如何判断线程池已经执行完所有任务了？

今天药忘吃喽~ 2023-09-29 09:24 16阅读 0赞

![0047bf0b8d0073a4b9ec45c7d24c3f0a.png][]

作者 | 磊哥

来源 | Java面试真题解析（ID：aimianshi666）

转载请联系授权（微信ID：GG\_Stone）

很多场景下，我们需要等待线程池的所有任务都执行完，然后再进行下一步操作。对于线程 Thread 来说，很好实现，加一个 join 方法就解决了，然而对于线程池的判断就比较麻烦了。

我们本文提供 4 种判断线程池任务是否执行完的方法：

1.  使用 isTerminated 方法判断。
2.  使用 getCompletedTaskCount 方法判断。
3.  使用 CountDownLatch 判断。
4.  使用 CyclicBarrier 判断。

接下来我们一个一个来看。

### 不判断的问题 ###

如果不对线程池是否已经执行完做判断，就会出现以下问题，如下代码所示：

import java.util.Random;
    import java.util.concurrent.LinkedBlockingDeque;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    public class ThreadPoolCompleted {
        public static void main(String[] args) {
            // 创建线程池
            ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 20,
                    0, TimeUnit.SECONDS, new LinkedBlockingDeque<>(1024));
            // 添加任务
            addTask(threadPool);
        // 打印结果
            System.out.println("线程池任务执行完成！");
        }
      
        /**
         * 给线程池添加任务
         */
        private static void addTask(ThreadPoolExecutor threadPool) {
            // 任务总数
            final int taskCount = 5;
            // 添加任务
            for (int i = 0; i < taskCount; i++) {
                final int finalI = i;
                threadPool.submit(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            // 随机休眠 0-4s
                            int sleepTime = new Random().nextInt(5);
                            TimeUnit.SECONDS.sleep(sleepTime);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(String.format("任务%d执行完成", finalI));
                    }
                });
            }
        }
    }

以上程序的执行结果如下：![3c46c3436d0368bce5a6695b15042598.png][]从上述执行结果可以看出，程序先打印了“线程池任务执行完成！”，然后还在陆续的执行线程池的任务，这种执行顺序混乱的结果，并不是我们期望的结果。我们想要的结果是等所有任务都执行完之后，再打印“线程池任务执行完成！”的信息。

> 产生以上问题的原因是因为主线程 main，和线程池是并发执行的，所以当线程池还没执行完，main 线程的打印结果代码就已经执行了。想要解决这个问题，就需要在打印结果之前，先判断线程池的任务是否已经全部执行完，如果没有执行完就等待任务执行完再执行打印结果。

### 方法1：isTerminated ###

我们可以利用线程池的终止状态（TERMINATED）来判断线程池的任务是否已经全部执行完，但想要线程池的状态发生改变，我们就需要调用线程池的 shutdown 方法，不然线程池一直会处于 RUNNING 运行状态，那就没办法使用终止状态来判断任务是否已经全部执行完了，它的实现代码如下：

import java.util.Random;
    import java.util.concurrent.LinkedBlockingDeque;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    /**
     * 线程池任务执行完成判断
     */
    public class ThreadPoolCompleted {
        public static void main(String[] args) {
            // 1.创建线程池
            ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 20,
                    0, TimeUnit.SECONDS, new LinkedBlockingDeque<>(1024));
            // 2.添加任务
            addTask(threadPool);
            // 3.判断线程池是否执行完
            isCompleted(threadPool); // 【核心调用方法】
            // 4.线程池执行完
            System.out.println();
            System.out.println("线程池任务执行完成！");
        }
    
        /**
         * 方法1：isTerminated 实现方式
         * 判断线程池的所有任务是否执行完
         */
        private static void isCompleted(ThreadPoolExecutor threadPool) {
            threadPool.shutdown();
            while (!threadPool.isTerminated()) { // 如果没有执行完就一直循环
            }
        }
    
        /**
         * 给线程池添加任务
         */
        private static void addTask(ThreadPoolExecutor threadPool) {
            // 任务总数
            final int taskCount = 5;
            // 添加任务
            for (int i = 0; i < taskCount; i++) {
                final int finalI = i;
                threadPool.submit(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            // 随机休眠 0-4s
                            int sleepTime = new Random().nextInt(5);
                            TimeUnit.SECONDS.sleep(sleepTime);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(String.format("任务%d执行完成", finalI));
                    }
                });
            }
        }
    }

> 方法说明：shutdown 方法是启动线程池有序关闭的方法，它在完全关闭之前会执行完之前所有已经提交的任务，并且不会再接受任何新任务。当线程池中的所有任务都执行完之后，线程池就进入了终止状态，调用 isTerminated 方法返回的结果就是 true 了。

以上程序的执行结果如下：![356563491e9e07f1059fdfa1e8ef35ed.png][]

##### 缺点分析 #####

需要关闭线程池。

##### 扩展：线程池的所有状态 #####

线程池总共包含以下 5 种状态：

*  RUNNING：运行状态。
 *  SHUTDOWN：关闭状态。
 *  STOP：阻断状态。
 *  TIDYING：整理状态。
 *  TERMINATED：终止状态。

![e7433971428d3a0e1301141fda980b3b.png][]如果不调用线程池的关闭方法，那么线程池会一直处于 RUNNING 运行状态。

### 方法2：getCompletedTaskCount ###

我们可以通过判断线程池中的计划执行任务数和已完成任务数，来判断线程池是否已经全部执行完，如果**计划执行任务数=已完成任务数**，那么线程池的任务就全部执行完了，否则就未执行完，具体实现代码如下：

/**
     * 方法2：getCompletedTaskCount 实现方式
     * 判断线程池的所有任务是否执行完
     */
    private static void isCompletedByTaskCount(ThreadPoolExecutor threadPool) {
        while (threadPool.getTaskCount() != threadPool.getCompletedTaskCount()) {
        }
    }

以上程序执行结果如下：![8ae86d1c95df3652f74015a1d00918e0.png][]

##### 方法说明 #####

*  getTaskCount()：返回计划执行的任务总数。由于任务和线程的状态可能在计算过程中动态变化，因此返回的值只是一个近似值。
 *  getCompletedTaskCount()：返回完成执行任务的总数。因为任务和线程的状态可能在计算过程中动态地改变，所以返回的值只是一个近似值，但是在连续的调用中并不会减少。

##### 优缺点分析 #####

此实现方法的优点是无需关闭线程池。它的缺点是 getTaskCount() 和 getCompletedTaskCount() 返回的是一个近似值，因为线程池中的任务和线程的状态可能在计算过程中动态变化，所以它们两个返回的都是一个近似值。

### 方法3：CountDownLatch ###

CountDownLatch 可以理解为一个计数器，我们创建了一个包含 N 个任务的计数器，每个任务执行完计数器 -1，直到计数器减为 0 时，说明所有的任务都执行完了，就可以执行下一段业务的代码了，它的实现流程如下图所示：![846603d82bd53d319be5a60a192db33a.gif][]具体实现代码如下：

public static void main(String[] args) throws InterruptedException {
        // 创建线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 20,
         0, TimeUnit.SECONDS, new LinkedBlockingDeque<>(1024));
        final int taskCount = 5;    // 任务总数
        // 单次计数器
        CountDownLatch countDownLatch = new CountDownLatch(taskCount); // ①
        // 添加任务
        for (int i = 0; i < taskCount; i++) {
            final int finalI = i;
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        // 随机休眠 0-4s
                        int sleepTime = new Random().nextInt(5);
                        TimeUnit.SECONDS.sleep(sleepTime);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(String.format("任务%d执行完成", finalI));
                    // 线程执行完，计数器 -1
                    countDownLatch.countDown();  // ②
                }
            });
        }
        // 阻塞等待线程池任务执行完
        countDownLatch.await();  // ③
        // 线程池执行完
        System.out.println();
        System.out.println("线程池任务执行完成！");
    }

> 代码说明：以上代码中标识为 ①、②、③ 的代码行是核心实现代码，其中：① 是声明一个包含了 5 个任务的计数器；② 是每个任务执行完之后计数器 -1；③ 是阻塞等待计数器 CountDownLatch 减为 0，表示任务都执行完了，可以执行 await 方法后面的业务代码了。

以上程序的执行结果如下：![56e71bfdf9cc28a6de8d8da3206b79e9.png][]

##### 优缺点分析 #####

CountDownLatch 写法很优雅，且无需关闭线程池，但它的缺点是只能使用一次，CountDownLatch 创建之后不能被重复使用，也就是说 CountDownLatch 可以理解为只能使用一次的计数器。

### 方法4：CyclicBarrier ###

CyclicBarrier 和 CountDownLatch 类似，它可以理解为一个可以重复使用的循环计数器，CyclicBarrier 可以调用 reset 方法将自己重置到初始状态，CyclicBarrier 具体实现代码如下：

public static void main(String[] args) throws InterruptedException {
        // 创建线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 20,
         0, TimeUnit.SECONDS, new LinkedBlockingDeque<>(1024));
        final int taskCount = 5;    // 任务总数
        // 循环计数器 ①
        CyclicBarrier cyclicBarrier = new CyclicBarrier(taskCount, new Runnable() {
            @Override
            public void run() {
                // 线程池执行完
                System.out.println();
                System.out.println("线程池所有任务已执行完！");
            }
        });
        // 添加任务
        for (int i = 0; i < taskCount; i++) {
            final int finalI = i;
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        // 随机休眠 0-4s
                        int sleepTime = new Random().nextInt(5);
                        TimeUnit.SECONDS.sleep(sleepTime);
                        System.out.println(String.format("任务%d执行完成", finalI));
                        // 线程执行完
                        cyclicBarrier.await(); // ②
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

以上程序的执行结果如下：![f4765a3dfdc1057f2c06e53d0c70948c.png][]

##### 方法说明 #####

CyclicBarrier 有 3 个重要的方法：

1.  构造方法：构造方法可以传递两个参数，参数 1 是计数器的数量 parties，参数 2 是计数器为 0 时，也就是任务都执行完之后可以执行的事件（方法）。
2.  await 方法：在 CyclicBarrier 上进行阻塞等待，当调用此方法时 CyclicBarrier 的内部计数器会 -1，直到发生以下情形之一：
    
    1.  在 CyclicBarrier 上等待的线程数量达到 parties，也就是计数器的声明数量时，则所有线程被释放，继续执行。
    2.  当前线程被中断，则抛出 InterruptedException 异常，并停止等待，继续执行。
    3.  其他等待的线程被中断，则当前线程抛出 BrokenBarrierException 异常，并停止等待，继续执行。
    4.  其他等待的线程超时，则当前线程抛出 BrokenBarrierException 异常，并停止等待，继续执行。
    5.  其他线程调用 CyclicBarrier.reset() 方法，则当前线程抛出 BrokenBarrierException 异常，并停止等待，继续执行。
3.  reset 方法：使得CyclicBarrier回归初始状态，直观来看它做了两件事：
    
    1.  如果有正在等待的线程，则会抛出 BrokenBarrierException 异常，且这些线程停止等待，继续执行。
    2.  将是否破损标志位 broken 置为 false。

##### 优缺点分析 #####

CyclicBarrier 从设计的复杂度到使用的复杂度都高于 CountDownLatch，相比于 CountDownLatch 来说它的优点是可以重复使用（只需调用 reset 就能恢复到初始状态），缺点是使用难度较高。

### 总结 ###

我们本文提供 4 种判断线程池任务是否执行完的方法：

1.  使用 isTerminated 方法判断：通过判断线程池的完成状态来实现，需要关闭线程池，一般情况下不建议使用。
2.  使用 getCompletedTaskCount 方法判断：通过计划执行总任务量和已经完成总任务量，来判断线程池的任务是否已经全部执行，如果相等则判定为全部执行完成。但因为线程个体和状态都会发生改变，所以得到的是一个大致的值，可能不准确。
3.  使用 CountDownLatch 判断：相当于一个线程安全的单次计数器，使用比较简单，且不需要关闭线程池，是**比较常用的判断方法**。
4.  使用 CyclicBarrier 判断：相当于一个线程安全的重复计数器，但使用较为复杂，所以日常项目中使用的较少。

> 是非审之于己，毁誉听之于人，得失安之于数。
> 
> 公众号：Java面试真题解析
> 
> 面试合集：https://gitee.com/mydb/interview

![e884e01951512dcb830408e9f387c640.gif][]

往期推荐

![31ceac5656415cd453ca746834a4c388.png][]

面试突击34：如何使用线程池执行定时任务？

![d3da4596c660fd3e400ddc2d5c895646.png][]

面试突击33：线程池有哪些状态？状态是如何转换的？

![7d7006d539ba1f699d4b48578be44433.png][]

面试突击32：为什么创建线程池一定要用ThreadPoolExecutor？

![1400d02f04840c02c7c9646fd49ae362.gif][]

[0047bf0b8d0073a4b9ec45c7d24c3f0a.png]: https://img-blog.csdnimg.cn/img_convert/0047bf0b8d0073a4b9ec45c7d24c3f0a.png
[3c46c3436d0368bce5a6695b15042598.png]: https://img-blog.csdnimg.cn/img_convert/3c46c3436d0368bce5a6695b15042598.png
[356563491e9e07f1059fdfa1e8ef35ed.png]: https://img-blog.csdnimg.cn/img_convert/356563491e9e07f1059fdfa1e8ef35ed.png
[e7433971428d3a0e1301141fda980b3b.png]: https://img-blog.csdnimg.cn/img_convert/e7433971428d3a0e1301141fda980b3b.png
[8ae86d1c95df3652f74015a1d00918e0.png]: https://img-blog.csdnimg.cn/img_convert/8ae86d1c95df3652f74015a1d00918e0.png
[846603d82bd53d319be5a60a192db33a.gif]: https://img-blog.csdnimg.cn/img_convert/846603d82bd53d319be5a60a192db33a.gif
[56e71bfdf9cc28a6de8d8da3206b79e9.png]: https://img-blog.csdnimg.cn/img_convert/56e71bfdf9cc28a6de8d8da3206b79e9.png
[f4765a3dfdc1057f2c06e53d0c70948c.png]: https://img-blog.csdnimg.cn/img_convert/f4765a3dfdc1057f2c06e53d0c70948c.png
[e884e01951512dcb830408e9f387c640.gif]: https://img-blog.csdnimg.cn/img_convert/e884e01951512dcb830408e9f387c640.gif
[31ceac5656415cd453ca746834a4c388.png]: https://img-blog.csdnimg.cn/img_convert/31ceac5656415cd453ca746834a4c388.png
[d3da4596c660fd3e400ddc2d5c895646.png]: https://img-blog.csdnimg.cn/img_convert/d3da4596c660fd3e400ddc2d5c895646.png
[7d7006d539ba1f699d4b48578be44433.png]: https://img-blog.csdnimg.cn/img_convert/7d7006d539ba1f699d4b48578be44433.png
[1400d02f04840c02c7c9646fd49ae362.gif]: https://img-blog.csdnimg.cn/img_convert/1400d02f04840c02c7c9646fd49ae362.gif