等待 ExecutorService.execute 中的所有任务完成

Question

使用提交时如何等待所有任务完成
ExecutorService.execute() 。 有一个名为 awaitTermination 的function
但是必须在其中提供超时。 这不能保证当这
返回所有任务将已完成。 有没有办法做到这一点？

Answer 1

如果您阅读ExecutorService.awaitTermination的 javadoc（或查看方法签名），您将看到它返回boolean 。 这个 boolean 指示Executor是否终止。 您可以使用该信息创建一个while循环以确定它是否已终止。

ExecutorService executor = ...

executor.shutdown(); // close the executor and don't accept new tasks

while (!executor.awaitTermination(100, TimeUnit.MILLISECONDS) {}

像这样的东西会停止执行器并等到它终止并且所有任务都完成。

Answer 2

执行方法不返回任何东西。 您可以使用返回 Future 类型结果的submit方法。

Future<String> future = 
  executorService.submit(callableTask/runnableTask);

Answer 3

如果您使用 class ThreadPoolExecutor或其任何子项，则您有一个getActiveCount()方法，该方法返回正在执行任务的线程数。 因此，您可以轮询该方法，直到它变为 0，这意味着所有任务都已完成并且当前没有新任务正在执行。 但是，如果某些任务卡住了怎么办？ 我认为您还必须给出一些超时时间，以防止在这种情况下出现无限循环。

这个想法的最大优点是您不需要调用关闭方法

Answer 4

有几种方法。

您可以先调用ExecutorService.shutdown ，然后调用ExecutorService.awaitTermination ，它会返回：

如果此执行程序终止，则为 true；如果在终止前超时，则为 false

所以：

有一个名为 awaitTermination 的 function 但必须在其中提供超时。 这并不能保证当它返回时所有任务都会完成。 有没有办法做到这一点？

您只需要循环调用awaitTermination 。

使用 awaitTermination

此实现的完整示例：

public class WaitForAllToEnd {

    public static void main(String[] args) throws InterruptedException {
        final int total_threads = 4;
        ExecutorService executor = Executors.newFixedThreadPool(total_threads);
        for(int i = 0; i < total_threads; i++){
            executor.execute(parallelWork(100 + i * 100));
        }

        int count = 0;

        // This is the relevant part
        // Chose the delay most appropriate for your use case
        executor.shutdown();
        while (!executor.awaitTermination(100, TimeUnit.MILLISECONDS)) {
            System.out.println("Waiting "+ count);
            count++;
        }
    }

    private static Runnable parallelWork(long sleepMillis) {
        return () -> {
            try {
                Thread.sleep(sleepMillis);
            } catch (InterruptedException e) {
                // Do Something
            }
            System.out.println("I am Thread : " + Thread.currentThread().getId());
        };
    }
}

使用 CountDownLatch

另一种选择是创建一个count等于并行任务数的CountDownLatch 。 每个线程调用countDownLatch.countDown(); , 而主线程调用countDownLatch.await(); .

此实现的完整示例：

public class WaitForAllToEnd {

    public static void main(String[] args) throws InterruptedException {
        final int total_threads = 4;
        CountDownLatch countDownLatch = new CountDownLatch(total_threads);
        ExecutorService executor = Executors.newFixedThreadPool(total_threads);
        for(int i = 0; i < total_threads; i++){
            executor.execute(parallelWork(100 + i * 100, countDownLatch));
        }
        countDownLatch.await();
        System.out.println("Exit");
        executor.shutdown();
    }

    private static Runnable parallelWork(long sleepMillis, CountDownLatch countDownLatch) {
        return () -> {
            try {
                Thread.sleep(sleepMillis);
            } catch (InterruptedException e) {
                // Do Something
            }
            System.out.println("I am Thread : " + Thread.currentThread().getId());
            countDownLatch.countDown();
        };
    }
}

使用循环障碍

另一种方法是使用循环障碍

public class WaitForAllToEnd {

    public static void main(String[] args) throws InterruptedException, BrokenBarrierException {
        final int total_threads = 4;
        CyclicBarrier barrier = new CyclicBarrier(total_threads+ 1);
        ExecutorService executor = Executors.newFixedThreadPool(total_threads);
        for(int i = 0; i < total_threads; i++){
            executor.execute(parallelWork(100 + i * 100, barrier));
        }
        barrier.await();
        System.out.println("Exit");
        executor.shutdown();
    }

    private static Runnable parallelWork(long sleepMillis, CyclicBarrier barrier) {
        return () -> {
            try {
                Thread.sleep(sleepMillis);
            } catch (InterruptedException e) {
                // Do Something
            }
            System.out.println("I am Thread : " + Thread.currentThread().getId());
            try {
                barrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
              // Do something
            }
        };
    }
}

还有其他方法，但这些方法需要更改您的初始要求，即：

使用 ExecutorService.execute() 提交所有任务时如何等待它们完成。