全文目录:
-
- 开篇语
- 前言:从一次差点把服务器搞崩的经历说起
- 一、先把"线程"这个东西聊清楚
-
- 1.1 线程到底是什么
- 1.2 线程不是免费的
- 二、不用线程池:裸奔的代价
-
- 2.1 线程数量完全失控
- 2.2 资源无法复用
- 2.3 缺乏统一管理和监控
- 2.4 没有任务排队机制
- 三、线程池的设计哲学:池化思想
- 四、Java 线程池核心实现:把 ThreadPoolExecutor 拆碎了看
-
- 4.1 七个核心参数
-
- `corePoolSize`:核心线程数
- `maximumPoolSize`:最大线程数
- `keepAliveTime` 和 `unit`:非核心线程的存活时间
- `workQueue`:任务等待队列
- `threadFactory`:线程工厂
- `handler`:拒绝策略
- 4.2 线程池的工作流程
- 4.3 Executors 工厂类:方便是方便,但有坑
- 五、代码演示:从错误示范到生产可用
-
- 5.1 错误示范:每来一个任务就 new 一个线程
- 5.2 基础线程池使用
- 5.3 实际场景演示:电商批量发送优惠券通知
- 5.4 带监控和动态调参的线程池封装
- 六、线程池参数怎么设?别再靠直觉拍脑袋
-
- 6.1 任务类型决定了参数方向
- 6.2 队列容量怎么设
- 6.3 动态线程池:不用重启服务来调参
- 七、那些年踩过的坑,一个个说清楚
-
- 7.1 用 Executors.newFixedThreadPool 踩 OOM
- 7.2 多个业务共用一个线程池导致互相影响
- 7.3 ThreadLocal 在线程池中的内存泄漏
- 7.4 shutdown() 和 shutdownNow() 傻傻分不清楚
- 7.5 任务执行时间过长却不设超时
- 八、其他语言和框架里的"线程池思想"
-
- 8.1 Python:concurrent.futures.ThreadPoolExecutor
- 8.2 Go:goroutine 池
- 8.3 Node.js:worker_threads 和任务队列
- 九、线程池的监控与调优:不只是配好参数就完事了
-
- 9.1 关键监控指标
- 9.2 典型问题的调优思路
- 十、总结:线程池不只是一个工具,是一种思维方式
- 文末
开篇语
哈喽,各位小伙伴们,你们好呀,我是喵手。运营社区:C站/掘金/腾讯云/阿里云/华为云/51CTO;其中也正在运营公号「程序员喵手」,欢迎大家常来逛逛。
今天我要给大家分享一些自己日常学习到的一些知识点,并以文字的形式跟大家一起交流,互相学习,一个人虽可以走的更快,但一群人可以走的更远。
我是一名后端开发爱好者,工作日常接触到最多的就是Java语言啦,所以我都尽量抽业余时间把自己所学到所会的,通过文章的形式进行输出,希望以这种方式帮助到更多的初学者或者想入门的小伙伴们,同时也能对自己的技术进行沉淀,加以复盘,查缺补漏。
小伙伴们在批阅的过程中,如果觉得文章不错,欢迎点赞、收藏、关注哦。三连即是对作者我写作道路上最好的鼓励与支持!
前言:从一次差点把服务器搞崩的经历说起
说实话,我第一次真正意识到"线程池"这个东西的重要性,不是在课堂上,也不是在刷面试题的时候——是在一次差点被客户投诉、差点被组长叫去谈话的线上故障里。
那是我参与的第一个正经项目,一套给某中型电商平台做的促销系统。需求很简单:用户触发特定条件后,后台异步发送优惠券通知。我当时刚接触多线程没多久,心里想,异步嘛,开个线程不就行了?于是写出了这样的代码:
// 千万别在生产环境这么干,这是反面教材
public void sendCouponNotification(List<User> users) {
for (User user : users) {
new Thread(() -> {
couponService.sendNotification(user);
}).start();
}
}
逻辑清晰,代码简洁,自我感觉良好。测试环境一跑,没问题。上线。
然后促销活动一开始,几万个用户同时触发条件,几万条线程同时被创建。服务器 CPU 直接飙到 100%,内存 OOM,服务宕机,告警群炸了,电话打过来了,我整个人是懵的。
事后排查,问题就出在这里——每来一个任务就创建一个线程,完全不加控制。这次事故让我把线程池从头到尾啃了一遍,也彻底理解了为什么经验老道的工程师每次看到 new Thread(…).start() 都会皱眉头。
这篇文章就是我把那次"交学费"的经历和后来的积累整理出来,想说清楚:为什么要用线程池、线程池解决了哪些问题、怎么用好它,以及踩过的那些坑。
适合人群:有一定 Java 基础、了解多线程基本概念、想搞清楚线程池原理和实践的开发者。如果你写过 new Thread(…).start() 然后觉得"能跑就行",这篇文章非常适合你。
一、先把"线程"这个东西聊清楚
在聊线程池之前,得先对线程本身有个清醒的认识。很多人把线程当成一个免费的、随开随用的轻量化工具,这个认知是有问题的。
1.1 线程到底是什么
用通俗的话讲,进程就像一家公司,拥有独立的办公室(内存空间)、独立的资产(文件描述符、网络连接等);线程则是这家公司里的员工,多个员工共享同一个办公室和资产,每个人负责处理不同的任务。
从操作系统角度来看,线程是 CPU 调度的最小单位。每个线程都有自己独立的:
- 程序计数器(PC Register):记录当前线程执行到哪条指令了;
- 虚拟机栈(JVM Stack):每个方法调用对应一个栈帧,存放局部变量、操作数栈等;
- 本地方法栈(Native Method Stack):处理 Native 方法调用;
而堆内存、方法区(元空间)、直接内存等,则是进程内所有线程共享的。
1.2 线程不是免费的
这是很多初学者的误区——认为线程很"轻",随便开。但实际上,每创建一个线程,都是有代价的。
内存开销
在 Java 中,每个线程默认的栈大小(-Xss 参数)通常是 512KB 到 1MB(不同 JVM 实现和操作系统略有差异)。这意味着你创建 1000 个线程,光栈内存就得消耗 500MB 到 1GB。你服务器有多少内存,掰着手指头算一算。
创建和销毁的开销
Java 线程的创建,在底层对应的是操作系统的内核线程(Kernel Thread)。这个过程涉及系统调用,需要在用户态和内核态之间切换,是一个相对昂贵的操作。你每 new Thread() 一次,背后都在做这件事,每次任务执行完,线程销毁又是一次类似的开销。
高频场景下,线程的创建和销毁成本,可能比任务本身的执行成本还高,这就很尴尬了。
上下文切换的代价
CPU 核心数是固定的,线程数却可以远超核心数。当线程数量超过 CPU 核心数时,CPU 就得在多个线程之间来回切换,这个过程叫上下文切换(Context Switch)。
每次切换,CPU 需要保存当前线程的状态(寄存器、程序计数器等),加载下一个线程的状态。这个操作本身耗时大概在几微秒到几十微秒之间,听起来不多,但当你线程数达到几千个的时候,CPU 大量时间都浪费在"换状态"上,而不是在真正干活。
线程越多,不一定越快,到了某个临界点之后反而越慢——这不是玄学,是操作系统的基本规律。
二、不用线程池:裸奔的代价
理解了线程本身的代价之后,再回头看"每次任务就 new 一个线程"的做法,问题就很清晰了。
2.1 线程数量完全失控
直接 new Thread() 最大的问题是:你无法控制系统中同时存在多少个线程。
任务来多少,线程就开多少,没有任何上限。在低并发场景下看起来没问题,一旦流量上来,瞬间就是几千、几万个线程同时运行。
还记得我前言里说的那次事故吗?几万个用户同时触发,几万条线程同时跑——这不是多线程在帮你,这是多线程在拖垮你。
2.2 资源无法复用
一个线程执行完任务之后,如果直接销毁,那下次来新任务还得重新创建。这个"创建 → 执行 → 销毁"的循环,每次都在白白消耗系统资源。
类比一下:你开了一家餐厅,每来一桌客人,你就从街上临时招一个服务员,客人走了就把服务员辞掉。下一桌来了再招。这种运营方式效率极低,成本极高。
正常做法是养一批固定的服务员(线程),轮流接待客人(任务),不用就让他们待命,来了任务直接上,任务结束回到待命状态。这就是线程池的核心思想。
2.3 缺乏统一管理和监控
裸 new Thread() 的线程,一旦启动,你就基本失去了对它的掌控:
- 你不知道当前系统里有多少个线程在跑;
- 你不知道任务执行了多久,有没有卡死;
- 你不知道出错了怎么处理,异常了怎么上报;
- 你无法对任务进行排队、优先级调整;
- 你无法在系统过载时做限流和降级。
生产系统里,不可观测的东西就是定时炸弹。
2.4 没有任务排队机制
请求高峰期,如果瞬时来了 10000 个任务,直接 new 10000 个线程,系统很可能直接崩溃。
但如果有了线程池,你可以设置"最多同时执行 200 个任务,其余的放到队列里等待"——这样系统始终在可控的负载范围内运行,不会因为瞬时峰值把服务搞垮。
这种流量削峰的能力,是裸 new Thread() 完全没有的。
三、线程池的设计哲学:池化思想
线程池本质上是一种**对象池(Object Pool)**设计模式的具体实现。
所谓池化,就是预先创建并维护一批资源,按需分配,用完归还,反复复用,而不是每次都走"申请 → 使用 → 销毁"这套昂贵的流程。
你身边其实到处都是"池化"的影子:
- 数据库连接池(Connection Pool):每次数据库操作不用重新建连接,复用已有连接;
- HTTP 连接池:HTTP/1.1 的 Keep-Alive 和 HTTP/2 的多路复用,都是在复用连接;
- 对象池:Netty 里的 PooledByteBufAllocator,避免频繁分配和回收内存;
- 线程池(Thread Pool):复用线程,避免频繁创建和销毁。
池化思想的核心价值,总结起来就三个字:省、稳、管。
- 省:减少资源反复申请和释放的开销;
- 稳:通过控制资源上限,防止系统因资源耗尽而崩溃;
- 管:提供统一的管理入口,便于监控、调优、治理。
四、Java 线程池核心实现:把 ThreadPoolExecutor 拆碎了看
Java 平台里线程池的核心实现类是 java.util.concurrent.ThreadPoolExecutor,这是整个 JUC(Java Util Concurrent)并发包里最复杂、也最值得深入研究的一个类。很多人用 Executors 工厂方法创建线程池,实际上底层都是它。
4.1 七个核心参数
ThreadPoolExecutor 最完整的构造函数接收七个参数,别被七个参数吓到,每一个都有其明确的含义,搞清楚了之后就不会觉得复杂。
public ThreadPoolExecutor(
int corePoolSize, // 核心线程数
int maximumPoolSize, // 最大线程数
long keepAliveTime, // 非核心线程的存活时间
TimeUnit unit, // 存活时间的单位
BlockingQueue<Runnable> workQueue, // 任务等待队列
ThreadFactory threadFactory, // 线程工厂
RejectedExecutionHandler handler // 拒绝策略
)
我来一个个拆解,用我自己的理解来说:
corePoolSize:核心线程数
这是线程池的"编制内员工数量"。线程池刚启动时是空的,随着任务提交,会逐渐创建线程,直到线程数达到 corePoolSize。达到之后,即使这些核心线程处于空闲状态,也不会被销毁(除非设置了 allowCoreThreadTimeOut(true))。
类比:餐厅的正式员工。不管有没有客人,正式员工都在岗,随时准备接活。
maximumPoolSize:最大线程数
这是线程池里线程数量的绝对上限。当任务队列满了,并且当前线程数还没有达到 maximumPoolSize,线程池才会创建新的"临时工"线程来处理任务。
类比:餐厅的兼职员工。只有正式员工忙不过来、并且排队的人太多时,才会叫兼职来帮忙。
注意:只有队列满了之后,才会创建超过 corePoolSize 的线程,很多人搞错顺序,以为先把线程拉满再入队,这是不对的。
keepAliveTime 和 unit:非核心线程的存活时间
当线程池中的线程数超过 corePoolSize 时,那些多余的"临时工"线程,如果空闲时间超过 keepAliveTime,就会被销毁。
类比:兼职员工闲置超过约定时间,就送回家了。
workQueue:任务等待队列
这是重中之重,很多线上 OOM 问题都出在这里。常见的选择有三种:
-
LinkedBlockingQueue:基于链表的无界队列(注意:说是"无界",实际上默认容量是 Integer.MAX_VALUE,约 21 亿),理论上可以无限排队。Executors.newFixedThreadPool 就用的这个,非常危险。
-
ArrayBlockingQueue:基于数组的有界队列,创建时必须指定容量。生产环境推荐使用这个,防止任务堆积把内存撑爆。
-
SynchronousQueue:容量为 0 的特殊队列,任务到来后必须立刻有线程来接,否则就触发拒绝策略(或创建新线程)。Executors.newCachedThreadPool 用的这个,适合任务量大、执行快的场景,但线程数可能无上限。
还有 PriorityBlockingQueue(优先级队列),用于需要任务优先级排序的场景,实际用得不多,但要知道有这个选项。
threadFactory:线程工厂
这个参数很多人直接用默认值,但在生产环境里,强烈建议自定义 ThreadFactory,至少给线程起个有意义的名字。
为什么?因为当你在线上排查问题,打开线程 dump 看到满屏的 pool-1-thread-1、pool-2-thread-1,根本不知道哪个线程池是干什么用的。而如果你给业务线程池命名为 order-process-thread-1,一眼就能定位。
// 使用 Guava 的 ThreadFactoryBuilder,或者自己实现
ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
.setNameFormat("order-process-thread-%d")
.setDaemon(false)
.build();
handler:拒绝策略
当线程数达到 maximumPoolSize 且队列也满了,新来的任务该怎么处理?这就是拒绝策略要解决的问题。
JDK 提供了四种内置策略:
| AbortPolicy(默认) | 直接抛出 RejectedExecutionException |
| CallerRunsPolicy | 由提交任务的那个线程自己来执行这个任务 |
| DiscardPolicy | 悄悄丢弃任务,不报错也不通知 |
| DiscardOldestPolicy | 丢弃队列里等待最久的那个任务,把新任务加进去 |
老实说,这四个策略在不同场景下各有合理性,但我在实际项目里,用得最多的是自定义拒绝策略——把被拒绝的任务记录到日志、写入 MQ 或者持久化,后续补偿处理,而不是简单地丢掉或者抛异常。
4.2 线程池的工作流程
把这七个参数联系起来,线程池的任务调度流程是这样的:
提交任务
│
▼
当前线程数 < corePoolSize?
│是 ──→ 创建新的核心线程执行任务
│否
▼
任务队列未满?
│是 ──→ 任务入队,等待核心线程来取
│否
▼
当前线程数 < maximumPoolSize?
│是 ──→ 创建新的非核心线程执行任务
│否
▼
执行拒绝策略
这个流程一定要背下来,面试高频考点,实际问题排查更要用到。注意一个非常容易犯错的认知误区:任务不是线程数满了才入队,而是核心线程数满了就入队,队列满了才继续扩展线程数。
4.3 Executors 工厂类:方便是方便,但有坑
Executors 是 JDK 提供的创建线程池的工具类,用起来很简洁:
// 固定线程数线程池
ExecutorService fixedPool = Executors.newFixedThreadPool(10);
// 可缓存线程池
ExecutorService cachedPool = Executors.newCachedThreadPool();
// 单线程线程池
ExecutorService singlePool = Executors.newSingleThreadExecutor();
// 定时任务线程池
ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(5);
但阿里巴巴 Java 开发手册里明确不推荐使用 Executors 创建线程池,为什么?
- newFixedThreadPool 和 newSingleThreadExecutor:使用 LinkedBlockingQueue 无界队列,任务堆积可能导致 OOM。
- newCachedThreadPool 和 newScheduledThreadPool:最大线程数是 Integer.MAX_VALUE,线程数量可能无限增长,也可能导致 OOM。
这不是说 Executors 一定不能用,而是说你用它的时候得清楚它背后的参数,知道它的风险在哪里。
最稳妥的做法,还是手动 new ThreadPoolExecutor(…) 把七个参数都显式配置好,一眼就能看出这个线程池的行为边界在哪里。
五、代码演示:从错误示范到生产可用
5.1 错误示范:每来一个任务就 new 一个线程
// ❌ 错误示范,勿在生产环境使用
public class BadPracticeDemo {
public void processOrders(List<Order> orders) {
for (Order order : orders) {
// 每个订单都 new 一个线程,完全不可控
new Thread(() -> {
processOrder(order);
}).start();
}
}
private void processOrder(Order order) {
// 模拟订单处理逻辑
System.out.println("Processing order: " + order.getId());
}
}
这种写法在测试环境的小数据量下看起来没问题,但生产环境一旦订单量大起来,就是个定时炸弹。
5.2 基础线程池使用
import java.util.concurrent.*;
public class BasicThreadPoolDemo {
// 创建一个有具体参数的线程池
private static final ThreadPoolExecutor executor = new ThreadPoolExecutor(
5, // corePoolSize:5个核心线程
10, // maximumPoolSize:最多10个线程
60, // keepAliveTime:非核心线程闲置60秒后销毁
TimeUnit.SECONDS, // 时间单位
new ArrayBlockingQueue<>(100), // 有界队列,最多积压100个任务
new ThreadFactoryBuilder()
.setNameFormat("basic-pool-thread-%d")
.build(),
new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝时由调用者线程执行
);
public static void main(String[] args) throws InterruptedException {
// 提交 20 个任务
for (int i = 0; i < 20; i++) {
final int taskId = i;
executor.submit(() -> {
System.out.println(Thread.currentThread().getName()
+ " 正在执行任务 " + taskId);
try {
Thread.sleep(500); // 模拟任务耗时
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
}
// 优雅关闭:等待已提交的任务执行完毕,不再接收新任务
executor.shutdown();
// 等待最多30秒让任务完成
if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
// 超时后强制关闭
executor.shutdownNow();
}
}
}
注意这里的几个细节:
- 用的是 ArrayBlockingQueue(100),有界队列,防止任务无限堆积;
- 线程命名了,方便排查;
- 拒绝策略选的是 CallerRunsPolicy,被拒绝的任务由提交者线程自己跑,相当于一种"自动限速",调用方的速度会被动降下来;
- 关闭时先 shutdown() 再 awaitTermination(),这是优雅关闭的标准姿势。
5.3 实际场景演示:电商批量发送优惠券通知
这是一个相对贴近生产的场景。假设我们要给 10 万用户批量发送优惠券到期提醒,需要异步处理,且不能把系统压垮。
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
public class CouponNotificationService {
// 统计成功和失败数量,方便后续监控
private final AtomicInteger successCount = new AtomicInteger(0);
private final AtomicInteger failCount = new AtomicInteger(0);
/**
* 自定义线程池:专门用于优惠券通知发送
* 参数说明:
* – corePoolSize = 10:维持10个核心线程,保证基本处理能力
* – maximumPoolSize = 30:高峰期最多开到30个线程
* – keepAliveTime = 120s:临时线程闲置2分钟后回收,节省资源
* – workQueue = ArrayBlockingQueue(5000):最多积压5000个任务
* – 拒绝策略:自定义,记录日志 + 写入补偿队列
*/
private final ThreadPoolExecutor notificationPool = new ThreadPoolExecutor(
10,
30,
120,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(5000),
new ThreadFactoryBuilder()
.setNameFormat("coupon-notify-thread-%d")
.setUncaughtExceptionHandler((thread, ex) -> {
// 捕获线程里未处理的异常,防止线程静默死亡
log.error("线程 {} 发生未捕获异常", thread.getName(), ex);
})
.build(),
(task, executor) -> {
// 自定义拒绝策略:记录被拒绝的任务,写入补偿机制
log.warn("优惠券通知任务被拒绝,当前队列长度: {}, 活跃线程数: {}",
notificationPool.getQueue().size(),
notificationPool.getActiveCount());
// 实际项目里这里可以写入 Redis 或 MQ,做补偿重试
}
);
/**
* 批量发送优惠券到期提醒
*/
public void batchSendExpirationNotice(List<UserCoupon> expiredCoupons) {
log.info("开始批量发送优惠券到期通知,共 {} 条", expiredCoupons.size());
// 使用 CountDownLatch 等待所有任务完成(可选,取决于是否需要同步等待)
CountDownLatch latch = new CountDownLatch(expiredCoupons.size());
for (UserCoupon coupon : expiredCoupons) {
notificationPool.submit(() -> {
try {
doSendNotification(coupon);
successCount.incrementAndGet();
} catch (Exception e) {
failCount.incrementAndGet();
log.error("发送优惠券通知失败,userId: {}, couponId: {}",
coupon.getUserId(), coupon.getCouponId(), e);
} finally {
// 无论成功失败都要 countDown,防止 latch 永远等待
latch.countDown();
}
});
}
try {
// 最多等待 10 分钟
boolean finished = latch.await(10, TimeUnit.MINUTES);
if (!finished) {
log.warn("批量通知未在10分钟内全部完成,已完成数: {}",
successCount.get() + failCount.get());
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
log.error("等待通知任务完成时被中断", e);
}
log.info("批量通知完成,成功: {}, 失败: {}", successCount.get(), failCount.get());
}
/**
* 实际发送通知的逻辑(模拟)
*/
private void doSendNotification(UserCoupon coupon) {
// 这里调用短信服务、推送服务或邮件服务
// 模拟网络 IO 耗时
Thread.sleep(50);
// smsService.send(coupon.getUserPhone(), buildMessage(coupon));
}
/**
* 获取当前线程池状态,用于监控
*/
public ThreadPoolStats getPoolStats() {
return ThreadPoolStats.builder()
.poolSize(notificationPool.getPoolSize())
.activeCount(notificationPool.getActiveCount())
.queueSize(notificationPool.getQueue().size())
.completedTaskCount(notificationPool.getCompletedTaskCount())
.build();
}
}
这段代码里有几个我觉得值得特别说说的细节:
关于 UncaughtExceptionHandler:这个很容易被忽略。线程池里的任务如果抛了未捕获的异常,线程会静默死亡(特别是用 execute() 提交的任务),你根本不知道出了问题,监控上也看不到。设置 UncaughtExceptionHandler 可以捕获这类异常并记录日志。
关于 finally { latch.countDown() }:这是一个非常重要的写法习惯。countDown() 必须放在 finally 块里,保证无论任务成功还是失败,计数器都会减一。如果放在 try 块里,一旦任务异常,countDown() 不执行,latch.await() 就会一直卡死,直到超时。
关于自定义拒绝策略:生产环境里直接丢任务或者抛异常,很多时候是不可接受的。更好的做法是记录日志 + 写入补偿队列,确保任务最终都被处理。
5.4 带监控和动态调参的线程池封装
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;
/**
* 可监控、可动态调参的线程池封装
* 在 ThreadPoolExecutor 基础上扩展了:
* 1. 任务执行耗时统计
* 2. 动态修改核心参数(corePoolSize / maximumPoolSize)
* 3. 任务提交前后的钩子(可用于链路追踪、MDC 上下文传递)
*/
public class MonitorableThreadPool extends ThreadPoolExecutor {
// 记录任务总执行时间,用于计算平均耗时
private final AtomicLong totalExecutionTime = new AtomicLong(0);
// 记录任务执行次数
private final AtomicLong taskExecutionCount = new AtomicLong(0);
// 线程局部变量,记录每个任务的开始时间
private final ThreadLocal<Long> taskStartTime = new ThreadLocal<>();
public MonitorableThreadPool(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit,
workQueue, threadFactory, handler);
}
/**
* 任务执行前的钩子:记录开始时间
* 这里还可以做 MDC 上下文传递(比如 traceId 透传到子线程)
*/
@Override
protected void beforeExecute(Thread t, Runnable r) {
super.beforeExecute(t, r);
taskStartTime.set(System.currentTimeMillis());
}
/**
* 任务执行后的钩子:统计耗时
*/
@Override
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
Long startTime = taskStartTime.get();
if (startTime != null) {
long elapsed = System.currentTimeMillis() – startTime;
totalExecutionTime.addAndGet(elapsed);
taskExecutionCount.incrementAndGet();
// 清除 ThreadLocal,防止内存泄漏(线程复用时会有遗留值)
taskStartTime.remove();
}
// 如果任务执行时抛了异常,这里可以统一处理
if (t != null) {
log.error("线程池任务执行异常", t);
}
}
/**
* 获取任务平均执行耗时(毫秒)
*/
public double getAverageExecutionTime() {
long count = taskExecutionCount.get();
if (count == 0) return 0;
return (double) totalExecutionTime.get() / count;
}
/**
* 动态调整核心线程数
* 可以结合配置中心(如 Nacos、Apollo)实现运行时无感调参
*/
public void adjustCorePoolSize(int newCorePoolSize) {
int maxPoolSize = getMaximumPoolSize();
if (newCorePoolSize > maxPoolSize) {
// 先扩大 maxPoolSize,再扩大 corePoolSize,避免参数非法
setMaximumPoolSize(newCorePoolSize);
setCorePoolSize(newCorePoolSize);
} else {
setCorePoolSize(newCorePoolSize);
}
log.info("线程池核心线程数已调整为: {}", newCorePoolSize);
}
/**
* 打印当前线程池状态快照,方便 Debug
*/
public void printStats() {
log.info("=== 线程池状态 ===\\n" +
"核心线程数: {}\\n" +
"最大线程数: {}\\n" +
"当前线程数: {}\\n" +
"活跃线程数: {}\\n" +
"队列积压数: {}\\n" +
"已完成任务数: {}\\n" +
"平均任务耗时: {}ms",
getCorePoolSize(),
getMaximumPoolSize(),
getPoolSize(),
getActiveCount(),
getQueue().size(),
getCompletedTaskCount(),
String.format("%.2f", getAverageExecutionTime()));
}
}
这个 MonitorableThreadPool 继承了 ThreadPoolExecutor 并重写了 beforeExecute() 和 afterExecute() 两个钩子方法。这两个方法是 ThreadPoolExecutor 专门预留出来给子类扩展用的,官方文档里也有说明。
特别注意 afterExecute 里的 taskStartTime.remove()——ThreadLocal 用完一定要清除,这是在线程池里使用 ThreadLocal 最容易踩的坑之一,后面我会单独讲。
六、线程池参数怎么设?别再靠直觉拍脑袋
很多同学在配置线程池参数时,要么直接用默认值,要么随便写个数字,很少真正思考过"为什么是这个值"。
6.1 任务类型决定了参数方向
线程池的参数没有放之四海而皆准的标准答案,核心在于你的任务是 CPU 密集型 还是 IO 密集型。
CPU 密集型任务(计算、加解密、压缩、图像处理等)
这类任务的特点是"一直在占用 CPU 运算",中间基本没有等待。这种场景下,线程数超过 CPU 核心数之后,CPU 就需要做上下文切换,反而拖慢速度。
经典推荐公式:
corePoolSize = CPU 核心数 + 1
加 1 是为了某个线程偶尔因为缺页中断等原因暂停时,额外的线程能顶上。
IO 密集型任务(数据库查询、HTTP 调用、文件读写等)
这类任务大量时间在等待 IO 响应,CPU 大部分时间是空闲的。这种场景下,可以设置比 CPU 核心数更多的线程,让 CPU 在等 IO 的时候去处理其他线程的任务,提高利用率。
一个常见的参考公式:
corePoolSize = CPU 核心数 * (1 + 等待时间 / 计算时间)
假如你的任务等待时间(IO 等待)是 90ms,计算时间是 10ms,CPU 是 8 核:
corePoolSize = 8 * (1 + 90/10) = 8 * 10 = 80
当然,这个公式是理论值,实际要结合压测结果来调整。
老实说,公式只是起点,不是终点。 真实的系统里,任务类型往往是混合的,等待时间也不是固定的,最终还是得靠压测数据说话。
6.2 队列容量怎么设
任务队列容量这个参数,很多人设得要么太大(结果内存撑爆),要么太小(结果任务频繁被拒绝)。
一个比较实用的思路:
先估算最大可接受的任务积压时间。比如你的任务平均处理时长是 100ms,核心线程数是 10,那么每秒最多处理 100 个任务。如果你希望系统最多积压 10 秒的量,那队列容量 = 100 * 10 = 1000。
当然,这也是粗估,具体还要结合内存容量、单个任务对象的大小来计算,防止队列里的对象本身就把内存占满了。
6.3 动态线程池:不用重启服务来调参
静态配置的线程池有一个痛点:参数写死在代码里,调参必须重新发布服务。在生产环境里,重新发布服务是有成本和风险的。
现在有一些开源的动态线程池解决方案,比如 Hippo4j 和 dynamic-tp,它们的核心思想是:
这个能力在生产环境里非常实用,遇到流量突增时,不用停服就能动态扩充线程数,相当灵活。
七、那些年踩过的坑,一个个说清楚
7.1 用 Executors.newFixedThreadPool 踩 OOM
这是最常见的坑,没有之一。
Executors.newFixedThreadPool(10) 看起来很安全,固定 10 个线程,应该没问题吧?但它用的是 LinkedBlockingQueue,默认容量是 Integer.MAX_VALUE。如果任务消费速度远低于提交速度,队列里的任务对象会无限堆积,把内存撑爆。
// 看看 Executors.newFixedThreadPool 的源码
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()); // 这行!
}
LinkedBlockingQueue 无参构造函数,容量是 Integer.MAX_VALUE,约 21 亿。任务对象很小也好,乘上 21 亿那也是天文数字。
解决方案:自己 new ThreadPoolExecutor,用有界的 ArrayBlockingQueue,明确指定容量。
7.2 多个业务共用一个线程池导致互相影响
这个坑比较隐蔽。假设你的应用里有两类任务:一类是发送邮件通知(耗时长,IO 密集),另一类是处理订单(耗时短,CPU 密集)。如果你把这两类任务都往同一个线程池里塞,会发生什么?
发邮件的任务由于耗时长,会长时间占用线程,导致队列里的订单处理任务迟迟得不到执行,用户下单后等了很久才看到响应。两个本来互不相关的业务,因为共用线程池,产生了相互影响。
解决方案:不同类型的业务使用独立的线程池,资源隔离,互不干扰。这也是服务治理里"线程隔离"思想的体现,Hystrix 和 Resilience4j 都有类似的机制。
7.3 ThreadLocal 在线程池中的内存泄漏
这个坑我踩过,而且踩得很深。
ThreadLocal 的设计初衷是给每个线程维护一份独立的变量副本,生命周期和线程绑定。在普通线程里,线程执行完就销毁,ThreadLocal 里的值随之被回收,没有问题。
但在线程池里,线程是复用的,不会被销毁。某次请求往 ThreadLocal 里塞了一个值,任务执行完但没有清除,这个值就一直留在这个线程的 ThreadLocal 里。下一次这个线程被复用来执行另一个任务时,新的任务读取到的 ThreadLocal 里,还是上一次任务遗留的值——这叫脏数据。
更严重的是,如果 ThreadLocal 里放的对象比较大,并且长时间不清除,就会造成内存泄漏。
// 错误示范
executor.submit(() -> {
// 往 ThreadLocal 里存了用户信息
UserContext.set(currentUser);
try {
doSomeWork();
} catch (Exception e) {
log.error("任务执行失败", e);
// ❌ 这里没有清除 ThreadLocal
}
// ❌ 正常路径里也没有清除
});
// ✅ 正确做法:用 try-finally 确保清除
executor.submit(() -> {
UserContext.set(currentUser);
try {
doSomeWork();
} finally {
UserContext.remove(); // ✅ 无论成功还是失败,都要清除
}
});
凡是在线程池里使用 ThreadLocal,务必在 finally 块里调用 remove(),这是铁律。
7.4 shutdown() 和 shutdownNow() 傻傻分不清楚
很多人在应用关闭的时候,直接对着线程池调 shutdownNow(),以为这样"强制关闭"更彻底。但这两个方法的行为差别很大:
- shutdown():温和关闭。不再接受新任务,但会等待已提交的任务(包括队列里等待的任务)全部执行完再关闭。
- shutdownNow():强制关闭。不再接受新任务,尝试中断所有正在执行的任务,并将队列里未执行的任务作为返回值返回。但要注意,中断不一定立刻生效,被中断的线程需要响应 InterruptedException 才会真正停下来。
生产环境里,建议这样写:
// 优雅关闭线程池的标准姿势
executor.shutdown(); // 停止接受新任务
try {
// 给60秒让正在运行的任务完成
if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
// 超时后强制关闭
List<Runnable> pendingTasks = executor.shutdownNow();
log.warn("线程池强制关闭,丢弃了 {} 个未执行的任务", pendingTasks.size());
// 如果允许,可以把 pendingTasks 记录下来,后续补偿
}
} catch (InterruptedException e) {
executor.shutdownNow();
Thread.currentThread().interrupt();
}
7.5 任务执行时间过长却不设超时
线程池里如果有些任务会因为某种原因"卡死"(比如调用了某个接口,对方没有设置超时,一直等不到响应),这些线程就会一直处于 BLOCKED 或 WAITING 状态,把线程池的线程都占满,新的任务就进不来了。
这叫线程饥饿,症状是:监控上看到活跃线程数等于最大线程数,队列持续积压,但任务完成数几乎不增加。
解决方案:
八、其他语言和框架里的"线程池思想"
线程池不是 Java 专属的概念,不同语言和运行时都有自己的实现方式,但背后的思想是一脉相承的。
8.1 Python:concurrent.futures.ThreadPoolExecutor
Python 里,concurrent.futures 模块提供了 ThreadPoolExecutor,用法上和 Java 很像,但更简洁:
from concurrent.futures import ThreadPoolExecutor, as_completed
import time
def send_notification(user_id: int) –> dict:
"""模拟发送通知,有网络 IO 耗时"""
time.sleep(0.1) # 模拟 IO
return {"user_id": user_id, "status": "success"}
def batch_notify(user_ids: list[int]) –> list[dict]:
results = []
# max_workers 相当于线程池的 maximumPoolSize
with ThreadPoolExecutor(max_workers=20) as executor:
# submit 提交任务,返回 Future 对象
future_to_uid = {
executor.submit(send_notification, uid): uid
for uid in user_ids
}
# as_completed 会在每个 Future 完成时立即返回
for future in as_completed(future_to_uid):
uid = future_to_uid[future]
try:
result = future.result(timeout=5) # 最多等待5秒
results.append(result)
except TimeoutError:
print(f"用户 {uid} 的通知发送超时")
except Exception as e:
print(f"用户 {uid} 通知发送失败: {e}")
return results
if __name__ == "__main__":
user_ids = list(range(1, 101)) # 100个用户
results = batch_notify(user_ids)
print(f"成功发送: {len(results)} 条通知")
Python 的 with ThreadPoolExecutor(…) as executor 语法配合上下文管理器,会在 with 块结束时自动调用 shutdown(wait=True),等价于 Java 里的 shutdown() + awaitTermination(),非常优雅。
需要注意的是,Python 由于 GIL(全局解释器锁) 的存在,ThreadPoolExecutor 在 CPU 密集型任务上并不能真正利用多核,遇到计算密集的场景要用 ProcessPoolExecutor(多进程)来替代。IO 密集型任务(网络请求、文件读写)不受 GIL 影响,ThreadPoolExecutor 效果很好。
8.2 Go:goroutine 池
Go 的并发哲学和 Java 不同,它的 goroutine 本身就是轻量级协程(goroutine 的初始栈只有 2KB,远小于 Java 线程的 512KB 起步),理论上可以同时跑几十万个 goroutine 而不崩溃。
但即便如此,在某些极端场景下(比如大量 goroutine 同时等待锁或 IO),goroutine 也可能成为问题。所以 Go 社区里也有"goroutine 池"的最佳实践,主要通过 channel + worker 模式来实现:
package main
import (
"fmt"
"sync"
"time"
)
// WorkerPool 简单的 goroutine 池实现
type WorkerPool struct {
workerCount int
jobQueue chan func()
wg sync.WaitGroup
}
func NewWorkerPool(workerCount int, queueSize int) *WorkerPool {
pool := &WorkerPool{
workerCount: workerCount,
jobQueue: make(chan func(), queueSize),
}
pool.start()
return pool
}
func (p *WorkerPool) start() {
for i := 0; i < p.workerCount; i++ {
go func() {
for job := range p.jobQueue {
job() // 执行任务
p.wg.Done() // 标记任务完成
}
}()
}
}
func (p *WorkerPool) Submit(job func()) {
p.wg.Add(1)
p.jobQueue <- job // 任务入队,如果队列满了会阻塞
}
func (p *WorkerPool) Wait() {
p.wg.Wait()
}
func (p *WorkerPool) Close() {
close(p.jobQueue)
}
func main() {
pool := NewWorkerPool(10, 100)
for i := 0; i < 50; i++ {
id := i
pool.Submit(func() {
time.Sleep(50 * time.Millisecond)
fmt.Printf("任务 %d 执行完毕\\n", id)
})
}
pool.Wait()
pool.Close()
fmt.Println("所有任务完成")
}
Go 的方式和 Java 有所不同,但"维护一批 worker,通过队列分发任务"这个核心思路是一样的。
8.3 Node.js:worker_threads 和任务队列
Node.js 是单线程事件循环模型,通常不需要线程池来处理并发 IO(libuv 底层的 IO 就是异步的)。但如果有 CPU 密集型任务,就需要用到 worker_threads 模块来避免阻塞主线程。
// worker-pool.js
const { Worker, isMainThread, parentPort } = require('worker_threads');
const os = require('os');
class WorkerPool {
constructor(workerScript, numWorkers = os.cpus().length) {
this.workerScript = workerScript;
this.numWorkers = numWorkers;
this.workers = [];
this.queue = [];
this.activeWorkers = new Set();
// 初始化 worker 线程
for (let i = 0; i < numWorkers; i++) {
this._addWorker();
}
}
_addWorker() {
const worker = new Worker(this.workerScript);
worker.on('message', (result) => {
// worker 执行完成,取出 resolve 回调
const { resolve } = worker._currentTask;
this.activeWorkers.delete(worker);
worker._currentTask = null;
resolve(result);
// 从队列里取下一个任务
this._processQueue(worker);
});
worker.on('error', (err) => {
const { reject } = worker._currentTask;
this.activeWorkers.delete(worker);
reject(err);
this._processQueue(worker);
});
this.workers.push(worker);
}
_processQueue(worker) {
if (this.queue.length > 0) {
const { task, resolve, reject } = this.queue.shift();
this._runTask(worker, task, resolve, reject);
}
}
_runTask(worker, task, resolve, reject) {
this.activeWorkers.add(worker);
worker._currentTask = { resolve, reject };
worker.postMessage(task);
}
run(task) {
return new Promise((resolve, reject) => {
// 找一个空闲的 worker
const idleWorker = this.workers.find(w => !this.activeWorkers.has(w));
if (idleWorker) {
this._runTask(idleWorker, task, resolve, reject);
} else {
// 所有 worker 都在忙,入队等待
this.queue.push({ task, resolve, reject });
}
});
}
async destroy() {
for (const worker of this.workers) {
await worker.terminate();
}
}
}
module.exports = { WorkerPool };
虽然 Node.js 里不常见"线程池"这个词,但这套 worker + 队列的模式,和线程池的核心思路是完全一致的。
九、线程池的监控与调优:不只是配好参数就完事了
很多人觉得线程池参数配好了就万事大吉,其实生产环境里,监控和调优是比初次配置更重要的事。
9.1 关键监控指标
以下几个指标是线程池健康状况的"体检报告":
-
活跃线程数(activeCount):正在执行任务的线程数。长时间等于最大线程数,说明线程池压力很大,甚至可能卡死。
-
队列积压数(queueSize):任务队列里等待的任务数。持续增长说明消费速度跟不上生产速度。
-
任务拒绝数:自定义拒绝策略里记录的被拒绝任务数量。只要不是 0 就要关注。
-
任务平均耗时:单个任务的平均执行时间。如果突然变长,可能是外部依赖出问题了(数据库慢查询、下游接口超时等)。
-
已完成任务数(completedTaskCount):总体处理量,可以用来计算吞吐量(TPS)。
这些指标可以通过 ThreadPoolExecutor 的 API 直接获取,然后上报到你的监控系统(Prometheus + Grafana、Micrometer、SkyWalking 等)里。
9.2 典型问题的调优思路
问题:队列积压持续增长,但活跃线程数没满
可能原因:
- 核心任务数设置太小;
- 任务本身有同步等待(比如等锁),实际并发度上不去。
调优方向:
- 适当增加 corePoolSize;
- 检查任务里是否有不必要的同步阻塞;
问题:活跃线程数长时间等于最大线程数,任务大量被拒绝
可能原因:
- 流量突增超过线程池处理能力;
- 下游服务响应慢(数据库、RPC 调用等),导致线程长时间占用不释放。
调优方向:
- 检查下游服务状态,是否有性能问题或超时未配置;
- 临时增加 maximumPoolSize(动态线程池派上用场);
- 考虑是否需要扩容服务实例;
问题:任务平均耗时突然增长
几乎可以断定是下游依赖出了问题,排查顺序:数据库慢查询 → 外部接口超时 → 本地计算逻辑是否有死循环或低效操作。
十、总结:线程池不只是一个工具,是一种思维方式
写到这里,回头看一下,线程池解决的核心问题其实就三件事:
第一,资源复用。线程不是免费的,频繁创建和销毁代价昂贵,池化复用是显而易见的优化。
第二,流量控制。通过核心线程数、最大线程数、队列容量三道"闸门",把系统的并发处理量卡在一个安全范围内,不让外部流量击穿服务。
第三,可观测与可治理。有了线程池,你才能看到系统里的任务排队状态、线程繁忙程度、任务处理速率,也才能做动态调参、异常告警这些事情。
其实不只是线程池,所有"池化"思想的背后,都是对资源和流量的精细化管理。数据库连接池、HTTP 连接池、对象池,解决的问题换个场景来看本质上差不多。
从这个角度看,搞懂线程池,不只是为了应付面试,也不只是为了写出"不被 code review 驳回"的代码。更重要的是培养出一种"凡是涉及资源申请和释放,就要想想能不能池化"的本能反应。
当然,线程池也不是万能药。用错了、配错了,照样出问题——这篇文章里提到的那些坑,大多数都是"线程池用了,但没用好"造成的。
最后说一句大实话:多线程的问题,往往不是代码写得有多复杂,而是对"资源是有限的"这件事缺乏足够的敬畏。代码上线之前,多问自己一句"如果同时来一万个请求,这段代码会发生什么"——你会发现很多隐患在上线之前就能被自己拦截掉。
… …
文末
好啦,以上就是我这期的全部内容,如果有任何疑问,欢迎下方留言哦,咱们下期见。
… …
学习不分先后,知识不分多少;事无巨细,当以虚心求教;三人行,必有我师焉!!!
wished for you successed !!!
⭐️若喜欢我,就请关注我叭。
⭐️若对您有用,就请点赞叭。 ⭐️若有疑问,就请评论留言告诉我叭。
版权声明:本文由作者原创,转载请注明出处,谢谢支持!
网硕互联帮助中心




评论前必须登录!
注册