线程池
Java ThreadPoolExecutor 源码与工作原理总结
学习目标:不仅记住线程池的参数和执行流程,还要理解 Worker
如何创建、复用、回收,线程池如何关闭,以及中断机制为什么不能强制终止线程。适用版本:以 OpenJDK
ThreadPoolExecutor的经典实现为主。JDK
8、17、25 的核心设计思路基本一致,具体源码细节以所使用 JDK 版本为准。
1. 先建立整体模型
ThreadPoolExecutor 可以理解为一个任务调度器 + Worker 管理器:
- 外部通过
execute()提交任务。 - 线程池根据核心线程数、任务队列、最大线程数决定如何接收任务。
Worker是线程池内部的工作单元,持有真正执行任务的Thread。- Worker 执行完初始任务后,会继续从任务队列取任务,复用同一个线程。
- 线程池关闭时,根据关闭方式决定是否继续处理队列任务、是否尝试中断
Worker。 - 所有 Worker 退出后,线程池才真正进入
TERMINATED。
整体结构:
业务线程
|
| execute(task)
v
ThreadPoolExecutor
|
+---- Worker 数量 < corePoolSize ?
| |
| +---- 是:创建 Worker 执行任务
| |
| +---- 否:尝试任务入队
| |
| +---- 入队成功:等待 Worker 处理
| |
| +---- 入队失败:尝试扩容到 maximumPoolSize
| |
| +---- 成功:创建 Worker
| |
| +---- 失败:执行拒绝策略
|
v
Worker.run()
|
v
runWorker()
|
+---- 执行 firstTask
|
+---- getTask() 从队列获取后续任务
|
+---- 循环执行,直到 Worker 退出
要牢记:线程池并不是"核心线程池"和"非核心线程池"两套线程。核心线程数、最大线程数是线程数量管理策略;Worker
本身没有两种不同的线程类型。
2. execute():任务提交的核心流程
经典实现的核心逻辑可以简化为:
public void execute(Runnable command) {
if (command == null) {
throw new NullPointerException();
}
int c = ctl.get();
// 1. Worker 数量小于核心线程数,优先创建 Worker 执行当前任务
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true)) {
return;
}
c = ctl.get();
}
// 2. 核心线程数已满,尝试将任务放入队列
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
// 入队后重新检查线程池状态,防止并发关闭时任务遗留
if (!isRunning(recheck) && remove(command)) {
reject(command);
} else if (workerCountOf(recheck) == 0) {
addWorker(null, false);
}
return;
}
// 3. 队列满或线程池不再运行,尝试创建非核心 Worker
if (!addWorker(command, false)) {
// 4. 无法创建 Worker,执行拒绝策略
reject(command);
}
}
2.1 执行顺序
- Worker 数量小于
corePoolSize:优先创建 Worker,直接执行当前任务。 - 核心 Worker 数量已满:尝试
workQueue.offer(command)。 - 队列放不进去:尝试创建 Worker,数量上限为
maximumPoolSize。 - 达到最大线程数且队列也满:执行拒绝策略。
2.2 用一个例子理解
配置:
corePoolSize = 2;
maximumPoolSize = 4;
workQueue = new ArrayBlockingQueue<>(3);
假设任务都还没有执行完成,依次提交 A 到 H:
提交任务 Worker 数量 队列 结果
A 1 空 创建 Worker 执行 A
B 2 空 创建 Worker 执行 B
C 2 C 入队
D 2 C、D 入队
E 2 C、D、E 入队,队列满
F 3 C、D、E 队列满,创建第 3 个 Worker 执行 F
G 4 C、D、E 队列满,创建第 4 个 Worker 执行 G
H 4 C、D、E 队列满且达到最大线程数,拒绝
这是理解线程池容量的关键:在任务尚未完成的理想推演下,最多容纳
maximumPoolSize + queueCapacity 个正在执行或等待的任务。这里是
4 + 3 = 7 个。
注意:实际运行中任务会并发完成,Worker
数量和队列长度会动态变化,因此提交结果取决于当时的状态。
2.3 为什么使用 offer(),而不是 put()?
offer():队列有空间就放入,队列满时立即返回false。put():队列满时阻塞提交任务的线程,直到有空间。
线程池使用 offer(),是为了在队列满时及时知道入队失败,从而尝试扩容
Worker。
如果使用
put(),提交任务的业务线程可能卡在队列入队操作上,线程池就无法按预期执行"队列满后扩容"的逻辑。
补充:ArrayBlockingQueue.offer()
内部仍然需要获取队列锁,因此"立即返回"是指队列满时不会等待队列空出位置,并不意味着完全没有锁竞争。
2.4 为什么入队成功后还要重新检查线程池状态?
源码:
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (!isRunning(recheck) && remove(command)) {
reject(command);
} else if (workerCountOf(recheck) == 0) {
addWorker(null, false);
}
return;
}
isRunning(c) 与 workQueue.offer(command) 不是一个原子操作。提交任务的线程检查到 RUNNING 后,另一个线程可能恰好调用 shutdown(),将状态改为 SHUTDOWN;随后提交线程仍可能成功把任务放进队列。
如果入队后不复查,就可能把任务留在线程池已经关闭的队列里。因此源码重新读取 ctl:
- 如果线程池已经不再是
RUNNING,尝试remove(command)。 - 移除成功,说明任务仍在队列中,执行拒绝策略。
- 移除失败,说明任务可能已经被 Worker 取走,不能贸然拒绝;任务可能已经进入执行流程。
这一步解决的是 execute() 与 shutdown() 并发时的竞态问题。
2.5 为什么 Worker 数量为 0 时调用 addWorker(null, false)?
任务已经入队,不需要新 Worker 携带 firstTask;创建一个 firstTask = null 的 Worker,让它启动后通过 getTask() 从队列取任务即可:
任务入队成功
|
v
重新读取 ctl,发现 workerCount == 0
|
v
addWorker(null, false)
|
v
创建 Worker,firstTask 为 null
|
v
runWorker() -> getTask() -> 从队列取任务
出现 Worker 数量为 0 的情况包括:
corePoolSize设置为 0,任务先进入队列。- 开启
allowCoreThreadTimeOut(true)后,所有 Worker 都可能因空闲超时退出。 - Worker 退出与新任务入队并发,提交线程复查时发现 Worker 数量已经归零。
这里还有一个源码细节:addWorker(null, false) 在 SHUTDOWN 状态下并非一概禁止。addWorker() 的状态校验允许在 SHUTDOWN 且 firstTask == null、队列非空时创建 Worker,因为它的目的是处理关闭前已经入队的任务;但在 STOP 状态下不会这样做。
所以这段代码的重点是:队列里已有任务时,尽量保证有 Worker 能消费;并发关闭时则遵守线程池状态和任务是否仍在队列中的规则。
3. Worker:线程池为什么能够复用线程?
Worker 是 ThreadPoolExecutor 的内部类,经典实现大致如下:
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable {
final Thread thread;
Runnable firstTask;
Worker(Runnable firstTask) {
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
@Override
public void run() {
runWorker(this);
}
}
3.1 Worker 与 Thread 的关系
Worker 不等于 Thread:
- Worker:线程池内部的工作单元,负责管理任务执行过程。
- Thread:真正由 JVM 调度、执行代码的线程。
firstTask:Worker 创建时携带的第一个任务。thread:Worker 持有的实际线程。
关键代码:
this.thread = getThreadFactory().newThread(this);
传给 ThreadFactory 的是 this,也就是 Worker 自身,而不是业务任务。
因此线程启动后,会调用:
Thread.start()
-> Worker.run()
-> runWorker(this)
3.2 runWorker() 如何复用线程?
核心逻辑可以简化为:
final void runWorker(Worker w) {
Runnable task = w.firstTask;
w.firstTask = null;
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
try {
task.run();
} finally {
task = null;
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
执行过程:
- 先执行 Worker 携带的
firstTask。 - 执行完后,将局部变量
task置空。 - 调用
getTask()从任务队列获取下一个任务。 - 获取到任务就继续执行。
- 获取不到任务且满足退出条件,循环结束,Worker 退出。
所以一个 Worker 对应的 Thread 可以连续执行多个 Runnable:
Thread-1
|
+-- 执行任务 A
|
+-- 从队列获取任务 C
|
+-- 执行任务 C
|
+-- 从队列获取任务 D
|
+-- 执行任务 D
|
+-- 继续等待或退出
线程池复用线程,主要就是依靠这个循环,而不是每提交一个任务就创建一个新线程。
4. addWorker():Worker 是如何创建的?
addWorker(firstTask, core) 负责创建 Worker。参数含义:
firstTask:新 Worker 创建后首先执行的任务,可以为null。core = true:Worker 数量上限按corePoolSize判断。core = false:Worker 数量上限按maximumPoolSize判断。
可以把它理解为三个阶段。
阶段一:检查状态并预占 Worker 数量
线程池通过 ctl 中的 Worker 数量和线程池状态进行校验,再通过 CAS 增加
Worker 数量。
这里的"预占"很重要:
CAS 成功只代表预留了一个 Worker 名额,不代表 Thread 已经创建或启动。
阶段二:创建 Worker 和 Thread
Worker w = new Worker(firstTask);
Thread t = w.thread;
Worker 构造时通过 ThreadFactory 创建实际 Thread。
阶段三:加入集合并启动线程
mainLock.lock();
try {
workers.add(w);
t.start();
} finally {
mainLock.unlock();
}
上面只是帮助理解的简化示意。真实源码还会检查线程池状态、处理创建失败、维护
Worker 数量,并确保异常路径能够清理预占的数量。
4.1 ctl 和 workers 分别维护什么?
线程池同时维护两种信息,但它们职责不同:
| 维度 | ctl 中的 workerCount |
workers 集合 |
|---|---|---|
| 保存内容 | Worker 数量计数 | Worker 对象 |
| 结构 | AtomicInteger |
HashSet<Worker> |
| 主要用途 | 并发判断是否还能创建 Worker、控制数量上限 | 管理 Worker 生命周期、遍历和统计 |
| 并发保护 | CAS | mainLock |
判断能否创建 Worker、预占名额时,以 ctl 为准。addWorker() 会先通过 CAS 增加 workerCount,之后才创建 Worker 并加入 workers。
因此,在 Worker 创建或退出的过渡阶段,ctl 数值与 workers.size() 可能短暂不相等。例如名额已通过 CAS 预占,但 Worker 尚未加入集合时,ctl 已经加一,而集合大小还没变化。这是设计允许的中间状态,不代表数据永久不一致。
workers 不是线程池扩容时的并发计数器;它是实际 Worker 对象的管理集合。线程池的一些监控方法会在 mainLock 保护下遍历或统计这个集合。
完整思路:
addWorker()
|
v
检查线程池状态、Worker 数量
|
v
CAS 预占 Worker 名额
|
v
创建 Worker
|
v
ThreadFactory 创建 Thread
|
v
mainLock 保护 workers 集合
|
v
workers.add(worker)
|
v
thread.start()
5. getTask():Worker 如何等待任务和退出?
Worker 执行完当前任务后,会调用 getTask() 获取下一个任务。
它需要处理两件事:
- 队列有任务:取出并返回。
- 队列没有任务:等待,或者在满足回收条件时退出。
核心思想:
boolean timed = allowCoreThreadTimeOut
|| workerCount > corePoolSize;
Runnable task = timed
? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)
: workQueue.take();
if (task != null) {
return task;
}
这是简化示意,真实源码还会检查线程池状态、Worker 数量、超时情况,并通过
CAS 更新 Worker 数量。
5.1 take() 与 poll(timeout) 的区别
| 方法 | 队列为空时 | 常见用途 |
|---|---|---|
take() |
一直等待,直到有任务或被中断 | 不允许超时回收的 Worker |
poll(timeout) |
等待指定时间,超时返回 null |
允许超时回收的 Worker |
默认情况下:
- Worker 数量不超过
corePoolSize时,通常使用take()。 - Worker 数量超过
corePoolSize时,通常使用poll(keepAliveTime)。 - 设置
allowCoreThreadTimeOut(true)后,核心 Worker 也可以超时回收。
例如:
keepAliveTime = 5;
unit = TimeUnit.SECONDS;
当非核心 Worker 空闲等待任务超过 5 秒,poll() 返回 null,Worker
就有机会退出。
5.2 keepAliveTime 到底控制什么?
它控制的是允许超时回收的空闲 Worker
等待新任务的时间,不是任务执行时间上限。
任务正在执行时,不会因为超过 keepAliveTime 就被线程池自动杀掉。
6. processWorkerExit():Worker 退出后做什么?
Worker 退出并不意味着线程池整体结束。
线程池需要清理这个 Worker,并判断是否需要补充 Worker。
主要做三件事:
- 如果是异常退出,修正 Worker 数量。
- 从
workers集合中移除 Worker,累计已完成任务数。 - 检查线程池是否应该终止;如果线程池还在运行且 Worker
数量不足,可能创建新 Worker 补充。
6.1 两种退出方式
正常退出:
例如非核心 Worker 空闲超过 keepAliveTime,getTask() 返回
null,Worker 正常结束。
异常退出:
例如业务任务抛出未捕获的 RuntimeException 或 Error,Worker
的执行流程异常结束。
6.2 completedAbruptly 的含义
源码中的 processWorkerExit(w, completedAbruptly):
true:Worker 因异常等原因突然退出,Worker
数量还需要在退出处理过程中修正。false:Worker 正常通过getTask()返回null
退出,数量通常已经在getTask()中调整。
线程池会根据剩余 Worker 数量和配置决定是否补充,不是每次 Worker
退出都一定创建新 Worker。
6.3 正常退出和异常退出,Worker 数量分别在哪里减 1?
这是理解 completedAbruptly 的关键。两种退出路径的数量递减位置不同:
正常退出: getTask() 判断当前 Worker 应该退出时,会先通过 CAS 将 ctl 中的 Worker 数量减 1,再返回 null。随后 runWorker() 循环结束,以 completedAbruptly = false 调用 processWorkerExit()。因此正常退出不能在 processWorkerExit() 里再减一次,否则会重复扣减。
异常退出: 例如 task.run() 抛出未捕获的 RuntimeException。执行流程没有经过 getTask() 中正常退出时的递减逻辑,因此 processWorkerExit(w, true) 会调用 decrementWorkerCount(),通过 CAS 将 ctl 中的 Worker 数量减 1。
正常退出:getTask() CAS 减 1 -> 返回 null -> processWorkerExit(false)
异常退出:任务抛异常 -> processWorkerExit(true) -> decrementWorkerCount() CAS 减 1
6.4 ctl 和 workers 如何协同更新?
processWorkerExit() 的核心顺序可以概括为:
if (completedAbruptly) {
decrementWorkerCount();
}
mainLock.lock();
try {
completedTaskCount += w.completedTasks;
workers.remove(w);
} finally {
mainLock.unlock();
}
这里没有把 ctl 和 workers 的更新做成一个跨数据结构的原子事务:
ctl的 Worker 数量通过 CAS 原子更新。workers集合通过mainLock保护增删和遍历。- 两步之间允许短暂出现
workerCount与workers.size()不一致;退出处理完成后,Worker 会从管理集合中移除。
例如异常退出时,可能先把 ctl.workerCount 从 2 减到 1,此时 workers.size() 暂时仍是 2;拿到 mainLock 并移除 Worker 后,集合大小再变为 1。
这不是要求两者每一瞬间都相等,而是分别保证计数更新和集合操作的线程安全。ctl 负责并发数量控制,mainLock 负责集合安全。
6.5 什么情况下需要补充 Worker?
源码中的补充逻辑可以简化为:
if (runStateLessThan(c, STOP)) {
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && !workQueue.isEmpty()) {
min = 1;
}
if (workerCountOf(c) >= min) {
return;
}
}
addWorker(null, false);
}
理解为两种情况:
- 异常退出: 只要线程池状态还允许补充(尚未到
STOP),就尝试创建 Worker。因为 Worker 是非预期退出的,需要尽快恢复工作能力。若线程池已经进入SHUTDOWN,addWorker()仍可能在队列非空且firstTask == null时创建 Worker,以便处理关闭前留下的任务;队列空时则不会为了补充而继续创建。 - 正常退出: 检查 Worker 数量是否低于最低要求。默认不允许核心线程超时时,最低数量通常是
corePoolSize;允许核心线程超时时,最低数量是 0。但如果最低数量为 0 且队列仍有任务,会把最低数量提高到 1,保证至少有一个 Worker 消费队列。
6.6 核心 Worker 使用 take(),为什么仍然可能需要补充?
你的理解有一部分是对的:默认情况下,核心 Worker 队列为空时通常通过 take() 等待,不会仅仅因为空闲而退出。
但 take() 只解释了空闲时如何等待,并不能保证 Worker 永远不会退出。核心 Worker 仍可能因为以下原因消失:
- 执行的业务任务抛出未捕获异常,导致 Worker 异常退出。
- 开启
allowCoreThreadTimeOut(true)后,核心 Worker 也可能因空闲超时退出。 - 线程池关闭过程中,Worker 会根据状态和队列情况退出。
例如 corePoolSize = 2,原来有两个 Worker,其中一个执行任务时抛出未捕获异常,异常退出后数量从 2 变成 1。即使另一个 Worker 正阻塞在 take(),线程池仍会尝试补充一个 Worker,使运行期间的 Worker 数量恢复到核心数量要求。
所以需要区分:take() 防止核心 Worker 因普通空闲而退出;processWorkerExit() 负责处理异常退出、超时退出等导致的 Worker 数量变化。
7. ctl:为什么把线程池状态和 Worker 数量放在一个 int 里?
经典实现使用一个 AtomicInteger ctl 同时保存:
- 线程池运行状态
runState。 - Worker 数量
workerCount。
private final AtomicInteger ctl =
new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
一个 int 是 32 位:
高 3 位 低 29 位
+-----------------------------+-----------------------------+
| runState | workerCount |
+-----------------------------+-----------------------------+
7.1 状态定义
private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
private static final int STOP = 1 << COUNT_BITS;
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;
状态 含义 接收新任务 处理队列任务
RUNNING 正常运行 是 是
SHUTDOWN 正常关闭 否 是
STOP 立即停止流程 否 否,尝试中断正在执行的任务
TIDYING 最终清理阶段 否 否
TERMINATED 已终止 否 否
7.2 位运算方法
private static int runStateOf(int c) {
return c & ~CAPACITY;
}
private static int workerCountOf(int c) {
return c & CAPACITY;
}
private static int ctlOf(int rs, int wc) {
return rs | wc;
}
workerCountOf(c):提取低 29 位。runStateOf(c):提取高 3 位。ctlOf(rs, wc):把状态和数量合并。
7.3 为什么要合并?
因为线程池经常需要同时判断状态和 Worker 数量,并更新 Worker 数量。
把它们放在一个 AtomicInteger 中,可以通过一次 CAS
原子地校验和更新组合状态,避免状态与数量分别更新时产生不一致的中间状态。
注意:ctl 只能保证这个整数自身的原子性,不能代替对 workers
集合的锁保护。ctl.workerCount 是扩容和数量控制时的核心计数依据;workers 是 Worker 对象管理集合。两者在创建、退出的过渡阶段可能短暂不相等,具体协同方式见第 4.1 节和第 6.4 节。
8. Worker 为什么继承 AQS?
经典源码:
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable {
// ...
}
Worker 继承
AQS,不是为了让业务任务之间互斥,而是用一个简单的独占锁状态标记 Worker
是否正在执行任务,并辅助关闭时的中断协调。
可以这样理解:
Worker AQS 状态 含义
state = 0 空闲,没有持有 Worker 锁
state = 1 正在执行任务,持有 Worker 锁
初始 state = -1 Worker 启动前暂时禁止中断
执行任务前会 w.lock(),任务执行后 w.unlock()。
线程池关闭时调用 interruptIdleWorkers(),会尝试对 Worker 执行
tryLock():
- 成功:说明 Worker 当前空闲,可以尝试中断。
- 失败:说明 Worker 正在执行任务,不属于空闲 Worker。
因此,Worker 的 AQS 状态主要服务于 Worker 生命周期管理和中断协调。
9. mainLock:为什么还需要一把 ReentrantLock?
源码中还有:
private final ReentrantLock mainLock = new ReentrantLock();
private final HashSet<Worker> workers = new HashSet<>();
ctl 和 mainLock 解决的问题不同:
机制 保护内容 主要职责
ctl 状态和 Worker 数量 原子更新线程池状态、Worker
数量
mainLock workers 保护 Worker
集合及相关复合操作 的添加、移除、遍历和统计
Worker 的 AQS 单个 Worker 的执行状态 区分空闲与执行中,协调中断
为什么不能只依赖 ctl?
因为 ctl 是一个整数,不能保证 HashSet 的并发添加、删除和遍历安全。
为什么不能只用 mainLock?
因为 Worker 数量和线程池状态的高频校验、CAS
更新,需要一种更轻量的原子状态管理方式。
特别注意:mainLock 并不会把 ctl 的 CAS 更新和 workers 集合的增删变成同一个原子事务。线程池接受两者在生命周期过渡阶段短暂不一致:ctl 通过 CAS 保证数量计数正确推进,mainLock 保证集合操作安全。不要把“两个结构最终协调一致”误解为“每一时刻两个值都严格相等”。
10. 中断机制:为什么 interrupt() 不能强制杀死线程?
这是理解 shutdownNow() 的关键。
10.1 中断本质是协作式通知
调用:
thread.interrupt();
并不意味着 JVM 强制终止目标线程,而是向目标线程发出中断请求。
线程需要在合适的位置检查中断状态,并主动决定退出。
例如:
while (!Thread.currentThread().isInterrupted()) {
doWork();
}
当其他线程调用 interrupt()
后,中断状态被设置,任务在下一次检查时就可以退出。
而下面的代码不会主动检查中断:
while (true) {
doWork();
}
因此即使收到中断请求,也可能一直运行。
10.2 阻塞方法对中断的响应
操作 收到中断请求时的典型行为
普通 CPU 计算 设置中断状态,代码需要主动检查
Thread.sleep() 抛出 InterruptedException
Object.wait() 抛出 InterruptedException
BlockingQueue.take() 通常抛出 InterruptedException
BlockingQueue.poll(timeout) 通常抛出 InterruptedException
注意:sleep()、wait()、BlockingQueue.take() 等可中断阻塞方法抛出
InterruptedException 时,通常会清除中断状态。
如果捕获异常后不能直接退出,而是要把中断请求继续传递,常见做法是:
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return;
}
不要无视异常后继续无限执行,也不要在不理解语义时随意吞掉中断。
10.3 两个查询方法的区别
// 查询当前线程的中断状态,不清除标记
Thread.currentThread().isInterrupted();
// 查询当前线程的中断状态,并清除标记
Thread.interrupted();
方法 查询对象 清除中断状态
isInterrupted() 指定 Thread 对象 否
Thread.interrupted() 当前线程 是
10.4 中断状态的可见性
自己实现一个跨线程中断标记时,可以使用 volatile:
private volatile boolean interrupted;
public void stop() {
interrupted = true;
}
public void run() {
while (!interrupted) {
doWork();
}
}
volatile 写与后续读取同一变量的 volatile 读之间建立 happens-before
关系,保证可见性。
但 Java 原生线程中断状态由 JVM 管理,interrupt()、isInterrupted() 等
API 已经提供了相应的线程间协调语义,不需要自己再包装一个 volatile
标记。
11. shutdown() 与 shutdownNow():线程池如何关闭?
这是线程池生命周期的重点。
11.1 shutdown()
语义:
- 不再接收新任务。
- 已经提交到队列中的任务继续执行。
- 尝试唤醒空闲 Worker。
- 等所有 Worker 退出后,线程池才真正终止。
简化流程:
shutdown()
|
v
RUNNING -> SHUTDOWN
|
v
interruptIdleWorkers()
|
v
空闲 Worker 从 take()/poll() 中被唤醒
|
v
继续处理队列中的任务
|
v
队列清空
|
v
getTask() 返回 null
|
v
Worker 退出
|
v
processWorkerExit()
|
v
tryTerminate()
|
v
TIDYING -> TERMINATED
为什么要中断空闲 Worker?
空闲 Worker 可能阻塞在
workQueue.take(),一直等待新任务。如果关闭时不唤醒它,它可能无法及时重新检查线程池状态并退出,导致
Worker 数量无法归零。
这里的唤醒通常不是
Object.notify(),而是通过中断让可中断阻塞操作响应中断。
11.2 shutdownNow()
语义:
- 不再接收新任务。
- 尝试中断所有 Worker。
- 尝试从队列中移除尚未开始的任务,并将它们返回。
- 正在执行的任务是否停止,取决于任务是否响应中断。
简化流程:
shutdownNow()
|
v
RUNNING/SHUTDOWN -> STOP
|
v
interruptWorkers()
|
v
尝试中断所有 Worker
|
v
drainQueue() 移除等待中的任务
|
v
正在执行的任务响应中断并退出
|
v
Worker 数量归零
|
v
TIDYING -> TERMINATED
非常重要:
shutdownNow() 只是尝试中断,不会强制杀死正在运行的线程。
如果任务执行:
while (true) {
doWork();
}
且完全不检查中断状态,也不调用可中断阻塞方法,那么它可能一直运行,线程池就可能一直无法进入
TERMINATED。
11.3 awaitTermination()
executor.shutdown();
boolean terminated = executor.awaitTermination(
30, TimeUnit.SECONDS
);
shutdown():发起关闭,不等待线程池彻底结束。awaitTermination():调用线程等待线程池终止,最多等待指定时间。- 返回
true:线程池在超时时间内终止。 - 返回
false:等待超时,线程池尚未终止。
常见等待者是应用关闭线程、负责资源回收的管理线程或测试线程,不是 Worker
在等待自己关闭。
11.4 tryTerminate() 的判断思路
它负责推动线程池进入最终终止状态。核心判断:
RUNNING不能终止。SHUTDOWN且队列还有任务,不能终止。- Worker 数量不为 0,不能终止;必要时尝试中断空闲 Worker,推动其退出。
- Worker 数量为 0 且满足终止条件,进入
TIDYING。 - 调用
terminated()钩子方法。 - 最后设置为
TERMINATED,并唤醒等待终止的线程。
不能简单理解成"队列空了就终止":还必须满足 Worker 数量归零等条件。
12. 三个常见疑问
Q1:shutdown() 为什么不直接结束所有线程?
因为 shutdown()
的语义是平滑关闭:不再接收新任务,但允许已提交任务执行完毕。它只需要唤醒空闲
Worker,让它们检查状态并继续处理队列。
Q2:shutdownNow() 后,任务一直不响应中断怎么办?
线程池无法强制终止它。生产上需要:
- 任务代码主动检查中断状态。
- RPC、HTTP、数据库调用设置合理超时。
- 长循环和分阶段任务设计中断检查点。
- 使用有限时间的
awaitTermination()。 - 超时后记录日志和告警,并由应用关闭策略决定后续处理。
Q3:视频转码这类长任务应该怎么处理?
不要只依赖线程池内存队列保存任务。建议将任务状态持久化,例如保存在 MySQL
的任务表中:
PENDING -> RUNNING -> SUCCESS
-> FAILED
-> CANCELLED
应用重启后,根据持久化状态恢复或重新调度未完成任务。对于外部 FFmpeg
进程,也需要设计进程退出、超时和资源清理逻辑。
13. 面试时如何完整回答 ThreadPoolExecutor?
可以按下面的顺序组织答案:
第一层:任务提交
execute() 先判断 Worker 数量是否小于核心线程数,小于则创建 Worker
执行任务;否则尝试将任务放入阻塞队列;队列满了再尝试扩容到最大线程数;达到上限后执行拒绝策略。
第二层:任务执行
线程池通过 Worker 管理实际 Thread。Worker 持有 firstTask,启动后进入
runWorker(),先执行初始任务,再通过 getTask()
不断从队列获取任务,从而实现线程复用。
第三层:Worker 回收
getTask() 根据是否允许超时回收,选择 take() 或
poll(keepAliveTime)。满足退出条件时返回 null,Worker 退出后由
processWorkerExit() 清理 Worker,并按需补充。
第四层:并发控制
ctl 的高 3 位存线程池状态,低 29 位存 Worker 数量,通过 CAS
原子更新;mainLock 保护 Worker 集合;Worker 继承
AQS,用于标记执行状态并协调空闲 Worker 的中断。
第五层:关闭流程
shutdown() 不接收新任务,但继续执行队列任务;shutdownNow() 尝试中断
Worker,并返回尚未开始的队列任务。中断是协作式的,任务必须响应中断。所有
Worker 退出后,线程池才从 TIDYING 进入 TERMINATED。
14. 学习检查清单
建议能脱离文档讲清楚下面这些问题:
15. 最终记忆图
ThreadPoolExecutor
|
+------------+------------+
| |
execute() shutdown()
| |
判断 Worker 数量 SHUTDOWN
| |
+-----+------+ 唤醒空闲 Worker
| | |
未满核心数 已满核心数 继续处理队列
| | |
addWorker() offer() 队列清空
| |
+-----+-----+ Worker 退出
| | |
成功 失败 processWorkerExit()
| | |
入队 扩容 Worker tryTerminate()
| |
失败拒绝 TIDYING
|
TERMINATED
一句话总结:
ThreadPoolExecutor 通过 execute() 管理任务接收,通过 Worker
管理线程复用,通过 getTask() 管理任务获取和空闲回收,通过
ctl、mainLock 和 Worker AQS 协调并发状态,最后通过 shutdown() /
shutdownNow() 和 tryTerminate() 完成生命周期管理。

浙公网安备 33010602011771号