1. 前言🔥

多线程编程在现代软件开发中非常常见且重要，而线程池是多线程编程的常用技术。在使用线程池时，通常需要判断线程池中的任务是否全部完成，以便决定程序继续执行的下一步操作。本文将介绍5种判断线程池任务是否全部完成的方案，帮助开发者解决这一问题。

所以呢，你们打算怎么处理？这将又会是干货满满的一期，全程无尿点不废话只抓重点教，具有非常好的学习效果，拿好小板凳准备就坐！希望学习的过程中大家认真听好好学，学习的途中有任何不清楚或疑问的地方皆可评论区留言或私信，bug菌将第一时间给予解惑，那么废话不多说，直接开整！Fighting！！

2. 环境说明🔥

本地的开发环境：

开发工具：IDEA 2021.3

JDK版本： JDK 1.8

Spring Boot版本：2.3.1 RELEASE

Maven版本：3.8.2

3. 正文🔥

3.1 需求分析

前言提到采用线程池来并发处理多个sql查询，其实使用线程池不麻烦，麻烦的是你要通过什么方式去统计线程池中的任务都被执行，何为都执行完了？其实这也很理解，无非你就是要把握一个点，判断【计划执行任务数】是否等于【已完成任务数】即可，如果相等则说明线程池中的任务全被执行掉了，反之就是未执行完。

那么你就朝着这个方向去思考，有那些方式可以算出【计划执行任务数】与【已完成任务数】这两个量值？

3.2 实现概述

统计线程池中的任务是否被全执行完的方法其实有很多很多，我给大家举几个例子：

使用 getCompletedTaskCount() 统计出【已完成任务数】和使用Java线程池中的getTaskCount() 方法来获取【总任务数】，二者进行对比即可。
使用 FutureTask对象，等待所有任务都执行完，线程池的任务就都执行完了。
使用 CountDownLatch对象或 CyclicBarrier对象，等待所有线程都执行完之后，再执行后续流程，计数。
使用isTerminated() 方法。利用线程池的终止状态（TERMINATED）来判断线程池的任务是否已经全部执行完，但想要线程池的状态发生改变，就需要调用线程池的 shutdown() 方法，不然线程池一直会处于 RUNNING 运行状态，那就没办法使用终止状态来判断任务是否已经全部执行完了，shutdown() 方法是启动线程池有序关闭的方法，它在完全关闭之前会执行完之前所有已经提交的任务，并且不会再接受任何新任务。当线程池中的所有任务都执行完之后，线程池就进入了终止状态，调用 isTerminated() 方法返回的结果就是 true 了,以这点作为依据来判断即可。
...

如果你有其他的点子，欢迎评论区交流学习。

3.3 实现方案

3.3.1 统计完成已完成任务数

这里通过使用getCompletedTaskCount()和getTaskCount() 方法分别统计出统计出【已完成任务数】和【总任务数】，如果相等则说明线程池的任务执行完了，否则既未执行完。

示例代码如下：

java 复制代码

    //校验计划执行任务数 ?= 已完成任务数
    private static void isCompletedByTaskCount(ThreadPoolExecutor threadPool) {
        while (threadPool.getTaskCount() != threadPool.getCompletedTaskCount()) {
        }
    }

具体演示代码如下：

java 复制代码

package com.example.demo.component.threadPool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class CountThreadTask {
    //创建一个最大线程数100的线程池
    private static ExecutorService es =
            new ThreadPoolExecutor(3, 100, 0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<Runnable>(100));


    public static void main(String[] args) throws Exception {
        for (int i = 1; i <= 10; i++) {
            int finalI = i;
            es.execute(() -> { //提交执行
                System.out.println("线程" + finalI + "执行完成！");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        ThreadPoolExecutor threadPool = ((ThreadPoolExecutor) es);
        System.out.println("线程池任务总数量："+threadPool.getTaskCount());
        System.out.println("---------线程池开始执行-----------");
        while (true) {
            if (threadPool.getTaskCount() == threadPool.getCompletedTaskCount()) {
                System.out.println("---------线程池执行完了-----------");
                break;
            }
            //间隔2s查询一次
            Thread.sleep(2000);
            System.out.println("线程池还未执行完，敬请等待！已完成的任务数量："+threadPool.getCompletedTaskCount());
        }
        
    }

}

执行main函数，结果控制台打印示例如下，仅供参考：

方法说明及拓展：

getTaskCount()：返回线程池计划执行的任务总数。注意：由于任务和线程的状态可能在计算过程中动态变化，因此该方法返回值只是一个近似值，不是精准的。
getCompletedTaskCount()：返回线程池中已完成的任务数，注意：跟getTaskCount()方法一致，该方法返回值也是一个近似值。
getPoolSize()：返回线程池当前的线程数量。
getActiveCount()：返回当前线程池中正在执行任务的线程数量。

方式总结：

由于getTaskCount() 与 getCompletedTaskCount()方法返回值都是一个近似值而不是精确值，固结果可能有一定的偏差，这也是该方式的一大缺点。

3.3.2 使用 FutureTask

与方式1不同的是，FutrueTask 可以弥补它的弊端，使用它可以精准获取任务结果，调用每个 FutrueTask 对象的 get() 方法就是等待该任务执行完，如下代码所示：

java 复制代码

package com.example.demo.component.threadPool;

import java.util.concurrent.*;

/**
 * 使用 FutrueTask 等待线程池执行完全部任务
 */
public class FutureTaskTask {
    
    //创建一个最大线程数100的线程池
    private static ExecutorService es =
            new ThreadPoolExecutor(4, 100, 0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<Runnable>(100));

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        // 创建任务1
        FutureTask<Integer> task1 = new FutureTask<>(() -> {
            System.out.println("---Task 1 开始执行---");
            Thread.sleep(2000);
            System.out.println("------Task 1 执行结束------");
            return 1;
        });
        // 创建任务2
        FutureTask<Integer> task2 = new FutureTask<>(() -> {
            System.out.println("---Task 2 开始执行---");
            Thread.sleep(3000);
            System.out.println("------Task 2 执行结束------");
            return 2;
        });
        // 创建任务3
        FutureTask<Integer> task3 = new FutureTask<>(() -> {
            System.out.println("---Task 3 开始执行---");
            Thread.sleep(1000);
            System.out.println("------Task 3 执行结束------");
            return 3;
        });
        // 创建任务4
        FutureTask<Integer> task4 = new FutureTask<>(() -> {
            System.out.println("---Task 4 开始执行---");
            Thread.sleep(500);
            System.out.println("------Task 4 执行结束------");
            return 4;
        });
        // 提交4个任务给线程池
        es.submit(task1);
        es.submit(task2);
        es.submit(task3);
        es.submit(task4);

        // 等待所有任务执行完毕
        task1.get();
        task2.get();
        task3.get();
        task4.get();

        //执行完毕
        System.out.println("线程池执行完了！");
    }
}

执行main函数，结果控制台打印示例如下，仅供参考：

3.3.3 使用CountDownLatch

CountDownLatch身为同步工具类，作用之一可协调多个线程之间的同步，或者说接通线程之间的通信（而不是互斥）。CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后再继续执行。其中，计数器初始值为全线程的数量，当每一个线程完成自己任务后，计数器的值就会自动减1；当计数器的值 = 0时，表示所有的线程都已经完成一些任务，然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。

接下来给大家演示下，如何巧妙利用CountDownLatch达到统计线程池所有线程都被执行完的需求？请看示例代码:

java 复制代码

package com.example.demo.component.threadPool;

import java.util.concurrent.*;

/**
 * 使用CountDownLatch
 */
public class CountDownLatchTask {

    //创建一个最大线程数100的线程池
    private static ExecutorService es =
            new ThreadPoolExecutor(1, 100, 0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<Runnable>(100));

    public static void main(String[] args) throws Exception {
        //计数器，判断线程是否执行结束
        //初始值为10
        CountDownLatch taskLatch = new CountDownLatch(10);
        for (int i = 0; i < 10; i++) {
            es.execute(() -> { //提交执行
                taskLatch.countDown();
                System.out.println("当前计数器值为：" + taskLatch.getCount());
                try {
                    //模拟线程执行方法，执行1s
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        //当前线程阻塞，等待计数器置为0
        taskLatch.await();
        System.out.println("线程池执行完了！");
    }


}

执行main函数，结果控制台打印示例如下，仅供参考：

方式总结：

虽然使用CountDownLatch可达到统计线程是否被执行完，该方式使用起来代码简洁优雅，不需要对线程池进行操作。但由于CountDownLatch是一次性的，计数器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当CountDownLatch使用完毕后，它不能再次被使用。

3.3.4 使用CyclicBarrier

CyclicBarrier 和 CountDownLatch 类似，你可以把它理解为一个可以重复使用的循环计数器，CyclicBarrier 可调用 reset() 方法将自己重置到初始状态,这是与CountDownLatch不一样的特性，那具体如何使用CyclicBarrier达到统计线程池所有线程都被执行完的需求吧，具体实现代码如下，仅供参考：

java 复制代码

package com.example.demo.component.threadPool;

import java.util.Random;
import java.util.concurrent.*;

/**
 * 使用CyclicBarrier
 */
public class CyclicBarrierTask {

    //创建一个最大线程数100的线程池
    private static ExecutorService es =
            new ThreadPoolExecutor(5, 100, 0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<Runnable>(100));

    public static void main(String[] args) throws InterruptedException {

        //任务总数
        final int taskCount = 5;
        //循环计数器
        CyclicBarrier cyclicBarrier = new CyclicBarrier(taskCount, new Runnable() {
            @Override
            public void run() {
                // 线程池执行完
                System.out.println("---------线程池执行完了-----------");
            }
        });

        // 添加任务
        for (int i = 0; i < taskCount; i++) {
            final int finalI = i;
            es.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        //随机休眠1-4秒
                        TimeUnit.SECONDS.sleep(new Random().nextInt(5));
                        System.out.println("任务" + finalI + "执行完成");
                        // 线程执行完
                        cyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

执行main函数，结果控制台打印示例如下，仅供参考：

3.3.5 使用isTerminated()

使用线程池的 isTerminated() 方法，在执行 shutdown() 进行线程池的关闭后，隔间调用isTerminated()判断线程池中的所有任务是否已经完成即可。那具体如何使用 isTerminated() 方法达到统计线程池所有线程都被执行完的需求吧，具体实现代码如下，仅供参考：

java 复制代码

package com.example.demo.component.threadPool;

import java.util.concurrent.*;

/**
 * 使用isTerminated()
 */
public class IsTerminatedTask {

    //创建一个最大线程数100的线程池
    private static ExecutorService es =
            new ThreadPoolExecutor(4, 100, 0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<Runnable>(100));

    public static void main(String[] args) throws Exception {

        for (int i = 1; i <= 10; i++) {
            int finalI = i;
            es.execute(() -> { //提交执行
                System.out.println("线程" + finalI + "执行完成！");
                try {
                    //模拟线程执行过程
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        //关闭线程池
        es.shutdown();
        //隔间1s判断是否执行完了，如果所有任务在关闭后完成,返回true。
        while (!es.isTerminated()) {
            Thread.sleep(1000);
        }
        System.out.println("---------线程池执行完了-----------");
    }
}

执行main函数，结果控制台打印示例如下，仅供参考：

在上述代码演示中，在主线程中进行循环判断，全部任务是否已经完成。

拓展：

shutdown() ：对线程池进行有序关闭。调用该方法后，线程池将不再接受新的任务，但会继续执行已提交的任务。如果线程池已经处于关闭状态，则对该方法的调用没有额外的作用。
isTerminated() ：判断线程池中的所有任务是否在关闭后完成。只有在调用了shutdown()或shutdownNow()方法后，所有任务执行完毕，才会返回true。需要注意的是，在调用shutdown()之前调用isTerminated()方法始终返回false值的。