Java线程池非阻塞判断全部执行完任务

作为一名经验丰富的开发者,我很高兴能帮助你理解如何在Java中使用线程池并非阻塞地判断任务是否全部执行完成。以下是整个流程的详细说明。

流程图

flowchart TD
    A[开始] --> B[创建线程池]
    B --> C[提交任务]
    C --> D[判断任务是否完成]
    D --> E[任务完成]
    D --> F[任务未完成,继续等待]
    F --> D
    E --> G[结束]

步骤说明

  1. 创建线程池:首先,我们需要创建一个线程池,以便管理多个任务的执行。
  2. 提交任务:将任务提交到线程池中,线程池会根据需要自动分配线程来执行这些任务。
  3. 判断任务是否完成:在任务提交后,我们需要非阻塞地判断任务是否全部执行完成。
  4. 任务完成:如果所有任务都已完成,结束程序。
  5. 任务未完成:如果还有任务未完成,继续等待并重新判断。

代码实现

以下是使用Java实现上述流程的代码示例。

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 步骤1:创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // 步骤2:提交任务
        Future<?> future1 = executorService.submit(() -> {
            System.out.println("任务1开始执行");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务1执行完成");
        });

        Future<?> future2 = executorService.submit(() -> {
            System.out.println("任务2开始执行");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务2执行完成");
        });

        Future<?> future3 = executorService.submit(() -> {
            System.out.println("任务3开始执行");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务3执行完成");
        });

        // 步骤3:判断任务是否完成
        boolean isAllDone = true;
        while (isAllDone) {
            try {
                // 等待所有任务完成
                Thread.sleep(1000);
                isAllDone = !future1.isDone() || !future2.isDone() || !future3.isDone();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 步骤4:任务完成
        System.out.println("所有任务执行完成");

        // 关闭线程池
        executorService.shutdown();
    }
}
  • 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.
  • 54.
  • 55.
  • 56.
  • 57.
  • 58.
  • 59.
  • 60.
代码解释
  • Executors.newFixedThreadPool(3):创建一个包含3个线程的线程池。
  • executorService.submit(Runnable task):提交一个任务到线程池中执行。
  • future.isDone():检查任务是否完成。
  • Thread.sleep(1000):在循环中等待1秒,然后重新检查任务状态。

通过以上代码,我们可以非阻塞地判断线程池中的任务是否全部执行完成。希望这对你有所帮助!