コード例 #1
0
  public void checkAndResumePsicquicTasks() {
    List<Future> currentRunningTasks = new ArrayList<Future>(runningTasks);

    for (Future<PsicquicCountResults> f : currentRunningTasks) {
      try {
        PsicquicCountResults results = f.get(threadTimeOut, TimeUnit.SECONDS);

        if (results.isImex()) {
          if (results.isImexResponding() && results.getImexCount() > 0) {
            countInOtherImexDatabases += results.getImexCount();
            otherImexDatabasesWithResults++;
          } else if (!results.isImexResponding()) {
            nonRespondingImexDatabases++;
          }
        }

        if (results.isServiceResponding() && results.getPsicquicCount() > 0) {
          countInOtherDatabases += results.getPsicquicCount();
          otherDatabasesWithResults++;
        } else if (!results.isServiceResponding()) {
          nonRespondingDatabases++;
        }

        runningTasks.remove(f);
      } catch (InterruptedException e) {
        log.error("The psicquic task was interrupted, we cancel the task.", e);
        this.nonRespondingDatabases++;
        this.nonRespondingImexDatabases++;
        if (!f.isCancelled()) {
          f.cancel(false);
        }
        runningTasks.remove(f);
      } catch (ExecutionException e) {
        log.error("The psicquic task could not be executed, we cancel the task.", e);
        if (!f.isCancelled()) {
          f.cancel(false);
        }
        runningTasks.remove(f);
      } catch (TimeoutException e) {
        log.error("Service task stopped because of time out " + threadTimeOut + "seconds.");
        this.nonRespondingDatabases++;
        this.nonRespondingImexDatabases++;

        if (!f.isCancelled()) {
          f.cancel(false);
        }
        runningTasks.remove(f);
      } catch (Throwable e) {
        log.error("The psicquic task could not be executed, we cancel the task.", e);
        if (!f.isCancelled()) {
          f.cancel(false);
        }
        runningTasks.remove(f);
      }
    }
  }
コード例 #2
0
 /** Closes any tasks currently in progress */
 @Override
 public void close() {
   isOpen.set(false);
   Iterator<Future<?>> iterator = futures.iterator();
   while (iterator.hasNext()) {
     Future<?> future = iterator.next();
     iterator.remove();
     if (!future.isDone() && !future.isCancelled() && !future.cancel(true)) {
       log.warn("Could not cancel " + future);
     }
   }
   if (shutdownOnClose) {
     executorService.shutdownNow();
   }
 }
コード例 #3
0
  @Test
  public void testCancellationAwareTask2() {
    Callable task1 = new CancellationAwareTask(5000);
    ExecutorService executor = createSingleNodeExecutorService("testCancellationAwareTask", 1);
    executor.submit(task1);

    Callable task2 = new BasicTestTask();
    Future future = executor.submit(task2);
    assertFalse(future.isDone());
    assertTrue(future.cancel(true));
    assertTrue(future.isCancelled());
    assertTrue(future.isDone());

    try {
      future.get();
      fail("Should not complete the task successfully");
    } catch (CancellationException expected) {
    } catch (Exception e) {
      fail("Unexpected exception " + e);
    }
  }
コード例 #4
0
  @Test
  public void testCancellationAwareTask() throws ExecutionException, InterruptedException {
    CancellationAwareTask task = new CancellationAwareTask(5000);
    ExecutorService executor = createSingleNodeExecutorService("testCancellationAwareTask");
    Future future = executor.submit(task);
    try {
      future.get(2, TimeUnit.SECONDS);
      fail("Should throw TimeoutException!");
    } catch (TimeoutException expected) {
    }
    assertFalse(future.isDone());
    assertTrue(future.cancel(true));
    assertTrue(future.isCancelled());
    assertTrue(future.isDone());

    try {
      future.get();
      fail("Should not complete the task successfully");
    } catch (CancellationException expected) {
    } catch (Exception e) {
      fail("Unexpected exception " + e);
    }
  }
コード例 #5
0
  @Test
  public void isCancelled_shouldReturnFalse_givenAFutureReturnedByExecute() throws Exception {
    Future<?> result = asyncExecutor.execute(() -> {});

    assertFalse(result.isCancelled());
  }
コード例 #6
0
 @Override
 public boolean isRunning() {
   return !task.isDone() && !task.isCancelled();
 }