跳到主要内容
约 14 分钟7 张卡

Java 线程池

Java 线程池是一组可复用的工作线程,加上一个存放待执行任务的队列。创建线程有成本,线程太多又会争抢 CPU 和内存,线程池用固定的线程数量和队列容量,把并发控制在可承受的范围内。ThreadPoolExecutor 是它的核心实现,实现里把工作线程叫作 Worker。理解线程池,关键是记住新任务到来时的处理顺序:先建核心线程,再排队,排不下才扩容,扩不了就拒绝。参数怎么配、过载时会怎样、关闭时任务去哪了,都能从这个顺序推出来。

1. 面试核心​

先记住这几条,再读正文
  • 运行中的线程池先按核心线程数创建 Worker,再尝试入队,入队失败后才按最大线程数扩容。卡 · 构造参数
  • 无界队列在核心 Worker 创建后会持续接收任务,过载表现为队列和等待时间不断增长,线程数不会超过核心数。卡 · 队列类型与扩容
  • 运行期可用 setter 调整线程数和空闲策略,但缩容不会强行停止正在执行的任务;队列也不能通过 setter 任意替换。卡 · 运行期参数调整
  • I/O 线程数由任务的等待比例和目标吞吐决定,并受下游并发容量与内存限制。卡 · 线程池容量
  • 池已关闭,或线程和队列都已耗尽时,由拒绝策略决定新任务的结果。卡 · 过载保护
  • shutdownNow() 停止从队列取任务,尝试中断正在执行的任务,并返回尚未执行的排队任务。卡 · 线程池关闭与终止

2. 构造参数​

线程池能承接多少任务,要把线程数、排队空间和拒绝行为放在一起看。ThreadPoolExecutor 的七个主要构造参数如下:

范围参数作用
线程数量corePoolSize、maximumPoolSize核心阈值与线程上限
空闲回收keepAliveTime、unit空闲等待期限
排队workQueue保存待执行任务
创建threadFactory创建和命名 Worker 线程
拒绝handler处理拒绝任务
ExecutorService executor = new ThreadPoolExecutor(
8,
16,
30,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(200),
new ThreadPoolExecutor.AbortPolicy()
);

这里用的是六参数重载,没有传 ThreadFactory,使用默认实现。核心线程数 8,队列容量 200,线程上限 16;超过核心数的那部分线程空闲 30 秒后可以回收。线程和队列都满时,AbortPolicy 抛出拒绝异常。按下一节的流程,这个池最多同时容纳 16 个运行中的任务加 200 个排队任务;在没有任务完成的情况下,第 217 个任务会被拒绝。

自定义 ThreadFactory 可以给线程起带业务含义的名字,从线程栈里一眼看出是哪个池的线程。另外,这些参数要和队列类型一起看:队列越小,任务越早走到扩容或拒绝分支。

3. execute 接收流程​

execute 要决定新任务交给谁执行,暂时没人执行时放在哪里。运行中的线程池按创建、排队、扩容、拒绝的顺序处理:

  1. Worker 数量少于 corePoolSize 时,尝试创建一个新 Worker,让它直接执行这个任务。
  2. 没能在第一步交给新 Worker 时,尝试把任务放进队列,入队成功后再复查一次运行状态。
  3. 队列放不下时,尝试再创建 Worker,总数最多到 maximumPoolSize。
  4. 线程池已经关闭,或者线程和队列都满了,执行拒绝策略。

注意第 2 步排在第 3 步之前:核心线程满了以后,线程池宁可让任务排队,也不急着加线程。这是很多配置问题的根源,第 7 节会展开。

入队后要复查,是因为入队和关闭线程池可能同时发生。复查发现池已经关闭,并且能把刚才的任务从队列里移除,就拒绝它。如果任务留在了队列里,而 Worker 数量恰好为零(比如核心线程允许超时回收),就补建一个 Worker,免得队列里的任务没人处理。

Worker 执行完第一个任务后不会退出,而是继续从队列取任务,所以一个线程会执行很多个任务。超过核心数的线程空闲达到 keepAliveTime 后会超时退出。调用 allowCoreThreadTimeOut(true) 后,核心线程空闲也会被回收,这时 keepAliveTime 必须大于零。

3.1 execute 与 submit 的异常​

同一个任务抛出异常,用 execute 和 submit 提交,调用方发现失败的途径不同。区别在于 submit 多包了一层,专门保存结果和异常。

通过 execute 提交的任务抛出未捕获异常时,执行它的 Worker 会异常退出。异常交给线程的未捕获异常处理器,默认是打印堆栈;线程池再按状态和容量补建一个 Worker。

submit 把任务包装成 FutureTask,异常被 FutureTask 捕获并保存起来,Worker 本身不会退出,也不会打印任何东西。调用方执行 Future.get() 时,才会收到包装了原始异常的 ExecutionException。所以用 submit 提交、又把返回的 Future 丢掉,任务失败就悄无声息。

afterExecute 是任务执行后调用的扩展方法,它的 Throwable 参数也受这层包装影响:异常已经被 FutureTask 捕获,这个参数就是 null。所以基于 afterExecute 做监控时,还要检查已完成的 Future,才能发现里面的任务失败。

3.2 运行期参数调整​

ThreadPoolExecutor 的部分参数可以在运行期间修改。 调用者需要持有具体的 ThreadPoolExecutor 对象;ExecutorService 接口本身不提供这些调参方法,工厂方法返回的包装对象也不一定能转换成它。

方法生效方式与限制
setCorePoolSize增大后,会按需要启动 Worker 处理已排队任务;减小后,多余线程在空闲时退出,不强停当前任务
setMaximumPoolSize修改线程上限;增大上限不等于立即创建更多线程,任务仍先尝试入队;减小时,多余线程在不再执行当前任务后退出
setKeepAliveTime、allowCoreThreadTimeOut修改空闲回收规则;允许核心线程超时时,存活时间必须大于 0
setThreadFactory影响之后创建的线程,不重命名或替换已经存在的线程
setRejectedExecutionHandler替换后续拒绝处理使用的策略;不补救此前已被丢弃的任务

线程数需要满足 0 <= corePoolSize <= maximumPoolSize,且 maximumPoolSize > 0。一次调整两个值时,每一步也必须合法。例如只有一个管理者修改参数,当前配置为 core=2、max=4:

// 原配置为 core=2、max=4;扩到 core=6、max=12。
pool.setMaximumPoolSize(12);
pool.setCorePoolSize(6);
// 再缩回 core=2、max=4。
pool.setCorePoolSize(2);
pool.setMaximumPoolSize(4);

扩容时先调大上限,避免先把核心数设成 6、却仍受旧上限 4 限制;缩容时先把核心数降下来,避免上限先降到核心数以下。JDK 会拒绝这些不合法的中间状态。两个 setter 不是一次原子配置更新;若多个管理入口能同时修改,应在管理层串行协调,不能只靠调用顺序避免相互干扰。

这些方法改变的是后续调度和回收条件,不保证调用返回时实际线程数已经等于目标。比如一个 Worker 正在处理任务,另一个任务排在无界队列里,只增大 maximumPoolSize 不会让排队任务立即运行;增大核心数则可以为排队任务补建 Worker。降低上限也不会抢走正在执行任务的线程,实际收缩仍取决于任务何时结束。

workQueue 在构造时确定,ThreadPoolExecutor 没有替换队列的 setter;标准 ArrayBlockingQueue 的容量也不能动态修改。不要通过反射更换队列,或把 getQueue() 当成重新分配任务的通用接口。需要改变队列类型或容量时,应安排新池接流量、旧池完成已接收任务的迁移过程,并处理在途任务和拒绝结果。

4. 线程池容量​

配置线程数之前,先弄清任务大部分时间是在计算还是在等待。CPU 密集任务一直占着核心,线程数接近可用核心数之后,再加线程只会互相争抢 CPU、增加切换。I/O 任务等数据库或网络响应时会让出 CPU,可以多开线程,但每个线程仍然占着连接这类下游资源。

可以用下面两个关系估算线程数和在途任务数,作为压测的起点:

线程数 ≈ CPU 核数 × 目标利用率 × (1 + 等待时间 / 计算时间)
在途任务数 ≈ 目标吞吐 × 平均响应时间

在途任务指已经进入系统、还没完成的任务。比如 8 核机器、目标利用率 0.8,每个任务计算 10 毫秒、等待 90 毫秒,第一条给出 8 × 0.8 × 10 = 64 个线程。第二条是稳定系统下的 Little 定律:目标每秒 500 个任务、平均响应 0.2 秒,系统里平均就有 100 个任务在途。第一条依赖等待和计算时间的测量,两者都只是估算。

实际配置还要满足下面这些资源与延迟约束:

  • 数据库连接数限制同时执行的查询数量。
  • 下游配额限制同时发起的接口调用数量。
  • 内存限制线程栈和在途任务可以占用的空间。
  • 容器 CPU 配额和可用核心数限制计算能力。
  • 请求超时与延迟预算限制任务可以排队多久。

线程数超过数据库连接池大小,多出来的线程只会在连接池前排队。压测时逐步增加并发,同时观察吞吐、P95/P99、队列长度和拒绝数。P99 是 99% 的请求耗时都不超过的值,反映较慢的那部分请求。再结合 CPU、上下文切换次数和下游等待,判断瓶颈在哪里。吞吐不再增长而长尾延迟上升时,继续加线程已经没有收益。

5. 过载保护​

有界队列限制排队任务的数量,排队占用的内存就能估算出来。线程和队列都用完后,拒绝策略决定新任务的结果,JDK 提供四种:

策略行为
AbortPolicy抛出 RejectedExecutionException
CallerRunsPolicy池未关闭时由提交线程执行,否则丢弃
DiscardPolicy静默丢弃当前任务
DiscardOldestPolicy池未关闭时移除队头,再尝试提交

选策略的同时,要定义调用方收到什么结果:返回繁忙、有限重试、降级、合并重复任务,或者明确允许丢弃。重试的任务要幂等,也就是重复执行仍然得到正确结果。还要给任务设截止时间、记录拒绝次数,避免已经过期的工作继续占用资源。

CallerRunsPolicy 让提交者自己去执行任务,提交者忙着执行,就没空继续提交,提交速度自然降下来,这种效果叫反压。但效果取决于提交者是谁:如果提交者是 I/O 线程、事件循环或者正持有锁的线程,让它去执行一个慢任务,阻塞会扩散到更大的范围。

6. 饱和与堆积诊断​

队列长期增长,说明任务到达的速度高于完成的速度。排查时先区分流量增加和任务变慢,再判断还有没有扩容空间:

  1. 查看活跃线程数、池大小、队列长度、最老任务年龄、完成数和拒绝数。任务年龄指它已经排队等了多久。
  2. 比较提交速率、完成速率和任务耗时,确认是新任务变多了,还是每个任务执行得更慢了。
  3. 连续采集多份线程栈,看线程是在等数据库连接、等下游调用、等锁,还是在消耗 CPU。
  4. 检查是否有父任务在同步等待同一个池里的子任务。所有 Worker 都被父任务占着,子任务就永远排不到。
  5. 先限制新任务、隔离慢依赖、放弃已过期的任务,再根据可用资源评估是否扩容。

线程很多而 CPU 很低,说明线程大多在等某样东西,应该先找出它们在等什么;这时继续加线程,只会在同一个资源前增加等待者。同池等待的成因见 并发活跃性。

7. 队列类型与扩容​

达到核心线程数后,execute 先尝试入队,入队失败才扩容。所以同样的线程数配置,配上不同的队列,扩容行为完全不同:

队列接收特点对扩容的影响
无界 LinkedBlockingQueue持续保存等待任务核心数后优先积压
有界 ArrayBlockingQueue容量固定满后才扩展 Worker
SynchronousQueue容量为零,直接交接无接收者时尝试增线程

无界队列永远能入队,按 maximumPoolSize 扩容的分支几乎走不到,maximumPoolSize 设得再大也没用。SynchronousQueue 不存放任务,只能直接交给正在等待取任务的 Worker;没有空闲 Worker 接手时入队就失败,线程池随即尝试增加 Worker。Executors.newCachedThreadPool 就是这种直接交接队列配上极高的线程上限,任务来得快时线程数会迅速膨胀。

需要用队列缓冲突发流量时,按可接受的排队时间和单个任务的内存确定容量。Worker 取出任务时还要检查截止时间,已经过期的就不要再执行。

8. 线程池关闭与终止​

关闭方法返回时,线程池里的任务可能还在执行,线程池要经过几个状态才真正终止。OpenJDK 21 中有五种状态:

状态行为
RUNNING接收新任务,处理队列
SHUTDOWN拒绝新任务,继续处理队列
STOP拒绝新任务,停止取队列并尝试中断运行任务
TIDYINGWorker 已归零,执行终止钩子
TERMINATED终止钩子执行完成

shutdown() 让线程池进入 SHUTDOWN,开始有序关闭:拒绝新任务,已接受的任务(包括排队的)继续执行。shutdownNow() 让线程池进入 STOP:停止从队列取任务,尝试中断正在运行的任务,并把还没执行的排队任务作为列表返回。两个方法都不等任务结束就返回,要等线程池真正终止,用 awaitTermination,并给等待设一个期限:

pool.shutdown();
if (!pool.awaitTermination(5, TimeUnit.SECONDS)) {
List<Runnable> pending = pool.shutdownNow();
handlePending(pending);
}

先有序关闭并等 5 秒;还没终止,就调用 shutdownNow() 尝试中断运行中的任务,并把返回的排队任务交给 handlePending。这段代码需要处理或声明 InterruptedException。

shutdownNow() 也只是尝试。运行中的任务如果忽略中断,会继续执行到结束,线程池要等它结束才能终止。返回的排队任务如果是 submit 产生的 FutureTask,调用方还要取消或接管它们,否则等这些结果的线程会一直等下去。

9. 静默拒绝与悬空 Future​

有一种隐蔽的故障:任务被丢弃了,调用方手里却还拿着一个永远不会完成的 Future。原因在 submit 的实现:它先创建 FutureTask,再调用 execute 提交。拒绝策略静默丢弃时,这个 FutureTask 既没有执行,也没有被取消,调用 get() 就会一直等下去。

以下三种拒绝情形都会留下这样的 Future:

  • DiscardPolicy 直接丢弃新任务,留下它对应的 Future。
  • 线程池关闭后,CallerRunsPolicy 也会直接丢弃任务。
  • DiscardOldestPolicy 移除队头任务时,被移除任务的 Future 就悬空了。

需要返回结果的任务应该显式拒绝,比如用 AbortPolicy 抛出异常,让提交方立刻知道失败。也可以写自定义拒绝处理器,取消被丢弃的 Future 并记录失败。这样等待结果的调用方总能得到一个明确的结局。

10. 常见问题​

10.1 创建线程池时会立即创建所有核心线程吗?​

不会。核心 Worker 默认在任务到来时按需创建。需要提前准备好线程时,可以调用 prestartCoreThread() 启动一个,或者调用 prestartAllCoreThreads() 启动全部核心 Worker。

10.2 固定线程池为什么还会耗尽内存?​

10.3 队列越大越能应对突发吗?​

11. 面试题卡片​

12. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明