Beispiel #1
0
 /* This is different from threadly's FutureUtils because
  * we want logging progress as futures complete...Since
  * these futures may take a VERY long time to complete.
  * The alternative would be to add runnables to these
  * so that we log out at 10% intervals, but that would assume
  * that the futures complete mostly in order.
  */
 public static void blockTillAllDone(List<Future<?>> futures) {
   float doneCount = 0;
   int lastReportedDonePercent = 0;
   Iterator<Future<?>> it = futures.iterator();
   while (it.hasNext()) {
     try {
       Future<?> f = it.next();
       if (!f.isDone() || !it.hasNext()) {
         // we take * 10 and / 10 so we can get one additional decimal of accuracy
         int donePercent = (int) Math.round((doneCount / futures.size()) * 100 * 10);
         if (donePercent != lastReportedDonePercent) {
           lastReportedDonePercent = donePercent;
           System.out.println("Progress: " + (donePercent / 10.) + "%");
         }
         f.get();
       }
       doneCount++;
     } catch (InterruptedException e) {
       ExceptionUtils.handleException(e);
       return; // let thread exit
     } catch (ExecutionException e) {
       ExceptionUtils.handleException(e);
     }
   }
 }
  /**
   * Internal tick implementation. Allowing control on if the cancelTick boolean should be reset if
   * no tasks are run. Thus allowing for an optimistic attempt to run tasks, while maintaining the
   * cancelTick state.
   *
   * @param exceptionHandler Exception handler implementation to call if any tasks throw an
   *     exception, or null to have exceptions thrown out of this call
   * @param resetCancelTickIfNoTasksRan if {@code true} will reset cancelTick weather tasks ran or
   *     not, otherwise cancelTick will only be reset if tasks ran
   * @return quantity of tasks run during this tick invocation
   */
  private int tick(
      ExceptionHandlerInterface exceptionHandler, boolean resetCancelTickIfNoTasksRan) {
    int tasks = 0;
    TaskContainer nextTask;
    while ((nextTask = getNextTask(true)) != null && !tickCanceled) {
      // call will remove task from queue, or reposition as necessary
      try {
        nextTask.runTask();
      } catch (Throwable t) {
        if (exceptionHandler != null) {
          exceptionHandler.handleException(t);
        } else {
          throw ExceptionUtils.makeRuntime(t);
        }
      }

      tasks++;
    }

    if ((tasks != 0 || resetCancelTickIfNoTasksRan) && tickCanceled) {
      // reset for future tick calls
      tickCanceled = false;
    }

    return tasks;
  }
    @Override
    public void run() {
      while (!stopped) {
        try {
          T next = getNext();

          acceptor.acceptConsumedItem(next);
        } catch (InterruptedException e) {
          stop();
        } catch (Throwable t) {
          ExceptionUtils.handleException(t);
        }
      }
    }