使用ExecutorService的超时任务

Question

我已经使用ExecutorService实现了超时任务。在下面的方法中，我正在提交超时任务，如果它在给定的时间内超时，我将取消该任务并关闭执行器。

private boolean waitForProcessToBeCompleted(long timeOut) {
            boolean result = false;
            ExecutorService executor = Executors.newSingleThreadExecutor();
            // Create a FutureTask which will be run
            FutureTask<Boolean> futureTask = new FutureTask<Boolean>(new TimeoutTask());
            executor.submit(futureTask); // Run the FutureTask
            try {
                result = futureTask.get(timeOut, TimeUnit.MILLISECONDS); // Check if FutureTask completed in the given time
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                futureTask.cancel(true);
                result = true;  // Return True only when timed out
            } finally {
                executor.shutdownNow(); // Stop the executor
            }
            return result;
        }

它运行得很好，我没有任何问题。

然而，我想知道这是否是最好的代码设计。我只是想知道如果使用ExecutorService返回的未来是否会更好。submit（）获取可调用函数的返回值或超时超时任务。例如

            Future<?> futureTask = executor.submit(new TimeoutTask()); // Run the FutureTask
            try {
                result = futureTask.get(timeOut, TimeUnit.MILLISECONDS); // Check if FutureTask completed in the given time
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                futureTask.cancel(true);
                result = true;  // Return True only when timed out
            } finally {
                executor.shutdownNow(); // Stop the executor
            }
            return result;

我正在使用JDK7。

Answer 1

ExecutorService上的invokeAll方法可用于自动取消超过超时的任务。这使您可以在不关闭线程池的情况下取消任务（如果您愿意，也可以将同一线程池重新用于其他用途）。

private boolean waitForProcessToBeCompleted(long timeOut) {
  ExecutorService executor = Executors.newSingleThreadExecutor();
  List<FutureTask> tasks = new ArrayList<>();
  tasks.add(new SomeFutureTaskThing()));
  List<Future<Boolean>> results;
  try {
    results = executor.invokeAll(tasks, timeOut, TimeUnit.SECONDS);
  } catch (InterruptedException e) {
    Thread.currentThread().interrupt(); // Restore interrupt status.
    return null;
  } catch (ExecutionException e) {
    throw new RuntimeException(e.getCause());
  }
  Future<Boolean> result = results.get(0);
  try {
    return result.get();
  } catch (CancellationException e) {
    System.err.println("Timed out");
    return null;
  }
}

Answer 2

如果您查看futureTask的代码。取消，您将看到它只是试图中断正在执行任务的线程。如果任务定期显式或隐式检查中断标志（通过调用sleep（）或wait（）），则此中断可能有效。在Java中，没有其他安全的方法来停止方法的执行。

因此，可以实现相同的功能，而无需每次创建单独的单线程执行程序。取而代之的是，从waitForProcessToBeComplved方法中执行TimerWG。为了收到超时通知，请向SheduledExecutorService提交监视任务。监视任务应该中断执行TimerWork的线程。如果任务在超时前完成，则取消观看任务。

这样，您需要一个ScheduledExecutorService，但它只消耗很少的处理器周期，并且可以在整个应用程序中重用。

Answer 3

我更喜欢使用倒计时闩锁：

List<List<String>> elements = MyPartition.partition(bigObjectList, size); 
List<Future<?>> tasks = new ArrayList<Future<?>>();
ExecutorService executor = Executors.newSingleThreadExecutor();
CountDownLatch doneSignal =  new CountDownLatch(10);
for(List<String> l: elements) {         
   ReadTask worker = new ReadTask(doneSignal, l);
   tasks.add(executor.submit(worker));
}   

long timeout = 10000;
doneSignal.await(timeout, TimeUnit.SECONDS);
boolean notFinished = false;
if(doneSignal.getCount() > 0) {
  for(Future<?> fut : tasks) {
    if(!fut.isDone()) {
      System.out.println("Sub Thread " + fut + " has not finshed!");
      fut.cancel(true);             
      notFinished = true;
    }
  }
}