面试突击：如何判断线程池已经执行完所有任务了？

发布时间：2025-11-05 16:00:23 来源：云智核 作者：系统运维

作者 | 磊哥

来源 | Java面试真题解析(ID：aimianshi666)

转载请联系授权(微信ID：GG_Stone)

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

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

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

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

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));

}

});

}

}

以上程序的执行结果如下：

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

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

我们可以利用线程池的终止状态(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 了。

以上程序的执行结果如下：

需要关闭线程池。

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

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

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

/

* 方法2：getCompletedTaskCount 实现方式

* 判断线程池的云服务器所有任务是否执行完

*/

private static void isCompletedByTaskCount(ThreadPoolExecutor threadPool) {

while (threadPool.getTaskCount() != threadPool.getCompletedTaskCount()) {

}

以上程序执行结果如下：

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

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

具体实现代码如下：

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();

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

以上程序的执行结果如下：

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

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();

}

}

});

}

以上程序的执行结果如下：

CyclicBarrier 有 3 个重要的方法：

构造方法：构造方法可以传递两个参数，参数 1 是计数器的数量 parties，参数 2 是计数器为 0 时，也就是任务都执行完之后可以执行的事件(方法)。

await 方法：在 CyclicBarrier 上进行阻塞等待，当调用此方法时 CyclicBarrier 的内部计数器会 -1，直到发生以下情形之一：

reset 方法：使得CyclicBarrier回归初始状态，直观来看它做了两件事：

如果有正在等待的线程，则会抛出 BrokenBarrierException 异常，且这些线程停止等待，继续执行。

将是否破损标志位 broken 置为 false。

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

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

相关文章