Java异步判断线程池所有任务是否执行完

大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们来讨论一下如何在Java中异步判断线程池中的所有任务是否执行完。线程池是Java并发编程中非常重要的一个工具，通过合理使用线程池，我们可以有效地管理和调度多线程任务。

我们将展示如何创建线程池，提交任务，并在任务完成时异步通知主线程。我们主要使用Java的ExecutorService、Future和CompletionService来实现这个功能。

1. 创建线程池

首先，我们需要创建一个线程池。在Java中，ExecutorService是一个非常方便的接口，提供了多种方法来管理和控制线程池。下面是一个简单的线程池创建示例：

package cn.juwatech.threadpool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    private ExecutorService executorService;

    public ThreadPoolExample(int poolSize) {
        executorService = Executors.newFixedThreadPool(poolSize);
    }

    public ExecutorService getExecutorService() {
        return executorService;
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.

2. 提交任务

接下来，我们需要将任务提交到线程池中。我们可以使用ExecutorService的submit方法来提交任务，并返回一个Future对象。Future对象可以用于检查任务的状态或获取任务的结果。

package cn.juwatech.task;

import java.util.concurrent.Callable;

public class SimpleTask implements Callable<String> {
    private final String taskName;

    public SimpleTask(String taskName) {
        this.taskName = taskName;
    }

    @Override
    public String call() throws Exception {
        // 模拟任务执行时间
        Thread.sleep(1000);
        return "Task " + taskName + " completed.";
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.

3. 异步判断任务完成

为了异步判断任务是否完成，我们可以使用CompletionService。CompletionService结合了Executor和BlockingQueue的功能，用于管理已完成的任务。我们可以使用ExecutorCompletionService来实现这一点。

package cn.juwatech.threadpool;

import cn.juwatech.task.SimpleTask;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class AsyncTaskCompletionExample {
    private final ExecutorService executorService;
    private final CompletionService<String> completionService;

    public AsyncTaskCompletionExample(int poolSize) {
        executorService = Executors.newFixedThreadPool(poolSize);
        completionService = new ExecutorCompletionService<>(executorService);
    }

    public void submitTasks(List<Callable<String>> tasks) {
        for (Callable<String> task : tasks) {
            completionService.submit(task);
        }
    }

    public void checkCompletion(int taskCount) {
        int completedTasks = 0;
        while (completedTasks < taskCount) {
            try {
                Future<String> resultFuture = completionService.take(); // 阻塞直到有一个任务完成
                String result = resultFuture.get();
                System.out.println(result);
                completedTasks++;
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
        System.out.println("所有任务都已完成。");
        executorService.shutdown();
    }

    public static void main(String[] args) {
        int poolSize = 5;
        int taskCount = 10;
        AsyncTaskCompletionExample example = new AsyncTaskCompletionExample(poolSize);

        List<Callable<String>> tasks = new ArrayList<>();
        for (int i = 1; i <= taskCount; i++) {
            tasks.add(new SimpleTask("Task" + i));
        }

        example.submitTasks(tasks);
        example.checkCompletion(taskCount);
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
  • 51.
  • 52.
  • 53.

4. 运行示例

在上面的代码中，我们创建了一个固定大小为5的线程池，并使用CompletionService来管理任务。我们提交了10个任务到线程池中，并使用checkCompletion方法来异步判断任务的完成状态。

执行main方法，输出如下：

Task Task1 completed.
Task Task2 completed.
Task Task3 completed.
Task Task4 completed.
Task Task5 completed.
Task Task6 completed.
Task Task7 completed.
Task Task8 completed.
Task Task9 completed.
Task Task10 completed.
所有任务都已完成。
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.

可以看到，所有任务都已经完成，并且我们通过CompletionService成功实现了异步判断任务完成的功能。

至此，我们已经完成了一个使用Java线程池和CompletionService来异步判断所有任务是否完成的示例。这个方法可以有效地管理多线程任务，并且能够在任务完成时及时通知主线程。

微赚淘客系统3.0小编出品，必属精品，转载请注明出处！