云计算百科
云计算领域专业知识百科平台

每次来个请求就 new 一个线程,你的服务器真的撑得住吗?

全文目录:

    • 开篇语
    • 前言:从一次差点把服务器搞崩的经历说起
    • 一、先把"线程"这个东西聊清楚
      • 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,它们的核心思想是:

  • 线程池参数注册到配置中心(Nacos、Apollo、Zookeeper 等);
  • 监听配置变化,动态调用 setCorePoolSize()、setMaximumPoolSize() 等方法更新参数;
  • 提供监控面板,实时查看线程池状态。
  • 这个能力在生产环境里非常实用,遇到流量突增时,不用停服就能动态扩充线程数,相当灵活。

    七、那些年踩过的坑,一个个说清楚

    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 状态,把线程池的线程都占满,新的任务就进不来了。

    这叫线程饥饿,症状是:监控上看到活跃线程数等于最大线程数,队列持续积压,但任务完成数几乎不增加。

    解决方案:

  • 给所有外部调用(HTTP、RPC、数据库)设置超时时间,这是基础素养;
  • 对于不得不执行的长耗时任务,使用 Future.get(timeout, unit) 设置最大等待时间;
  • 考虑使用专门处理长任务的独立线程池,和处理短任务的线程池隔离开。
  • 八、其他语言和框架里的"线程池思想"

    线程池不是 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 !!!


    ⭐️若喜欢我,就请关注我叭。

    ⭐️若对您有用,就请点赞叭。 ⭐️若有疑问,就请评论留言告诉我叭。

    版权声明:本文由作者原创,转载请注明出处,谢谢支持!

    赞(0)
    未经允许不得转载:网硕互联帮助中心 » 每次来个请求就 new 一个线程,你的服务器真的撑得住吗?
    分享到: 更多 (0)

    评论 抢沙发

    评论前必须登录!