线程池

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 执行顺序

  1. Worker 数量小于 corePoolSize:优先创建 Worker,直接执行当前任务。
  2. 核心 Worker 数量已满:尝试 workQueue.offer(command)。
  3. 队列放不进去:尝试创建 Worker,数量上限为 maximumPoolSize。
  4. 达到最大线程数且队列也满:执行拒绝策略。

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 的情况包括:

  1. corePoolSize 设置为 0,任务先进入队列。
  2. 开启 allowCoreThreadTimeOut(true) 后,所有 Worker 都可能因空闲超时退出。
  3. 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);
    }
}

执行过程:

  1. 先执行 Worker 携带的 firstTask。
  2. 执行完后,将局部变量 task 置空。
  3. 调用 getTask() 从任务队列获取下一个任务。
  4. 获取到任务就继续执行。
  5. 获取不到任务且满足退出条件,循环结束,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() 获取下一个任务。

它需要处理两件事:

  1. 队列有任务:取出并返回。
  2. 队列没有任务:等待,或者在满足回收条件时退出。

核心思想:

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。

主要做三件事:

  1. 如果是异常退出,修正 Worker 数量。
  2. 从 workers 集合中移除 Worker,累计已完成任务数。
  3. 检查线程池是否应该终止;如果线程池还在运行且 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);
}

理解为两种情况:

  1. 异常退出: 只要线程池状态还允许补充(尚未到 STOP),就尝试创建 Worker。因为 Worker 是非预期退出的,需要尽快恢复工作能力。若线程池已经进入 SHUTDOWN,addWorker() 仍可能在队列非空且 firstTask == null 时创建 Worker,以便处理关闭前留下的任务;队列空时则不会为了补充而继续创建。
  2. 正常退出: 检查 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() 的判断思路

它负责推动线程池进入最终终止状态。核心判断:

  1. RUNNING 不能终止。
  2. SHUTDOWN 且队列还有任务,不能终止。
  3. Worker 数量不为 0,不能终止;必要时尝试中断空闲 Worker,推动其退出。
  4. Worker 数量为 0 且满足终止条件,进入 TIDYING。
  5. 调用 terminated() 钩子方法。
  6. 最后设置为 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() 完成生命周期管理。

posted @ 2026-11-15 20:48  zhangph  阅读(6)  评论(0)    收藏  举报