ThreadPoolExecutor线程池全解析:参数、队列与拒绝策略实战
ThreadPoolExecutor线程池:从参数到实战,一篇讲透并发里面的这点事
线程池这个东西,几乎每个Java面试都会问到,实际项目中更是绕不开。ThreadPoolExecutor作为Java并发包里的核心类,它解决的可不是简单的“复用线程”问题,而是资源控制、任务调度、性能权衡这一整个体系的问题。
我刚开始写Java的时候,觉得线程池不过是new几个线程跑任务而已,后来被线上一次线程爆炸干翻,才老老实实把ThreadPoolExecutor的源码、参数、队列、拒绝策略都啃了一遍。这篇博客就把我踩过的坑和总结出来的配置方法全写出来,适合正在准备Java面试、或者工作中想系统掌握线程池配置的开发者参考。
1. 为什么非要用线程池?手动new Thread到底错在哪
很多人写并发时会觉得,Java里开线程不就是一个new Thread(...).start()的事吗?确实,随手写个异步任务,一条线程就能解决,但一旦放到生产环境,这种写法带来的隐患比想象中大得多。
我给你算一笔账:每创建一个Java线程,抛开对象本身不谈,底层还需要分配线程栈空间(默认大概1MB左右),再加上操作系统内核线程的创建开销、线程切换时的上下文切换成本,这些都会实实在在地消耗CPU和内存。假如一个请求进来就new一个线程,高峰期每秒进来500个请求,那这500个线程同时活着,光是栈内存就要吃500MB,再加上系统调度它们要来回切换上下文,应用不卡死才怪。
线程池要解决的正是这个问题:把线程的创建和销毁成本摊到一批任务的执行上,核心线程常驻,任务多了排队,任务满了有兜底策略。用一句话说,线程池管理的不是“任务”,而是“线程这种稀缺资源”。
在Java里,线程池这套体系的设计也很值得琢磨:
Executor是顶层接口,只负责给你一个“执行任务”的能力;ExecutorService扩展了生命周期管理,比如shutdown、shutdownNow,还有submit带回返回值的能力;AbstractExecutorService做了默认骨架;ThreadPoolExecutor才是真正干活的类,策略全部可配置。
这也是为什么面试官总是盯着ThreadPoolExecutor打——因为Executors工具类里那几种fixed、cached线程池,本质都是对ThreadPoolExecutor的不同参数组合,真正决定线程池能不能扛住业务的,还是你对ThreadPoolExecutor的每个参数理解得够不够深。
2. ThreadPoolExecutor的7个核心参数,一个一个拆给你看
ThreadPoolExecutor的核心构造方法最多有7个参数,很长,但每个参数都是有用的。先看完整签名:
2.1 corePoolSize与maximumPoolSize:线程数的上下限
corePoolSize是核心线程数,正常情况下线程池里的线程数会稳定在这个值附近。哪怕核心线程空闲,也默认不会被回收(除非设置了allowCoreThreadTimeOut(true))。maximumPoolSize是最大线程数,当任务队列满了、核心线程都在干活、仍然塞不进新任务时,线程池才会把线程数往maximumPoolSize扩。
这里有两个常见的误区:
- 线程数不是一上来就拉满到maximumPoolSize的。新任务到来时,线程池优先把线程数从0加到corePoolSize,如果核心线程都忙,任务会先进队列排队,队列满了才考虑加非核心线程。
- 非核心线程空闲超过keepAliveTime后会被回收,核心线程默认不会,除非显式开启
allowCoreThreadTimeOut。
2.2 keepAliveTime与unit:非核心线程的存活时间
keepAliveTime指的是非核心线程(以及开启超时回收时的核心线程)空闲存活时间。这个值不是随便拍的,它和任务的到达频率、任务的执行时长强相关。
如果任务平均执行时间很短,比如几十毫秒一个,那么keepAliveTime设置过长会导致空闲线程占着资源不放;如果任务执行很重,比如要跑几秒,keepAliveTime设短了会导致线程频繁被回收后又要重新创建,反而把性能浪费在线程创建上。
2.3 workQueue:任务排队的地方
workQueue是线程池里最容易被忽视、又最容易引发线上问题的参数。Java内置了几种阻塞队列,我后面专门用一个章节来说怎么选,这里只提示一句:队列选错了,线程池里线程数量配得再合理都没用。
2.4 threadFactory:给线程起个好名字
threadFactory用来创建线程,但99%的人默认不传,这时线程池会用默认工厂,线程名是pool-1-thread-1这种。问题是,线上出了故障,你去查堆栈,看到一堆pool-1-thread-1,你根本不知道这是哪个业务模块的线程池。
我强烈建议所有生产环境的线程池都自定义ThreadFactory,把业务名带进线程名。
有了这个习惯,线上排查线程问题时,jstack出来一眼就能看出线程归属,节省的时间远远超过写这几行代码的成本。
2.5 handler:队列也满了怎么办
当线程池的线程数已经达到maximumPoolSize,队列也装满了,再来新任务就会触发拒绝策略。Java内置四种,后面我也会展开讲。
先记住一个结论:生产环境默认的AbortPolicy很少是正确答案,它会让任务静默失败(抛RejectedExecutionException),而CallerRunsPolicy往往更稳。
3. 线程池的执行流程,画在脑子里
理解了参数,接下来要把“任务提交流程”刻进脑子里。这个流程是面试高频题,也是排查问题的基础。
几个容易混淆的细节:
- 先入队,后扩线程。很多新手以为是“队列满了才扩线程”,其实更要命的是“核心线程没满之前不会把任务丢进队列”。
- 提交execute任务的线程和执行任务的线程不是同一个,别把ThreadLocal一套,发现值对不上。
- 如果被拒绝的任务是execute提交的,异常会被直接抛出到调用方线程;如果是submit提交的,异常会被封装进Future,调用
future.get()时才抛出。
这个流程在设计上是合理的:优先复用一个固定数量的核心线程,保护系统资源;任务太多导致排队也不要紧,队列本身有缓冲作用;缓冲都顶不住了,才去临时招“非核心线程”来帮忙;最后真的撑不住,拒绝策略兜底。每层都有意义,层层保护。
4. 内置线程池看着好用,坑却不少
Executors工具类提供了4个静态方法,很多人图方便直接用:
newFixedThreadPool(n):固定线程数,队列用无界的LinkedBlockingQueue。newSingleThreadExecutor():单线程,队列同样无界。newCachedThreadPool():核心线程0,最大线程数Integer.MAX_VALUE,队列用SynchronousQueue。newScheduledThreadPool(n):支持定时任务,内部用的DelayedWorkQueue。
先说newFixedThreadPool。它的queue是无界链表队列,意味着所有任务都会排队,永远触发不了拒绝策略。如果任务积压速度一直大于处理速度,队列里的对象会无限膨胀,最后OOM。线上出过的事故很多都是这么来的:一个定时任务半夜跑挂了,第二天早上队列里积压了几百万个任务,直接把内存打爆。
再说newCachedThreadPool。它用的是SynchronousQueue,这个队列不存储元素——提交的任务必须立刻被消费,否则就催线程池新建线程。配合Integer.MAX_VALUE的最大线程数,一旦任务来得又快又多,线程数就会疯狂上涨,最终线程炸穿系统。
内置线程池也不是一无是处,开发环境、控制台工具、任务量可控的场景用它很方便。但线上核心链路,我还是建议直接new ThreadPoolExecutor,参数自己定。这不是教条,是踩过坑后的条件反射。
如果你图省事又想降低风险,也可以基于newFixedThreadPool的思路,把队列换成有界队列,再配上自定义的拒绝策略,这样本质上就是半个自研线程池了。
5. 阻塞队列怎么选:这里藏着90%的配置问题
队列选择是ThreadPoolExecutor配置里最讲究的一环。
5.1 LinkedBlockingQueue:默认的“大胃王”
LinkedBlockingQueue有两种:默认构造是无界的,传容量是有界的。很多人用Executors.newFixedThreadPool就踩了无界的坑。
无界队列的问题我在前面已经说了:队列永远不会满,线程数永远不会超过corePoolSize,拒绝策略永远不会触发。看起来一切平稳,实际上内存会被慢慢吃光。
改进方案:new一个带容量的LinkedBlockingQueue,比如new LinkedBlockingQueue<>(1000),队列能容纳1000个任务缓冲。我的经验是,容量不要设太大,几千上万往往都过大了,具体和业务请求量、消费速度有关。
5.2 ArrayBlockingQueue:有界数组,控制力最强
ArrayBlockingQueue底层是数组,必须指定容量,天生就是有界队列。它比LinkedBlockingQueue更硬核——队列满了就拒绝,没有任何讨价还价的余地。
如果你需要一个“严格限流”的线程池,ArrayBlockingQueue是第一选择。代价是:队列满了之后,新任务会转而触发非核心线程扩容,如果达到了最大线程数,就直接走拒绝策略。
5.3 SynchronousQueue:不存任务的交接队列
SynchronousQueue比较特殊,它内部不缓存任何任务。生产者提交任务时,如果当前没有消费者线程在等待,提交就会失败/阻塞(取决于使用方式)。在ThreadPoolExecutor的场景下,SynchronousQueue的作用是:任务必须立刻被线程消费,否则就触发新建线程。
这正好配合newCachedThreadPool的“任务多就扩线程”策略。但如果你自己用SynchronousQueue搭配一个有限的最大线程数,那么就要求提交任务的速度不能太猛,否则扩容到上限后只能拒绝。
5.4 PriorityBlockingQueue与DelayedWorkQueue
PriorityBlockingQueue支持按优先级出队,适合任务有优先级之分的场景。使用时要注意,入队的Runnable对象必须实现Comparable接口,或者通过构造传入Comparator。
DelayedWorkQueue是ScheduledThreadPoolExecutor内部使用的延迟队列,它保证队首元素是到期时间最近的。如果只是普通并发任务,一般用不到这种队列。
5.5 一个比较直观的选择对照
| 队列类型 | 是否有界 | 适用场景 | 主要风险 |
|---|---|---|---|
| LinkedBlockingQueue(默认) | 无界 | 开发环境/工具类 | 队列积压导致OOM |
| LinkedBlockingQueue(带容量) | 有界 | 通用业务异步任务 | 需配合合理的拒绝策略 |
| ArrayBlockingQueue | 有界 | 严格限流的核心链路 | 队列容量配置不合适容易频繁拒绝 |
| SynchronousQueue | 不存储 | 高吞吐/快速交接型任务 | 线程数易失控 |
| PriorityBlockingQueue | 无界 | 带优先级的任务 | 同样有无界OOM风险 |
经验总结:日常业务里的异步处理、消息推送、日志落盘,我习惯用带容量的LinkedBlockingQueue,容量根据业务峰值来设;核心链路上需要强限流的,用ArrayBlockingQueue;要快速处理和短任务的,才考虑SynchronousQueue。无界队列在我的生产环境里基本绝迹了。
6. 核心线程数怎么算?直接给你可落地的方案
线程数设置其实没有“万能公式”,但业界有一套被验证过的经验模型。
6.1 从任务性质出发
任务分两类:CPU密集型和IO密集型。
- CPU密集型:任务大部分时间在做计算、循环、逻辑处理,占用CPU时间片。线程数建议设为
CPU核数 + 1,多出来的那一个是为了规避因缺页中断等导致某个线程阻塞时CPU空闲的损失。 - IO密集型:任务大量时间在等数据库返回、等外部接口响应、等文件读写,CPU利用率不高。线程数建议设为
CPU核数 * 2左右,如果IO等待时间占比非常大,还可以继续往上调。
更精细一点,有一个“最佳线程数”的经验公式:
比如一个查询接口,平均IO等待耗时80ms,计算耗时20ms,四核机器,目标是让CPU利用率到80%:
这个公式的意义不是给你一个绝对正确的数,而是提醒你:不要拍脑袋,要从等待时间和计算时间的比例来推导。
6.2 线程数不是越大越好
这一点值得反复强调。线程多了,每个线程分到的CPU时间片反而变少,上下文切换的开销变大,吞吐量并不会随之提升,极端情况下反而下降。
我见过一个生产事故:某团队把一个线程池的maximumPoolSize配到2000,结果高并发时光是线程切换就占了CPU的40%以上,接口RT反而飙得很高。最后压测下来发现,合适的最大线程数也就200左右。
6.3 压测验证才是终极手段
经验公式给你一个起点,真正确定参数还得压测。
我的做法是:先用经验公式定一个初始值,然后用压测工具(JMeter、wrk、自研压测脚本)逐步增加并发量和任务提交量,观察线程池状态、队列积压、RT、CPU、内存这五个指标。如果队列一直积压,优先调大线程数或降低任务提交量;如果CPU打满但队列空,说明线程数偏大;如果RT稳定、CPU利用率在合理区间、队列偶尔有点小积压但很快消化完,那就是比较健康的配置。
7. 四种拒绝策略,别再只会用默认的了
当线程池线程数已达上限、队列已满,提交新任务会触发RejectedExecutionHandler。JDK自带了四种实现:
7.1 AbortPolicy(默认)
直接抛出RejectedExecutionException。问题是,它会把任务拒绝的责任丢给调用方,并且调用方如果没做try-catch,任务就悄无声息丢了。
7.2 DiscardPolicy
静默丢弃掉被拒绝的任务,什么异常都没有。看起来无害,实际上会让你的业务数据“凭空消失”,我最不推荐这种策略,除非你明确知道丢掉也无所谓。
7.3 DiscardOldestPolicy
丢弃队列里最老的等待任务,然后重新尝试提交当前任务。这适合“重试新任务、放弃旧任务”的场景,比如实时行情推送,旧数据没意义,新的才要紧。
7.4 CallerRunsPolicy
被拒绝的任务,会在提交任务的线程里直接执行。也就是说,谁提交的谁执行。这样做的效果是:线程池饱和时,提交方线程被占用去执行任务,新的提交速度自然降下来,相当于一种“背压(backpressure)”机制。
我比较推荐线上核心链路用CallerRunsPolicy,理由有三:
- 任务不会丢;
- 提交方线程被拖住,天然削峰;
- 实现简单,不需要额外写补偿逻辑。
但要提醒一点:如果任务执行时间很长,用CallerRunsPolicy会让提交方线程(比如HTTP请求线程)长时间阻塞,影响该线程处理其他请求。所以它是一种“限流+保底”的平衡方案,而不是万金油。
8. 实战配置:一套可以直接抄的线程池方案
这里给出一套我常用的基础模板,你可根据项目情况微调。
这里有几个处理细节我想单独说明:
- corePoolSize=8,假设CPU是4核,IO密集业务(查库、调三方接口),乘2差不多就是8;
- maximumPoolSize=16,允许峰值时扩一倍,但限制死了不让线程失控;
- 队列容量1000,按单任务耗时200ms粗略算,1000个积压任务大概需要200秒消化,这个缓冲足够覆盖大多数瞬时突刺,同时不至于让内存爆掉;
- daemon设为true:线程池线程设为守护线程,配合shutdownHook可以让JVM在关闭时比较果断地退出,但如果你有任务必须执行完,需要改成false并妥善处理shutdown逻辑。
如果是提交后需要拿到结果的场景,用submit而不是execute:
这里必须加超时,否则一个不可控的任务会让你的调用方线程无限等下去。
9. 常见问题与排查技巧实录
9.1 线程池里的线程数一直在涨,上下不去
排查思路:先看队列是否已经积压,再看任务执行耗时是否过长。用jstack抓一下线程栈,看看线程都卡在什么方法上。如果是外部依赖(RPC、数据库)慢,那线程池本身没毛病,是把依赖排查出来降低耗时,或者临时调大线程数顶住。
9.2 队列积压严重,但线程数没有扩
这种情况很可能是核心线程都在跑,但是任务入队成功、队列没满,所以maximumPoolSize的扩容逻辑根本没机会触发。令牌桶限一下提交速度,或者调大maximumPoolSize,看看是否缓解。
另外注意,如果队列是无界的,线程数永远不可能超过corePoolSize,因为任务永远不会“放不进队列”。想靠扩容线程数来提升吞吐,是有界队列的前提。
9.3 execute和submit的任务异常处理姿势不一样
- execute提交:任务内异常会抛到线程池的UncaughtExceptionHandler,如果没设置,异常会打在日志里,但调用方感知不到“提交失败”。
- submit提交:如果任务抛异常,异常被吞进Future里,你不调用get就永远不知道任务失败了。
所以,如果任务里有你可能关心的异常,一定要在run方法里自行try-catch并打日志,或者用submit+get配合超时来捕获,不要让任务失败变成“沉默故障”。
9.4 线程池满了之后任务被拒,怎么做到不丢数据
这要看业务诉求。如果任务是写消息日志、做异步统计这类允许延时的,我建议提交线程池之前先放一个本地内存队列或者MQ,线程池消费完后再去消息中间件取;如果任务本身对实时性要求很高,那宁可拒绝得清晰一点,留下告警记录。
一个简单兜底方案:自定义拒绝策略里,把被拒任务丢到一个补偿线程里重试。
9.5 监控线程池要盯哪些指标
生产环境中,我用下面这段代码做定时监控,每天轮询,配合告警:
这些指标的含义值得展开说一下:
queueSize:排队人数,持续上涨就是告警信号;activeCount:正在执行任务的工作线程数;taskCount:累计提交的任务数,包含排队和完成、被拒的;completedTaskCount:已完成任务数;poolSize:当前线程数;largestPoolSize:线程池曾经到过的最大线程数,用于分析峰值需求。
如果largestPoolSize经常等于maximumPoolSize,说明你的线程池频繁触及扩容上限,可能该调大最大线程数、优化任务耗时、或者削峰限流了。
10. 从“会用”到“懂得配”,核心是理解每个参数背后的代价
回头再看ThreadPoolExecutor,它的七个参数其实是在四个目标之间做平衡:吞吐量、资源占用、排队延迟、任务拒绝率。每个参数都不是孤立的,线程数影响吞吐,队列影响缓冲和内存,拒绝策略影响业务成败。
我见过很多团队把线程池配置挂在一个单独的配置中心里,每次调优都很谨慎,先压测、再灰度、最后全量,这是对的。因为线程池一旦上线,它的表现和业务流量密切相关,你很难在测试环境100%地模拟出生产级别的并发压力。
一些经验写在最后:
- 线程池的名字一定要可读,不要“pool-1”,否则排查问题的时候你会后悔的;
- 队列一定要有界,无界队列等于炸弹,只是引爆时间问题;
- 拒绝策略必须显式定义,明确“任务多到装不下时到底该怎么做”;
- submit交给你的Future,再忙也要加超时get,不要裸调get();
- 上线前务必压测,别信拍脑袋配置;
- 所有线程池都要有对应的监控,没有监控的线程池就是一个黑盒。
线程池不像一个业务组件,你在代码里写完配置就万事大吉了,它更像一个长期运行的“小系统”,需要持续观察和调优。把ThreadPoolExecutor的几个参数、队列特性、执行流程吃透之后,你写并发代码会有一个明显的质的提升——至少不会再因为线程爆炸或者任务丢失而被半夜叫起来处理线上事故了。