Exemplo n.º 1
1
 /**
  * Creates a new thread.
  *
  * @param r The runnable task.
  */
 public Thread newThread(Runnable r) {
   Thread result = new Thread(r);
   result.setName("Restlet-" + result.hashCode());
   result.setUncaughtExceptionHandler(new LoggingExceptionHandler());
   result.setDaemon(this.daemon);
   return result;
 }
Exemplo n.º 2
1
 @Override
 public Thread newThread(Runnable r) {
   Thread t = defaultFactory.newThread(r);
   t.setUncaughtExceptionHandler(handler);
   t.setDaemon(true); // daemonize the thread
   return t;
 }
Exemplo n.º 3
0
  @Override
  protected void cleanUpExamples(int epoch) {
    //		int n=0;
    for (int k = 0; k < nthreads; k++) {
      if (currentTrainingRun.queues.get(k).size() > 0) {
        //				n++;
        TrainerThread t = new TrainerThread(currentTrainingRun.queues.get(k), k);
        Thread th = new Thread(t, "xthread " + k);
        th.setDaemon(true);
        th.setUncaughtExceptionHandler(t);

        if (log.isDebugEnabled()) log.debug("Starting thread " + k);
        currentTrainingRun.threads.add(th);
        th.start();
      }
    }

    while (currentTrainingRun.threads.size() > 0) {
      try {
        Thread th = currentTrainingRun.threads.get(0);
        if (log.isDebugEnabled()) log.debug("Joining thread " + th.getName());
        th.join(); // will finish adding any new threads in uncaughtexceptionhandlers before
        // returning
        currentTrainingRun.threads.remove(0);
      } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    }
    currentTrainingRun.threads = null;
  }
Exemplo n.º 4
0
    @Override
    public void uncaughtException(Thread t, Throwable thrw) {
      // log warning for the exception
      StringWriter s = new StringWriter();
      s.write("Uncaught exception in thread " + t.getName() + ":\n");
      PrintWriter w = new PrintWriter(s);
      thrw.printStackTrace(w);
      log.warn(s.toString());
      try {
        s.close();
      } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }

      // resume work
      Thread th = new Thread(this, "Rxthread " + this.id);
      th.setDaemon(true);
      th.setUncaughtExceptionHandler(this);

      synchronized (currentTrainingRun.threads) {
        log.warn("Resuming thread " + t.getName() + " with " + th.getName());
        currentTrainingRun.threads.add(th); // don't want to join before thread has been started
        th.start();
      }
    }
Exemplo n.º 5
0
  public void onRemovePressed(final ContributedLibrary lib) {
    boolean managedByIndex = indexer.getIndex().getLibraries().contains(lib);

    if (!managedByIndex) {
      int chosenOption = JOptionPane.showConfirmDialog(this, _("This library is not listed on Library Manager. You won't be able to resinstall it from here.\nAre you sure you want to delete it?"), _("Please confirm library deletion"), JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE);
      if (chosenOption != JOptionPane.YES_OPTION) {
        return;
      }
    }

    clearErrorMessage();
    installerThread = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          setProgressVisible(true, _("Removing..."));
          installer.remove(lib);
          onIndexesUpdated(); // TODO: Do a better job in refreshing only the needed element
          //getContribModel().updateLibrary(lib);
        } catch (Exception e) {
          throw new RuntimeException(e);
        } finally {
          setProgressVisible(false, "");
        }
      }
    });
    installerThread.setUncaughtExceptionHandler(new InstallerJDialogUncaughtExceptionHandler(this, noConnectionErrorMessage));
    installerThread.start();
  }
    /**
     * @param thread the thread the task is running on
     * @param runnable the <code>Retriever</code> running on the thread
     * @throws IllegalArgumentException if either <code>thread</code> or <code>runnable</code> is
     *     null
     */
    @Override
    protected void beforeExecute(Thread thread, Runnable runnable) {
      if (thread == null) {
        String msg = Logging.getMessage("nullValue.ThreadIsNull");
        Logging.logger().fine(msg);
        throw new IllegalArgumentException(msg);
      }
      if (runnable == null) {
        String msg = Logging.getMessage("nullValue.RunnableIsNull");
        Logging.logger().fine(msg);
        throw new IllegalArgumentException(msg);
      }

      RetrievalTask task = (RetrievalTask) runnable;

      task.retriever.setBeginTime(System.currentTimeMillis());

      if (DownloaderRetrievalService.this.activeTasks.contains(task)) {
        // Task is a duplicate
        Logging.logger()
            .finer(
                Logging.getMessage(
                    "BasicRetrievalService.CancellingDuplicateRetrieval",
                    task.getRetriever().getName()));
        task.cancel(true);
      }

      DownloaderRetrievalService.this.activeTasks.add(task);

      thread.setName(RUNNING_THREAD_NAME_PREFIX + task.getRetriever().getName());
      thread.setPriority(Thread.MIN_PRIORITY); // Subordinate thread priority to rendering
      thread.setUncaughtExceptionHandler(DownloaderRetrievalService.this);

      super.beforeExecute(thread, runnable);
    }
Exemplo n.º 7
0
 @Override
 public Thread newThread(Runnable r) {
   Thread thread = new Thread(r);
   thread.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
   System.out.println("thread-id:" + thread.getId());
   return thread;
 }
 private void run(
     Runnable runnable, int numberOfRequests, final ConcurrentHashMap<String, Boolean> results)
     throws InterruptedException {
   Boolean finalResult = true;
   LOGGER.info("Tests start now!");
   final ArrayList<Thread> threads = new ArrayList<>();
   for (int i = 0; i < numberOfRequests; i++) {
     Thread t = new Thread(runnable, "pipeline" + i);
     threads.add(t);
   }
   for (Thread t : threads) {
     Thread.sleep(1000 * (new Random().nextInt(3) + 1));
     t.setUncaughtExceptionHandler(
         new Thread.UncaughtExceptionHandler() {
           public void uncaughtException(Thread t, Throwable e) {
             LOGGER.error("Exception " + e + " from thread " + t);
             results.put(t.getName(), false);
           }
         });
     t.start();
   }
   for (Thread t : threads) {
     int i = threads.indexOf(t);
     if (i == (numberOfRequests - 1)) {
       //                takeHeapDump(dumpDir, i);
     }
     t.join();
   }
   for (String threadId : results.keySet()) {
     finalResult = results.get(threadId) && finalResult;
   }
   assertThat(finalResult, is(true));
 }
Exemplo n.º 9
0
  public static void main(String[] args) {
    // 建立异常处理者
    ThreadExceptionHandler handler = new ThreadExceptionHandler();
    ThreadGroup threadGroup1 = new ThreadGroup("group1");

    Atom atom = new Atom(null, null, null);
    FutureTask<Object> transMgr = new FutureTask<Object>(atom);
    Thread t = new Thread(threadGroup1, transMgr);

    // 这是匿名类写法
    Thread thread1 =
        // 这个线程是threadGroup1的一员
        new Thread(
            threadGroup1,
            new Runnable() {
              public void run() {
                // 抛出unchecked异常
                throw new RuntimeException("测试异常");
              }
            });
    // 设置异常处理者
    thread1.setUncaughtExceptionHandler(handler);
    thread1.start();

    System.out.println(121221);
  }
Exemplo n.º 10
0
  /** Return a thread. */
  @Override
  public Thread newThread(Runnable r) {
    if (shutdown) return null;

    Runnable wrapper =
        new Runnable() {
          /** Keep track of non-daemon threads so shutdown can wait for their termination. */
          @Override
          public void run() {
            threads.fromNewToRunning(Thread.currentThread());

            r.run();
            /* If the task has thrown an exception, the code below is
             * not getting executed. The uncaughtException this.handler
             * removes the thread from the tracker list and notifies
             * the completer.
             */
            threads.removeRunning(Thread.currentThread());
            if (!hasActiveNonDaemonThreads()) completer.accept(ThreadFactoryTracker.this, null);
          }
        };

    Thread t = factory.newThread(wrapper);
    t.setName(t.getName() + "-" + threadName);
    t.setUncaughtExceptionHandler(handler);
    threads.addNew(t);
    return t;
  }
 @Override
 public void init() throws CoreException {
   String loggingId = retrieveConnection(AdaptrisConnection.class).getUniqueId();
   if (!isEmpty(loggingId)) {
     idForLogging = loggingId;
   } else {
     idForLogging =
         abbreviate(retrieveConnection(JmsConnection.class).getBrokerDetailsForLogging(), 20);
   }
   try {
     String s = "MockJmsConnectionErrorHandler";
     final String idForLogging = abbreviate(s, 20);
     MyExceptionHandler handler = new MyExceptionHandler();
     verifier = new MockJmsConnectionVerifier(idForLogging, new CountDownLatch(1));
     if (callback != null) {
       callback.register(verifier);
     }
     Thread verifierThread = new Thread(verifier);
     verifierThread.setUncaughtExceptionHandler(handler);
     verifierThread.start();
     if (additionalLogging()) {
       log.debug("ActiveJmsConnectionErrorHandler for " + idForLogging + " started");
     }
   } catch (Exception e) {
     throw new CoreException(e);
   }
 }
  @Test
  public void test() throws Exception {
    MmsClient c = createAndConnect();

    new Thread(
            () -> {
              while (received.size() < NUMBER_OF_MESSAGES) {
                rndSleep(300, TimeUnit.MILLISECONDS);
                t.closeIt();
              }
            })
        .start();

    final AtomicInteger ack = new AtomicInteger();

    Runnable server =
        new Runnable() {
          public void run() {
            int latestId = 0;
            Integer ackIt = null;
            while (received.size() < NUMBER_OF_MESSAGES) {
              Message tm = t.take(Message.class);

              if (tm instanceof Broadcast) {
                Broadcast bs = (Broadcast) tm;
                try {
                  BroadcastTestMessage hw = (BroadcastTestMessage) MmsMessage.tryRead(bs);
                  int id = hw.getId();
                  assertEquals(latestId++, id);
                  received.add(id);
                } catch (Exception e) {
                  e.printStackTrace();
                }
                ackIt = null;
              } else {
                if (ackIt == null) {
                  ackIt = ThreadLocalRandom.current().nextInt(ack.get(), latestId + 1);
                }
                ack.set(ackIt);
                latestId = ackIt;
                t.send(new Connected().setSessionId(BIN1).setLastReceivedMessageId((long) ackIt));
              }
            }
          }
        };
    Thread t = new Thread(server);
    t.setUncaughtExceptionHandler((a, b) -> b.printStackTrace());
    t.start();

    for (int i = 0; i < NUMBER_OF_MESSAGES; i++) {
      Thread.sleep(ThreadLocalRandom.current().nextLong(10));
      c.broadcast(new BroadcastTestMessage().setId(i));
    }

    while (received.size() < NUMBER_OF_MESSAGES) {
      Thread.sleep(10);
    }
  }
Exemplo n.º 13
0
  /**
   * start gvim with args using a ProcessBuilder and setup {@link #vc VimConnection} .
   *
   * @param args
   */
  private void start(String workingDir, boolean embedded, boolean tabbed, String... args) {
    if (!tabbed && vc != null && vc.isServerRunning()) {
      return;
    }

    VimPlugin plugin = VimPlugin.getDefault();

    if (vc == null || !vc.isServerRunning()) {
      vc = new VimConnection(ID);
      t = new Thread(vc);
      t.setUncaughtExceptionHandler(new VimExceptionHandler());
      t.setDaemon(true);
      t.start();
    }

    try {
      logger.debug("Trying to start vim");
      logger.debug(Arrays.toString(args));
      ProcessBuilder builder = new ProcessBuilder(args);
      /*java.util.Map<String, String> env = builder.environment();
      env.put("SPRO_GVIM_DEBUG", "/tmp/netbeans.log");
      env.put("SPRO_GVIM_DLEVEL", "0xffffffff");*/
      if (workingDir != null) {
        builder.directory(new File(workingDir));
      }

      p = builder.start();
      logger.debug("Started vim");
    } catch (IOException e) {
      logger.error("error:", e);
    }

    // Waits until server starts.. vim should return startupDone
    long maxTime = System.currentTimeMillis() + 10000L; // 10 seconds
    while (!vc.isServerRunning()) {
      if (System.currentTimeMillis() >= maxTime) {
        try {
          vc.close();
        } catch (Exception e) {
          logger.error("error:", e);
        }
        String message =
            plugin.getMessage("gvim.startup.failed", plugin.getMessage("gvim.startupDone.event"));
        throw new RuntimeException(message);
      }

      // sleep so that we don't have a messy cpu-hogging infinite loop
      // here
      long stoptime = 2000L; // 2 Seconds
      logger.debug("Waiting to connect to vim server");
      try {
        Thread.sleep(stoptime);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
    this.embedded = embedded;
  }
Exemplo n.º 14
0
 @Override
 public Thread newThread(Runnable r) {
   Thread t =
       new Thread(
           r, String.format("webcam-panel-scheduled-executor-%d", number.incrementAndGet()));
   t.setUncaughtExceptionHandler(WebcamExceptionHandler.getInstance());
   t.setDaemon(true);
   return t;
 }
  /**
   * Handles each person of the given <code>population</code> with a AbstractPersonAlgorithm
   * provided by <code>algoProvider</code>, using up to <code>numberOfThreads</code> threads to
   * speed things up. This method will request a new instance of the AbstractPersonAlgorithm for
   * each thread it allocates, thus enabling the parallel use of non-thread-safe algorithms. For
   * thread-safe algorithms, {@link #run(Population, int, AbstractPersonAlgorithm)} may be an easier
   * method to use.
   *
   * @param population
   * @param numberOfThreads
   * @param algoProvider
   */
  public static void run(
      final Population population,
      final int numberOfThreads,
      final PersonAlgorithmProvider algoProvider) {
    int numOfThreads =
        Math.max(
            numberOfThreads,
            1); // it should be at least 1 here; we allow 0 in other places for "no threads"
    PersonAlgoThread[] algoThreads = new PersonAlgoThread[numOfThreads];
    Thread[] threads = new Thread[numOfThreads];
    String name = null;
    Counter counter = null;

    final AtomicBoolean hadException = new AtomicBoolean(false);
    final ExceptionHandler uncaughtExceptionHandler = new ExceptionHandler(hadException);

    // setup threads
    for (int i = 0; i < numOfThreads; i++) {
      PersonAlgorithm algo = algoProvider.getPersonAlgorithm();
      if (i == 0) {
        name = algo.getClass().getSimpleName();
        counter = new Counter("[" + name + "] handled person # ");
      }
      PersonAlgoThread algothread = new PersonAlgoThread(algo, counter);
      Thread thread = new Thread(algothread, name + "." + i);
      thread.setUncaughtExceptionHandler(uncaughtExceptionHandler);
      threads[i] = thread;
      algoThreads[i] = algothread;
    }

    // distribute workload between threads, as long as threads are not yet started, so we don't need
    // synchronized data structures
    int i = 0;
    for (Person person : population.getPersons().values()) {
      algoThreads[i % numOfThreads].handlePerson(person);
      i++;
    }

    // start the threads
    for (Thread thread : threads) {
      thread.start();
    }

    // wait for the threads to finish
    try {
      for (Thread thread : threads) {
        thread.join();
      }
      counter.printCounter();
    } catch (InterruptedException e) {
      throw new RuntimeException(e);
    }
    if (hadException.get()) {
      throw new RuntimeException(
          "Exception while processing persons. Cannot guarantee that all persons have been fully processed.");
    }
  }
Exemplo n.º 16
0
 @Override
 public Thread newThread(Runnable runnable) {
   Thread thread = Executors.defaultThreadFactory().newThread(runnable);
   thread.setName(name + "-" + count.incrementAndGet());
   if (exceptionHandler != null) {
     thread.setUncaughtExceptionHandler(exceptionHandler);
   }
   return thread;
 }
  @Override
  public Thread newThread(Runnable runnable) {
    Thread thread = _threadFactory.newThread(runnable);

    thread.setUncaughtExceptionHandler(_recordUncaughtExceptionHandler);

    _createdThreads.add(thread);

    return thread;
  }
  @Override
  public Thread newThread(final Runnable adapter) {
    assert null != adapter : "Parameter 'adapter' of method 'newThread' must not be null";

    final Thread thread = new Thread(adapter);
    thread.setName("Feature Adapter");
    thread.setPriority(Thread.MIN_PRIORITY);
    thread.setUncaughtExceptionHandler(this);
    return thread;
  }
Exemplo n.º 19
0
 /**
  * Create a new thread
  *
  * @param name The name of the thread
  * @param runnable The work for the thread to do
  * @param daemon Should the thread block JVM shutdown?
  * @return The unstarted thread
  */
 public static Thread newThread(String name, Runnable runnable, Boolean daemon) {
   Thread thread = new Thread(runnable, name);
   thread.setDaemon(daemon);
   thread.setUncaughtExceptionHandler(
       new Thread.UncaughtExceptionHandler() {
         public void uncaughtException(Thread t, Throwable e) {
           log.error("Uncaught exception in thread '" + t.getName() + "':", e);
         }
       });
   return thread;
 }
 private Thread createThread(Runnable runnable, String name) throws InterruptedException {
   Thread thread = new Thread(runnable, name);
   thread.setUncaughtExceptionHandler(
       new Thread.UncaughtExceptionHandler() {
         public void uncaughtException(Thread t, Throwable e) {
           e.printStackTrace();
           throw new RuntimeException(e.getMessage(), e);
         }
       });
   return thread;
 }
Exemplo n.º 21
0
 @Override
 public Thread newThread(Runnable r) {
   Thread thread = new Thread(r, QUERY_POOL_NAME + "-" + suffix.incrementAndGet());
   thread.setUncaughtExceptionHandler(
       new Thread.UncaughtExceptionHandler() {
         @Override
         public void uncaughtException(Thread t, Throwable e) {
           LOGGER.error("UNCAUGHT exception in thread " + t.getName(), e);
         }
       });
   return thread;
 }
Exemplo n.º 22
0
 public void connect(SocketChannelHandler handler) {
   this.handler = handler;
   consumer.setUncaughtExceptionHandler(
       new UncaughtExceptionHandler() {
         @Override
         public void uncaughtException(Thread t, Throwable e) {
           log.warn(String.format("Uncaught exception on %s", t), e);
         }
       });
   consumer.setDaemon(true);
   consumer.start();
   fsm.connect();
 }
Exemplo n.º 23
0
 public void onReady(ReadyEvent event) {
   log("Setting up api related config...");
   Thread t =
       new Thread(
           () -> {
             TagCommand.initTags(event.getJDA(), logger);
             PublicLog.init(api, logger::logThrowable);
             this.api = event.getJDA();
             if (config.has("home")) home = api.getGuildById(config.getString("home"));
             new ModLogManager(api);
             User uOwner = api.getUserById(owner);
             try {
               log("Owner: " + uOwner.getUsername() + "#" + uOwner.getDiscriminator());
             } catch (NullPointerException e) {
               logger.logThrowable(
                   new NullPointerException(
                       "Owner could not be retrieved from the given id. Do you share a guild with this bot? - Caused by id: \""
                           + owner
                           + "\""));
             }
             this.handler.setApi(event.getJDA());
             try {
               initCommands(api);
             } catch (UnknownHostException | UnsupportedDataTypeException e) {
               logger.logThrowable(e);
             }
             AccountSettings as = new AccountSettings(console);
             console.setAccountSettings(as);
             as.setApi(api);
             if (audio) api.addEventListener(new MinnAudioManager());
             console.setTitle(
                 api.getSelfInfo().getUsername()
                     + "#"
                     + api.getSelfInfo()
                         .getDiscriminator()); // so you know which one is logged in!
             inviteurl = getInviteUrl();
             tmp.init(this);
             logger.logInfo("Setup completed.");
           });
   t.setDaemon(false);
   t.setPriority(Thread.MAX_PRIORITY);
   t.setName("onReady...");
   t.setUncaughtExceptionHandler((Thread.UncaughtExceptionHandler) logger);
   t.start();
 }
  /**
   * Main method of the example. Initialize a Thread to process the uncaught exceptions and starts a
   * Task object that always throws an exception
   *
   * @param args
   */
  public static void main(String[] args) {
    // Creates the Task
    Task task = new Task();
    // Creates the Thread
    Thread thread = new Thread(task);
    // Sets de uncaugh exceptio handler
    thread.setUncaughtExceptionHandler(new ExceptionHandler());
    // Starts the Thread
    thread.start();

    try {
      thread.join();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    System.out.printf("Thread has finished\n");
  }
  /**
   * <a href="https://issues.apache.org/jira/browse/WICKET-3769">WICKET-3769</a>
   *
   * @throws Exception
   */
  @Test
  public void applicationAndSessionAreExported() throws Exception {
    // bind the session so it can be found in TestSessionFilter
    tester.getSession().bind();

    // execute TestSessionFilter in different thread so that the Application and the Session are
    // not set by WicketTester
    Thread testThread =
        new Thread(
            new Runnable() {
              public void run() {
                try {
                  TestSessionFilter sessionFilter = new TestSessionFilter(tester);

                  Assert.assertFalse(Application.exists());
                  Assert.assertFalse(Session.exists());

                  sessionFilter.doFilter(
                      tester.getRequest(), tester.getResponse(), new TestFilterChain());

                  Assert.assertFalse(Application.exists());
                  Assert.assertFalse(Session.exists());

                } catch (Exception e) {
                  throw new RuntimeException(e.getMessage(), e);
                }
              }
            });

    final StringBuilder failMessage = new StringBuilder();
    final AtomicBoolean passed = new AtomicBoolean(true);

    testThread.setUncaughtExceptionHandler(
        new UncaughtExceptionHandler() {
          public void uncaughtException(Thread t, Throwable e) {
            failMessage.append(e.getMessage());
            passed.set(false);
          }
        });
    testThread.start();
    testThread.join(Duration.seconds(1).getMilliseconds());

    Assert.assertTrue(failMessage.toString(), passed.get());
  }
Exemplo n.º 26
0
  /**
   * Initializes the specified thread. This method is called by {@link #newThread(Runnable)} after a
   * new thread has been obtained from the wrapped thread factory. It initializes the thread
   * according to the options set for this factory.
   *
   * @param t the thread to be initialized
   */
  private void initializeThread(final Thread t) {

    if (getNamingPattern() != null) {
      final Long count = Long.valueOf(threadCounter.incrementAndGet());
      t.setName(String.format(getNamingPattern(), count));
    }

    if (getUncaughtExceptionHandler() != null) {
      t.setUncaughtExceptionHandler(getUncaughtExceptionHandler());
    }

    if (getPriority() != null) {
      t.setPriority(getPriority().intValue());
    }

    if (getDaemonFlag() != null) {
      t.setDaemon(getDaemonFlag().booleanValue());
    }
  }
Exemplo n.º 27
0
  private Context run(
      ClassLoader classLoader,
      final String classpath,
      final String mainClass,
      final String[] args,
      final Properties properties) {
    Properties contextProperties = new Properties();
    contextProperties.putAll(commonSystemProperties);
    contextProperties.putAll(properties);

    final Context context = new Context(classLoader, contextProperties);

    Thread thread =
        new Thread() {
          @Override
          public void run() {
            currentContext.set(context);
            context.setProperty("java.class.path", classpath);

            try {
              runMain(loadClass(mainClass), args);
            } catch (InterruptedException e) {
              Thread.currentThread().interrupt();
            } catch (MainClassNotFoundException e) {
              context.setException(e);
            } catch (Throwable e) {
              getUncaughtExceptionHandler().uncaughtException(this, e);
            }
          }
        };

    context.setMainThread(thread);
    thread.setUncaughtExceptionHandler(
        new Thread.UncaughtExceptionHandler() {
          @Override
          public void uncaughtException(Thread t, Throwable e) {
            context.setException(e);
          }
        });
    thread.setContextClassLoader(classLoader);
    thread.start();
    return context;
  }
Exemplo n.º 28
0
 public void onInstallPressed(final ContributedLibrary lib, final ContributedLibrary replaced) {
   clearErrorMessage();
   installerThread = new Thread(new Runnable() {
     @Override
     public void run() {
       try {
         setProgressVisible(true, _("Installing..."));
         installer.install(lib, replaced);
         onIndexesUpdated(); // TODO: Do a better job in refreshing only the needed element
         //getContribModel().updateLibrary(lib);
       } catch (Exception e) {
         throw new RuntimeException(e);
       } finally {
         setProgressVisible(false, "");
       }
     }
   });
   installerThread.setUncaughtExceptionHandler(new InstallerJDialogUncaughtExceptionHandler(this, noConnectionErrorMessage));
   installerThread.start();
 }
Exemplo n.º 29
0
 @Override
 protected void onUpdatePressed() {
   super.onUpdatePressed();
   installerThread = new Thread(new Runnable() {
     @Override
     public void run() {
       try {
         setProgressVisible(true, "");
         installer.updateIndex();
         onIndexesUpdated();
       } catch (Exception e) {
         throw new RuntimeException(e);
       } finally {
         setProgressVisible(false, "");
       }
     }
   });
   installerThread.setUncaughtExceptionHandler(new InstallerJDialogUncaughtExceptionHandler(this, noConnectionErrorMessage));
   installerThread.start();
 }
Exemplo n.º 30
0
  @Override
  public void frameBufferUpdateRequest(
      final RFBClient client, boolean incremental, int x, int y, int w, int h) throws IOException {
    // TODO Auto-generated method stub
    //		host.getWindow().getDecorView().getViewTreeObserver().removeOnPreDrawListener(this);
    //		host.getWindow().getDecorView().getViewTreeObserver().addOnPreDrawListener(this);
    //		updateAttempts = 3;
    // sendWholeScreen(client);

    Thread t =
        new Thread() {

          @Override
          public void run() {
            while (true) {
              try {
                sendWholeScreen(client);
                Thread.sleep(40);
              } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
              } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
              }
            }
          }
        };
    t.setName("loop update thread");
    t.setUncaughtExceptionHandler(
        new Thread.UncaughtExceptionHandler() {

          @Override
          public void uncaughtException(Thread thread, Throwable ex) {
            // TODO Auto-generated method stub
            // thread.start();
          }
        });
    t.start();
  }