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() 方法分别统计出统计出【已完成任务数】和【总任务数】，如果相等则说明线程池的任务执行完了，否则既未执行完。

示例代码如下：

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

具体演示代码如下：

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() 方法就是等待该任务执行完，如下代码所示：

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达到统计线程池所有线程都被执行完的需求？请看示例代码:

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达到统计线程池所有线程都被执行完的需求吧，具体实现代码如下，仅供参考：

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() 方法达到统计线程池所有线程都被执行完的需求吧，具体实现代码如下，仅供参考：

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值的。

3.4 小结

如上，我总共诺列了五种解决思路，小伙伴在面对该场景时，猜想第一感觉想到的会是方式1跟方式5吧，但是这五种方式，实现思路上各有优劣，如下bug菌就简单给同学们分析下其中的关系利弊，仅供参考。

3.4.1 使用getCompletedTaskCount()和getTaskCount() 方法

优点：使用它可不需要进行线程池的关闭，避免了创建线程池及销毁所带来的内存开销。

缺点：使用它两方法返回的都是一个近似值，而且进行线程判断局限很大，要保证在循环判断过程中没有产生新的任务，否则该方式就统计失效了。

3.4.2 使用 FutureTask

优点：使用其方法就是主打一个精确值，使用简单优雅，不需要对线程池有任何的操作。

缺点：每个提交给线程池的任务都会关联一个FutureTask对象，这就可能会损耗额外的内存开销。如果需要处理大量的任务，可能会占用较大的内存资源。

3.4.3 使用CountDownLatch

优点：使用简单优雅，不需要对线程池有任何的操作。

缺点：使用CountDownLatch 计数器只能使用一次，CountDownLatch 创建之后不能重复使用，而且需要提前知道线程的数量，性能较差，还需要在线程代码块内加上异常判断，否则在 countDown()之前发生异常而没有处理，就会导致主线程永远阻塞在 await 。

3.4.4 使用CyclicBarrier

优点：使用简单优雅，计数器可重置进行重复使用。

缺点：使用难度较高。相比CountDownLatch而言，CyclicBarrier 无论从设计还是使用，复杂度都高于CountDownLatch，相比 CountDownLatch 而言它的优点就是可以重复使用。

3.4.5 使用isTerminated()

优点：使用简单优雅。

缺点：使用场景受限，需要shutdown()关闭线程池。因为日常使用是会将线程池注入到Spring容器里，然后各个组件中都统一用同一个线程池，不能直接关闭线程池。

... ...

以上提供了五种不同的思路对其进行求解，且分析了这五种方式的使用优劣，希望对同学们有所帮助。如果有小伙伴还有其他的奇思妙想，欢迎评论区大胆交流，一起学习。

4. 热文推荐🔥

滴~如下推荐【Spring Boot 进阶篇】的学习大纲，请小伙伴们注意查收。

Spring Boot进阶(01)：Spring Boot 集成 Redis，实现缓存自由

Spring Boot进阶(02)：使用Validation进行参数校验

Spring Boot进阶(03)：如何使用MyBatis-Plus实现字段的自动填充

Spring Boot进阶(04)：如何使用MyBatis-Plus快速实现自定义sql分页

Spring Boot进阶(05)：Spring Boot 整合RabbitMq，实现消息队列服务

Spring Boot进阶(06)：Windows10系统搭建 RabbitMq Server 服务端

Spring Boot进阶(07)：集成EasyPoi，实现Excel/Word的导入导出

Spring Boot进阶(08)：集成EasyPoi，实现Excel/Word携带图片导出

Spring Boot进阶(09)：集成EasyPoi，实现Excel文件多sheet导入导出

Spring Boot进阶(10)：集成EasyPoi，实现Excel模板导出成PDF文件

Spring Boot进阶(11)：Spring Boot 如何实现纯文本转成.csv格式文件？

Spring Boot进阶(12)：Spring Boot 如何获取Excel sheet页的数量？

Spring Boot进阶(13)：Spring Boot 如何获取@ApiModelProperty(value = “序列号“, name = “uuid“)中的value值name值？

Spring Boot进阶(14)：Spring Boot 如何手动连接库并获取指定表结构？一文教会你

Spring Boot进阶(15)：根据数据库连接信息指定分页查询表结构信息

Spring Boot进阶(16)：Spring Boot 如何通过Redis实现手机号验证码功能？

Spring Boot进阶(17)：Spring Boot如何在swagger2中配置header请求头等参数信息

Spring Boot进阶(18)：SpringBoot如何使用@Scheduled创建定时任务？

Spring Boot进阶(19)：Spring Boot 整合ElasticSearch

Spring Boot进阶(20)：配置Jetty容器

Spring Boot进阶(21)：配置Undertow容器

Spring Boot进阶(22)：Tomcat与Undertow容器性能对比分析

Spring Boot进阶(23)：实现文件上传

Spring Boot进阶(24)：如何快速实现多文件上传？

Spring Boot进阶(25)：文件上传的单元测试怎么写?

Spring Boot进阶(26)：Mybatis 中 resultType、resultMap详解及实战教学

Spring Boot进阶(27)：Spring Boot 整合 kafka(环境搭建+演示)

Spring Boot进阶(28)：Jar包Linux后台启动部署及滚动日志查看，日志输出至实体文件保存

Spring Boot进阶(29)：如何正确使用@PathVariable，@RequestParam、@RequestBody等注解？不会我教你，结合Postman演示

Spring Boot进阶(30)：@RestController和@Controller 注解使用区别，实战演示

...

5. 文末🔥

如果想系统性的学习Spring Boot，小伙伴们直接订阅bug菌专门为大家创建的Spring Boot专栏《滚雪球学Spring Boot》从入门到精通，从无到有，从零到一！以知识点+实例+项目的学习模式由浅入深对Spring Boot框架进行学习&使用。

如果你有一定的基础却又想精进Spring Boot，那么《Spring Boot进阶实战》将会是你的最好的选择；此栏进行知识点+实例+项目的学习方式全面深入框架剖析及各种高阶玩法，励志打造全网最全最新springboot学习专栏，投资学习自己性价比最高。

本文涉及所有源代码，均已上传至github开源，供同学们一对一参考，GitHub，同时，原创开源不易，欢迎给个star🌟，想体验下被加Star的感jio，非常感谢 ❗

我是bug菌，一名想走👣出大山改变命运的程序猿。接下来的路还很长，都等待着我们去突破、去挑战。来吧，小伙伴们，我们一起加油！未来皆可期，fighting！

关注公众号，获取最新BAT互联网公司面试题、4000G pdf电子书籍、简历模板等硬核资源

Spring Boot进阶(60)：5种判断线程池任务是否全部完成的方案 | 实用技巧分享！

1. 前言🔥

2. 环境说明🔥

3. 正文🔥

3.1 需求分析

3.2 实现概述

3.3 实现方案

3.3.1 统计完成已完成任务数

3.3.2 使用 FutureTask

3.3.3 使用CountDownLatch

3.3.4 使用CyclicBarrier

3.3.5 使用isTerminated()

3.4 小结

3.4.1 使用getCompletedTaskCount()和getTaskCount() 方法

3.4.2 使用 FutureTask

3.4.3 使用CountDownLatch

3.4.4 使用CyclicBarrier

3.4.5 使用isTerminated()

4. 热文推荐🔥

5. 文末🔥

相关文章