2021-11-09 18:47:58 +08:00
---
2022-02-07 14:06:01 +08:00
title: Java 线程池最佳实践
2026-01-16 21:04:11 +08:00
description: Java线程池最佳实践总结：
2021-11-09 18:47:58 +08:00
category: Java
tag:
- Java并发
2025-11-17 11:11:54 +08:00
head:
- - meta
- name: keywords
2026-01-16 20:09:23 +08:00
content: 线程池最佳实践,ThreadPoolExecutor配置,Executors陷阱,OOM风险,拒绝策略,线程池监控,线程命名
2021-11-09 18:47:58 +08:00
---
2020-06-11 08:44:51 +08:00
简单总结一下我了解的使用线程池的时候应该注意的东西，网上似乎还没有专门写这方面的文章。
2023-02-07 11:03:15 +08:00
## 1、正确声明线程池
2020-06-11 08:44:51 +08:00
2023-02-07 11:03:15 +08:00
**线程池必须手动通过 `ThreadPoolExecutor` 的构造函数来声明，避免使用`Executors` 类创建线程池，会有 OOM 风险。 **
2020-06-11 08:44:51 +08:00
2023-02-07 11:03:15 +08:00
`Executors` 返回线程池对象的弊端如下(后文会详细介绍到)：
2020-06-11 08:44:51 +08:00
2025-02-22 15:35:59 +08:00
- **`FixedThreadPool` 和 `SingleThreadExecutor` **：使用的是阻塞队列 `LinkedBlockingQueue` ，任务队列的默认长度和最大长度为 `Integer.MAX_VALUE` ，可以看作是无界队列，可能堆积大量的请求，从而导致 OOM。
2024-05-28 11:27:35 +08:00
- **`CachedThreadPool` **：使用的是同步队列 `SynchronousQueue` ，允许创建的线程数量为 `Integer.MAX_VALUE` ，可能会创建大量线程，从而导致 OOM。
- **`ScheduledThreadPool` 和 `SingleThreadScheduledExecutor` ** : 使用的无界的延迟阻塞队列`DelayedWorkQueue` ，任务队列最大长度为 `Integer.MAX_VALUE` ，可能堆积大量的请求，从而导致 OOM。
2020-06-11 08:44:51 +08:00
说白了就是：**使用有界队列，控制线程创建数量。**
2022-07-25 20:46:48 +08:00
除了避免 OOM 的原因之外，不推荐使用 `Executors` 提供的两种快捷的线程池的原因还有：
2020-06-11 08:44:51 +08:00
2023-02-09 20:19:01 +08:00
- 实际使用中需要根据自己机器的性能、业务场景来手动配置线程池的参数比如核心线程数、使用的任务队列、饱和策略等等。
- 我们应该显示地给我们的线程池命名，这样有助于我们定位问题。
2020-06-11 08:44:51 +08:00
2023-02-07 11:03:15 +08:00
## 2、监测线程池运行状态
2020-06-11 08:44:51 +08:00
你可以通过一些手段来检测线程池的运行状态比如 SpringBoot 中的 Actuator 组件。
2022-07-25 20:46:48 +08:00
除此之外，我们还可以利用 `ThreadPoolExecutor` 的相关 API 做一个简陋的监控。从下图可以看出， `ThreadPoolExecutor` 提供了获取线程池当前的线程数和活跃线程数、已经执行完成的任务数、正在排队中的任务数等等。
2020-06-11 08:44:51 +08:00
2023-03-10 11:52:00 +08:00
2020-06-11 08:44:51 +08:00
下面是一个简单的 Demo。`printThreadPoolStatus()` 会每隔一秒打印出线程池的线程数、活跃线程数、完成的任务数、以及队列中的任务数。
``` java
2023-02-07 11:03:15 +08:00
/**
* 打印线程池的状态
*
* @param threadPool 线程池对象
*/
public static void printThreadPoolStatus ( ThreadPoolExecutor threadPool ) {
ScheduledExecutorService scheduledExecutorService = new ScheduledThreadPoolExecutor ( 1 , createThreadFactory ( " print-images/thread-pool-status " , false ) ) ;
scheduledExecutorService . scheduleAtFixedRate ( ( ) - > {
log . info ( " ========================= " ) ;
log . info ( " ThreadPool Size: [{}] " , threadPool . getPoolSize ( ) ) ;
log . info ( " Active Threads: {} " , threadPool . getActiveCount ( ) ) ;
log . info ( " Number of Tasks : {} " , threadPool . getCompletedTaskCount ( ) ) ;
log . info ( " Number of Tasks in Queue: {} " , threadPool . getQueue ( ) . size ( ) ) ;
log . info ( " ========================= " ) ;
} , 0 , 1 , TimeUnit . SECONDS ) ;
}
2020-06-11 08:44:51 +08:00
```
2023-02-07 11:03:15 +08:00
## 3、建议不同类别的业务用不同的线程池
2020-06-11 08:44:51 +08:00
很多人在实际项目中都会有类似这样的问题：**我的项目中多个业务需要用到线程池，是为每个线程池都定义一个还是说定义一个公共的线程池呢？**
一般建议是不同的业务使用不同的线程池，配置线程池的时候根据当前业务的情况对当前线程池进行配置，因为不同的业务的并发以及对资源的使用情况都不同，重心优化系统性能瓶颈相关的业务。
2023-10-30 13:32:52 +08:00
**我们再来看一个真实的事故案例！ ** (本案例来源自：[《线程池运用不当的一次线上事故》 ](https://heapdump.cn/article/646639 ) ，很精彩的一个案例)
2020-06-11 08:44:51 +08:00
2023-03-10 11:52:00 +08:00
2020-06-11 08:44:51 +08:00
上面的代码可能会存在死锁的情况，为什么呢？画个图给大家捋一捋。
2023-02-09 20:19:01 +08:00
试想这样一种极端情况：假如我们线程池的核心线程数为 **n ** ，父任务（扣费任务）数量为 **n ** ，父任务下面有两个子任务（扣费任务下的子任务），其中一个已经执行完成，另外一个被放在了任务队列中。由于父任务把线程池核心线程资源用完，所以子任务因为无法获取到线程资源无法正常执行，一直被阻塞在队列中。父任务等待子任务执行完成，而子任务等待父任务释放线程池资源，这也就造成了 * * "死锁"** 。
2020-06-11 08:44:51 +08:00
2023-03-10 11:52:00 +08:00
2020-06-11 08:44:51 +08:00
解决方法也很简单，就是新增加一个用于执行子任务的线程池专门为其服务。
2023-02-07 11:03:15 +08:00
## 4、别忘记给线程池命名
2020-06-11 08:44:51 +08:00
初始化线程池的时候需要显示命名（设置线程池名称前缀），有利于定位问题。
2023-02-07 11:03:15 +08:00
默认情况下创建的线程名字类似 `pool-1-thread-n` 这样的，没有业务含义，不利于我们定位问题。
2020-06-11 08:44:51 +08:00
给线程池里的线程命名通常有下面两种方式：
2023-02-09 20:19:01 +08:00
**1、利用 guava 的 `ThreadFactoryBuilder` **
2020-06-11 08:44:51 +08:00
``` java
ThreadFactory threadFactory = new ThreadFactoryBuilder ( )
. setNameFormat ( threadNamePrefix + " -%d " )
. setDaemon ( true ) . build ( ) ;
ExecutorService threadPool = new ThreadPoolExecutor ( corePoolSize , maximumPoolSize , keepAliveTime , TimeUnit . MINUTES , workQueue , threadFactory )
```
2023-07-25 23:21:54 +08:00
**2、自己实现 `ThreadFactory`。 **
2020-06-11 08:44:51 +08:00
``` java
import java.util.concurrent.ThreadFactory ;
import java.util.concurrent.atomic.AtomicInteger ;
2024-01-11 23:37:21 +08:00
2020-06-11 08:44:51 +08:00
/**
* 线程工厂，它设置线程名称，有利于我们定位问题。
*/
public final class NamingThreadFactory implements ThreadFactory {
private final AtomicInteger threadNum = new AtomicInteger ( ) ;
private final String name ;
/**
* 创建一个带名字的线程池生产工厂
*/
2024-01-11 23:37:21 +08:00
public NamingThreadFactory ( String name ) {
this . name = name ;
2020-06-11 08:44:51 +08:00
}
2022-07-25 20:46:48 +08:00
@Override
2020-06-11 08:44:51 +08:00
public Thread newThread ( Runnable r ) {
2024-01-11 23:37:21 +08:00
Thread t = new Thread ( r ) ;
2020-06-11 08:44:51 +08:00
t . setName ( name + " [# " + threadNum . incrementAndGet ( ) + " ] " ) ;
return t ;
}
}
```
2023-02-07 11:03:15 +08:00
## 5、正确配置线程池参数
2020-06-11 08:44:51 +08:00
说到如何给线程池配置参数，美团的骚操作至今让我难忘（后面会提到）！
2023-10-08 16:33:50 +08:00
我们先来看一下各种书籍和博客上一般推荐的配置线程池参数的方式，可以作为参考。
2020-06-11 08:44:51 +08:00
2023-02-07 11:03:15 +08:00
### 常规操作
2020-06-11 08:44:51 +08:00
2023-10-08 16:33:50 +08:00
很多人甚至可能都会觉得把线程池配置过大一点比较好！我觉得这明显是有问题的。就拿我们生活中非常常见的一例子来说：**并不是人多就能把事情做好，增加了沟通交流成本。你本来一件事情只需要 3 个人做，你硬是拉来了 6 个人，会提升做事效率嘛？我想并不会。** 线程数量过多的影响也是和我们分配多少人做事情一样，对于多线程这个场景来说主要是增加了**上下文切换** 成本。不清楚什么是上下文切换的话，可以看我下面的介绍。
2020-06-11 08:44:51 +08:00
> 上下文切换：
>
> 多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用， ，
>
> 上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗最大的操作。
>
> Linux 相比与其他操作系统（包括其他类 Unix 系统）有很多的优点，其中有一项就是，其上下文切换和模式切换的时间消耗非常少。
2024-10-11 14:16:26 +08:00
类比于现实世界中的人类通过合作做某件事情，我们可以肯定的一点是线程池大小设置过大或者过小都会有问题，合适的才是最好。
2020-06-11 08:44:51 +08:00
2022-07-25 20:46:48 +08:00
- 如果我们设置的线程池数量太小的话，如果同一时间有大量任务/请求需要处理，可能会导致大量的请求/任务在任务队列中排队等待执行，甚至会出现任务队列满了之后任务/请求无法处理的情况，或者大量任务堆积在任务队列导致 OOM。这样很明显是有问题的，
- 如果我们设置线程数量太大，大量线程可能会同时在争取 CPU 资源，这样会导致大量的上下文切换，从而增加线程的执行时间，影响了整体执行效率。
2020-06-11 08:44:51 +08:00
有一个简单并且适用面比较广的公式：
2024-09-07 17:36:39 +08:00
- **CPU 密集型任务 (N)： （
- **I/O 密集型任务(M \* N)： ， ，
CPU 密集型任务不再推荐 N+1， ：
- "N+1" 的初衷是希望预留线程处理突发暂停，但实际上，处理缺页中断等情况仍然需要占用 CPU 核心。
- CPU 密集场景下，
2020-06-11 08:44:51 +08:00
**如何判断是 CPU 密集任务还是 IO 密集任务？ **
2020-06-11 08:53:00 +08:00
CPU 密集型简单理解就是利用 CPU 计算能力的任务比如你在内存中对大量数据进行排序。但凡涉及到网络读取，文件读取这类都是 IO 密集型，这类任务的特点是 CPU 计算耗费时间相比于等待 IO 操作完成的时间来说很少，大部分时间都花在了等待 IO 操作完成上。
2020-06-11 08:44:51 +08:00
2023-10-08 16:33:50 +08:00
🌈 拓展一下（参见：[issue#1737 ](https://github.com/Snailclimb/JavaGuide/issues/1737 )） ：
线程数更严谨的计算的方法应该是：`最佳线程数 = N（ ） ∗ （ （ ） （ ） ） ，其中 `WT（ ） （ ） 。
线程等待时间所占比例越高，需要越多线程。线程计算时间所占比例越高，需要越少线程。
我们可以通过 JDK 自带的工具 VisualVM 来查看 `WT/ST` 比例。
CPU 密集型任务的 `WT/ST` 接近或者等于 0， ， （ ） ∗ （ ） ， （
IO 密集型任务下，几乎全是线程等待时间，从理论上来说，你就可以将线程数设置为 2N（ ，
2022-07-25 20:46:48 +08:00
2023-10-08 16:33:50 +08:00
**注意 ** ：上面提到的公示也只是参考，实际项目不太可能直接按照公式来设置线程池参数，毕竟不同的业务场景对应的需求不同，具体还是要根据项目实际线上运行情况来动态调整。接下来介绍的美团的线程池参数动态配置这种方案就非常不错，很实用！
2022-07-25 20:46:48 +08:00
2023-02-07 11:03:15 +08:00
### 美团的骚操作
2020-06-11 08:44:51 +08:00
2022-07-25 20:46:48 +08:00
美团技术团队在[《Java 线程池实现原理及其在美团业务中的实践》 ](https://tech.meituan.com/2020/04/02/java-pooling-pratice-in-meituan.html )这篇文章中介绍到对线程池参数实现可自定义配置的思路和方法。
2020-06-11 08:44:51 +08:00
美团技术团队的思路是主要对线程池的核心参数实现自定义可配置。这三个核心参数是：
2024-09-13 15:57:38 +08:00
- **`corePoolSize` :** 核心线程数定义了最小可以同时运行的线程数量。
2020-06-11 08:44:51 +08:00
- **`maximumPoolSize` :** 当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。
2021-09-28 19:25:29 +08:00
- **`workQueue` :** 当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，新任务就会被存放在队列中。
2020-06-11 08:44:51 +08:00
**为什么是这三个参数？ **
2022-07-25 20:46:48 +08:00
我在这篇[《新手也能看懂的线程池学习总结》 ](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247485808&idx=1&sn=1013253533d73450cef673aee13267ab&chksm=cea246bbf9d5cfad1c21316340a0ef1609a7457fea4113a1f8d69e8c91e7d9cd6285f5ee1490&token=510053261&lang=zh_CN&scene=21#wechat_redirect ) 中就说过这三个参数是 `ThreadPoolExecutor` 最重要的参数，它们基本决定了线程池对于任务的处理策略。
2020-06-11 08:44:51 +08:00
**如何支持参数动态配置？ ** 且看 `ThreadPoolExecutor` 提供的下面这些方法。
2023-03-10 11:52:00 +08:00
2020-06-11 08:44:51 +08:00
2022-07-25 20:46:48 +08:00
格外需要注意的是`corePoolSize` ， `setCorePoolSize（ ） 这个方法的话，线程池会首先判断当前工作线程数是否大于`corePoolSize` ，如果大于的话就会回收工作线程。
2020-06-11 08:44:51 +08:00
2022-07-25 20:46:48 +08:00
另外，你也看到了上面并没有动态指定队列长度的方法，美团的方式是自定义了一个叫做 `ResizableCapacityLinkedBlockIngQueue` 的队列（主要就是把`LinkedBlockingQueue` 的 capacity 字段的 final 关键字修饰给去掉了，让它变为可变的）。
2020-06-11 08:44:51 +08:00
最终实现的可动态修改线程池参数效果如下。👏👏👏
2023-03-10 11:52:00 +08:00
2020-06-11 08:44:51 +08:00
2023-02-07 11:03:15 +08:00
如果我们的项目也想要实现这种效果的话，可以借助现成的开源项目：
2023-06-02 10:43:17 +08:00
- **[Hippo4j ](https://github.com/opengoofy/hippo4j )**：异步线程池框架，支持线程池动态变更&监控&报警，无需修改代码轻松引入。支持多种使用模式，轻松引入，致力于提高系统运行保障能力。
2023-05-05 12:39:01 +08:00
- **[Dynamic TP ](https://github.com/dromara/dynamic-tp )**：轻量级动态线程池，内置监控告警功能，集成三方中间件线程池管理，基于主流配置中心（已支持 Nacos、Apollo， ，
2023-02-09 20:19:01 +08:00
2023-04-26 17:38:43 +08:00
## 6、别忘记关闭线程池
当线程池不再需要使用时，应该显式地关闭线程池，释放线程资源。
线程池提供了两个关闭方法：
- **`shutdown（ ） ** :关闭线程池，线程池的状态变为 `SHUTDOWN` 。线程池不再接受新任务了，但是队列里的任务得执行完毕。
2023-06-10 13:22:08 +08:00
- **`shutdownNow（ ） ** :关闭线程池，线程池的状态变为 `STOP` 。线程池会终止当前正在运行的任务，停止处理排队的任务并返回正在等待执行的 List。
2023-04-26 17:38:43 +08:00
调用完 `shutdownNow` 和 `shuwdown` 方法后，并不代表线程池已经完成关闭操作，它只是异步的通知线程池进行关闭处理。如果要同步等待线程池彻底关闭后才继续往下执行，需要调用`awaitTermination` 方法进行同步等待。
在调用 `awaitTermination()` 方法时，应该设置合理的超时时间，以避免程序长时间阻塞而导致性能问题。另外。由于线程池中的任务可能会被取消或抛出异常，因此在使用 `awaitTermination()` 方法时还需要进行异常处理。`awaitTermination()` 方法会抛出 `InterruptedException` 异常，需要捕获并处理该异常，以避免程序崩溃或者无法正常退出。
``` java
// ...
// 关闭线程池
executor . shutdown ( ) ;
try {
// 等待线程池关闭，
if ( ! executor . awaitTermination ( 5 , TimeUnit . MINUTES ) ) {
// 如果等待超时，则打印日志
System . err . println ( " 线程池未能在5分钟内完全关闭 " ) ;
}
} catch ( InterruptedException e ) {
// 异常处理
}
```
## 7、线程池尽量不要放耗时任务
线程池本身的目的是为了提高任务执行效率，避免因频繁创建和销毁线程而带来的性能开销。如果将耗时任务提交到线程池中执行，可能会导致线程池中的线程被长时间占用，无法及时响应其他任务，甚至会导致线程池崩溃或者程序假死。
2024-05-28 11:50:01 +08:00
因此，在使用线程池时，我们应该尽量避免将耗时任务提交到线程池中执行。对于一些比较耗时的操作，如网络请求、文件读写等，可以采用 `CompletableFuture` 等其他异步操作的方式来处理，以避免阻塞线程池中的线程。
2023-04-26 17:38:43 +08:00
## 8、线程池使用的一些小坑
2023-02-09 20:19:01 +08:00
### 重复创建线程池的坑
线程池是可以复用的，一定不要频繁创建线程池比如一个用户请求到了就单独创建一个线程池。
``` java
@GetMapping ( " wrong " )
public String wrong ( ) throws InterruptedException {
// 自定义线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor ( 5 , 10 , 1L , TimeUnit . SECONDS , new ArrayBlockingQueue < > ( 100 ) , new ThreadPoolExecutor . CallerRunsPolicy ( ) ) ;
// 处理任务
executor . execute ( ( ) - > {
// ......
}
return " OK " ;
}
```
出现这种问题的原因还是对于线程池认识不够，需要加强线程池的基础知识。
### Spring 内部线程池的坑
使用 Spring 内部线程池时，一定要手动自定义线程池，配置合理的参数，不然会出现生产问题（一个请求创建一个线程）。
``` java
@Configuration
@EnableAsync
public class ThreadPoolExecutorConfig {
@Bean ( name = " threadPoolExecutor " )
public Executor threadPoolExecutor ( ) {
ThreadPoolTaskExecutor threadPoolExecutor = new ThreadPoolTaskExecutor ( ) ;
int processNum = Runtime . getRuntime ( ) . availableProcessors ( ) ; // 返回可用处理器的Java虚拟机的数量
int corePoolSize = ( int ) ( processNum / ( 1 - 0 . 2 ) ) ;
int maxPoolSize = ( int ) ( processNum / ( 1 - 0 . 5 ) ) ;
threadPoolExecutor . setCorePoolSize ( corePoolSize ) ; // 核心池大小
threadPoolExecutor . setMaxPoolSize ( maxPoolSize ) ; // 最大线程数
2025-07-02 00:17:00 +08:00
threadPoolExecutor . setQueueCapacity ( maxPoolSize * 1000 ) ; // 队列长度
2023-02-09 20:19:01 +08:00
threadPoolExecutor . setThreadPriority ( Thread . MAX_PRIORITY ) ;
threadPoolExecutor . setDaemon ( false ) ;
threadPoolExecutor . setKeepAliveSeconds ( 300 ) ; // 线程空闲时间
threadPoolExecutor . setThreadNamePrefix ( " test-Executor- " ) ; // 线程名字前缀
return threadPoolExecutor ;
}
}
```
### 线程池和 ThreadLocal 共用的坑
线程池和 `ThreadLocal` 共用，可能会导致线程从`ThreadLocal` 获取到的是旧值/脏数据。这是因为线程池会复用线程对象，与线程对象绑定的类的静态属性 `ThreadLocal` 变量也会被重用，这就导致一个线程可能获取到其他线程的`ThreadLocal` 值。
不要以为代码中没有显示使用线程池就不存在线程池了，像常用的 Web 服务器 Tomcat 处理任务为了提高并发量，就使用到了线程池，并且使用的是基于原生 Java 线程池改进完善得到的自定义线程池。
当然了，你可以将 Tomcat 设置为单线程处理任务。不过，这并不合适，会严重影响其处理任务的速度。
``` properties
server.tomcat.max-threads = 1
```
解决上述问题比较建议的办法是使用阿里巴巴开源的 `TransmittableThreadLocal` (`TTL` )。`TransmittableThreadLocal` 类继承并加强了 JDK 内置的`InheritableThreadLocal` 类，在使用线程池等会池化复用线程的执行组件情况下，提供`ThreadLocal` 值的传递功能，解决异步执行时上下文传递的问题。
2023-12-30 17:14:13 +08:00
`TransmittableThreadLocal` 项目地址：<https://github.com/alibaba/transmittable-thread-local> 。
2023-08-07 18:56:33 +08:00
2023-10-27 06:44:02 +08:00
<!-- @include: @article -footer.snippet.md -->
