3个致命坑：cytoplasm图解原理助你避开Java并发雷区
官方文档翻了三遍，java.util.concurrent 包下的 API 描述依然云里雾里？别怪你笨，是 JDK 文档太学术，没给你画张图。想搞懂 cytoplasm（此处借指线程池内部核心机制的复杂生态，虽非标准类名，但常用来比喻线程池中那些看不见的调度逻辑与状态流转），光看文字绝对抓不住重点。
这篇不整虚的，直接上图解原理。咱们把线程池那个黑盒拆开，看看里面的“细胞质”是怎么流动的。很多初学者一上来就 new ThreadPoolExecutor，参数乱填，线上跑着跑着 OOM 或者任务堆积，最后排查半天发现是队列配错了。今天就把这三个最典型的坑，用代码和逻辑图给你讲透。
坑一：无界队列导致的内存爆炸
现象：CPU 飙高，Full GC 频繁，最终 OOM
这是新手最常踩的雷。你在业务代码里写了这么一段：
// 错误写法：典型的“看似合理”配置
ExecutorService executor = Executors.newFixedThreadPool(10);或者手动创建：
// 错误写法：手动创建，但队列无界
ThreadPoolExecutor pool = new ThreadPoolExecutor(10, // corePoolSize10, // maximumPoolSize0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue(), // 致命点：无界队列new ThreadFactory() {private final AtomicInteger counter = new AtomicInteger(0);@Overridepublic Thread newThread(Runnable r) {return new Thread(r, biz-pool- + counter.incrementAndGet());}}
);看起来挺完美：核心线程 10 个，最大线程 10 个，队列用 LinkedBlockingQueue。平时流量小的时候，跑得挺欢。一旦上游流量突增，任务提交速度远超消费速度，会发生什么？
LinkedBlockingQueue 的默认容量是 Integer.MAX_VALUE。这意味着，只要 corePoolSize 的线程没忙完，新任务会全部进入队列排队，而永远不会创建超过 corePoolSize 的线程（除非队列满了，但无界队列永远不“满”）。
结果就是：线程池只有 10 个线程在干活，但队列里可能堆了几十万个任务对象。每个任务对象都占内存，随着时间推移，堆内存被任务对象填满，触发 Full GC，GC 后内存依然降不下来，最后抛出 java.lang.OutOfMemoryError: Java heap space。
根本原因：对线程池扩容机制的误解
很多开发者误以为 maximumPoolSize 是“当核心线程忙不过来时，最多能启用的线程数”。这是错的！
JDK 源码里 ThreadPoolExecutor.execute() 的逻辑是这样的：如果当前线程数 corePoolSize，直接创建新线程。
如果当前线程数 = corePoolSize，尝试将任务加入工作队列。
只有当队列满了，且当前线程数 maximumPoolSize，才会创建新的非核心线程。
如果队列满了，且线程数 = maximumPoolSize，才执行拒绝策略。既然你用了无界队列，第 3 步永远走不到，maximumPoolSize 形同虚设。线程数永远等于 corePoolSize，所有压力都转化为内存压力。
正确写法：有界队列 + 合理的拒绝策略
必须使用有界队列。根据业务场景选择 ArrayBlockingQueue 或 LinkedBlockingQueue 并指定容量。
// 正确写法：有界队列，保护内存
ThreadPoolExecutor pool = new ThreadPoolExecutor(10, // corePoolSize20, // maximumPoolSize：队列满时，最多扩展到20个线程60L, TimeUnit.SECONDS, // 非核心线程空闲60秒后回收new ArrayBlockingQueue(1000), // 关键：有界队列，容量1000new ThreadFactory() {private final AtomicInteger counter = new AtomicInteger(0);@Overridepublic Thread newThread(Runnable r) {Thread t = new Thread(r, biz-pool- + counter.incrementAndGet());t.setUncaughtExceptionHandler((t, e) - {// 日志记录，避免静默失败log.error(Thread {} uncaught exception, t.getName(), e);});return t;}},new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略：由调用者线程执行，起到反压作用
);图解逻辑：任务来 - 线程数 10 - 建新线程。
任务来 - 线程数 = 10 - 入队（容量 1000）。
队列满 - 线程数 20 - 建新线程。
队列满 - 线程数 = 20 - 触发 CallerRunsPolicy，让上游线程自己跑，上游变慢，自然减缓提交速度。坑二：线程复用导致的上下文污染
现象：A 用户的请求返回了 B 用户的数据，日志混乱
这种坑更隐蔽。你用了线程池，没问题。但是，你在任务里用了 ThreadLocal 来传递用户 ID 或 Trace ID。
// 业务代码
public void handleOrder() {// 假设这是从 HTTP 请求入口设置的 ThreadLocalUserContext.setUserId(getCurrentUserId());executor.submit(() - {// 异步任务String userId = UserContext.getUserId();log.info(Processing order for user: {}, userId);// 业务逻辑...});
}你以为是线程隔离，安全无虞。但实际上，线程池里的线程是复用的。
场景复现：用户 A 发起请求，主线程设置 UserContext 为 A，提交任务到线程池。线程池中的 thread-1 取出任务，执行，UserContext 为 A。任务执行完，thread-1 回到池子等待。
注意： thread-1 并没有销毁，ThreadLocal 中的值 A 依然存在！
用户 B 发起请求，主线程设置 UserContext 为 B，提交任务。线程池正好轮到 thread-1 执行这个任务。
如果业务代码中忘记在任务开始时重新设置 UserContext，或者依赖主线程传递的值（但 ThreadLocal 不会自动从主线程复制到子线程），那么 thread-1 里的 UserContext 还是 A。
结果：用户 B 的订单处理逻辑里，读到的用户 ID 是 A。数据错乱，日志张冠李戴。更严重的是，如果 ThreadLocal 存储的是大对象，且没有 remove()，这些对象会一直被 thread-1 持有的 ThreadLocalMap 引用，导致内存泄漏。
根本原因：线程复用与 ThreadLocal 生命周期的错配
ThreadLocal 是绑定在 Thread 对象上的。线程池的核心优势是线程复用，但这恰恰是 ThreadLocal 的噩梦。线程不死，ThreadLocal 里的引用就不释放。
在掘金技术社区的一篇高赞文章《Java 线程池与 ThreadLocal 的那些坑》中，作者指出：“线程池 + ThreadLocal 是内存泄漏的温床，除非你像管理线程一样管理 ThreadLocal 的清理。”
正确写法：显式传递或使用 TransmittableThreadLocal
方案一：显式传递（推荐，简单可靠）
不要依赖隐式的 ThreadLocal 传递。把需要的上下文作为参数传入任务。
// 正确写法：显式传递上下文
public void handleOrder() {final String userId = getCurrentUserId(); // 在主线程获取executor.submit(() - {// 直接使用 userId 参数，不依赖 ThreadLocallog.info(Processing order for user: {}, userId);// 业务逻辑...});
}方案二：使用 Alibaba 的 TransmittableThreadLocal (TTL)
如果必须使用 ThreadLocal 风格，且项目依赖较重，可以使用 TTL。它通过装饰 Runnable 和 Callable，在任务提交时捕获当前线程的 TTL 值，在任务执行前设置到工作线程，执行后恢复。
// 需要引入依赖：com.alibaba:transmittable-thread-local
private static final TransmittableThreadLocalString USER_CONTEXT = new TransmittableThreadLocal();public void handleOrder() {USER_CONTEXT.set(getCurrentUserId());// 使用 TtlExecutors 包装线程池ExecutorService ttlExecutor = TtlExecutors.getTtlExecutorService(executor);ttlExecutor.submit(() - {String userId = USER_CONTEXT.get(); // 这里能正确拿到主线程设置的值log.info(Processing order for user: {}, userId);// 业务逻辑...});
}避坑要点：
无论哪种方案，务必在任务执行的 finally 块中清理 ThreadLocal，防止内存泄漏。
executor.submit(() - {try {// 业务逻辑} finally {UserContext.clear(); // 必须清理！}
});坑三：忽略线程池监控，故障后无法定位
现象：线上报警“线程池拒绝任务”，但不知道是哪个池子，也不知道为什么满
你写了五个线程池：订单池、支付池、日志池、缓存刷新池、报表池。线上突然报警 RejectedExecutionException。
你打开日志，看到 Task ... rejected from java.util.concurrent.ThreadPoolExecutor@1234abcd。
然后呢？1234abcd 是什么鬼？是订单池还是日志池？你连线程名都没打印，或者打印了但日志里混杂着几千行，根本找不到。
更糟糕的是，你完全不知道线程池当前的状态：核心线程数、最大线程数、当前活跃线程数、队列长度、已完成任务数。没有这些指标，你就只能靠猜。
根本原因：缺乏可观测性设计
线程池是一个复杂的并发组件，其内部状态是动态变化的。如果不暴露这些状态，它就是黑盒。
正确写法：暴露关键指标 + 自定义线程名自定义线程名：这是最基本的。给每个线程池的线程起个有意义的名字，包含业务前缀。ThreadFactory namedThreadFactory = new ThreadFactory() {private final AtomicInteger counter = new AtomicInteger(0);@Overridepublic Thread newThread(Runnable r) {Thread t = new Thread(r, order-pool- + counter.incrementAndGet());t.setUncaughtExceptionHandler((t, e) - {log.error(Order pool thread uncaught exception, e);});return t;}
};定期打印状态：写一个定时任务，每隔 30 秒打印一次线程池状态。// 在 Spring 中注册一个 Bean
@Component
public class ThreadPoolMonitor {@Autowiredprivate ThreadPoolExecutor orderPool;@Scheduled(fixedRate = 30000) // 每30秒执行一次public void monitor() {int activeCount = orderPool.getActiveCount();int queueSize = orderPool.getQueue().size();int largestPoolSize = orderPool.getLargestPoolSize();long completedTaskCount = orderPool.getCompletedTaskCount();long taskCount = orderPool.getTaskCount();long rejectedCount = orderPool.getRejectedExecutionHandler() instanceof ThreadPoolExecutor.CallerRunsPolicy ? 0 : 0; // 简化处理，实际需自定义计数器log.info(Order Pool Status: Active={}, QueueSize={}, LargestPool={}, Completed={}, Total={},activeCount, queueSize, largestPoolSize, completedTaskCount, taskCount);// 如果队列使用率超过80%，告警if (queueSize orderPool.getQueue().remainingCapacity() * 0.8) {log.warn(Order Pool queue is nearly full! QueueSize={}, queueSize);}}
}接入 Prometheus/JMX：如果是生产环境，建议通过 JMX 或 Prometheus 暴露 ThreadPoolExecutor 的 MBean，接入监控系统。ThreadPoolExecutor 本身实现了 ExecutorService，可以通过 java.util.concurrent 包的 MBean 暴露。进阶技巧： 自定义 RejectedExecutionHandler，记录被拒绝的任务，方便事后分析。
new RejectedExecutionHandler() {@Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {log.error(Task rejected! Task: {}, QueueSize: {}, ActiveCount: {}, r.toString(), executor.getQueue().size(), executor.getActiveCount());// 可以选择抛出异常，或者降级处理throw new RejectedExecutionException(Task rejected);}
}规避建议与最佳实践总结永远不要使用 Executors.newFixedThreadPool 或 newCachedThreadPool：newFixedThreadPool 使用无界队列，有 OOM 风险。
newCachedThreadPool 使用无界线程数，有线程爆炸风险。
始终手动创建 ThreadPoolExecutor，明确指定每个参数。参数设置原则：corePoolSize：根据业务基线流量设置，通常等于 CPU 核心数 * 2（CPU 密集型）或 CPU 核心数 * 10（IO 密集型）。
maximumPoolSize：根据业务峰值流量设置，通常为核心线程数的 1.5-2 倍。
Queue：必须有界。容量根据“能容忍的最大积压量”设置。
KeepAliveTime：非核心线程的空闲存活时间，建议 60 秒。
RejectedExecutionHandler：根据业务重要性选择。高优先级业务用 CallerRunsPolicy 反压，低优先级业务用 DiscardOldestPolicy 丢弃旧任务。ThreadLocal 清理：在 finally 块中 remove()。
优先使用显式参数传递，避免隐式依赖。
考虑使用 TTL 框架。监控与告警：线程名必须可读。
定期打印或暴露关键指标。
对队列长度、活跃线程数设置阈值告警。单元测试：模拟高并发场景，测试线程池的行为。
测试拒绝策略是否正确触发。
测试 ThreadLocal 是否被正确清理。结尾互动
线程池的坑，往往不在代码逻辑本身，而在于你对并发模型的理解深度。很多人觉得“我会用线程池了”，其实只是会调用 API，没搞懂背后的调度机制和内存模型。
你在项目里踩过这个坑吗？比如，有没有遇到过因为 ThreadLocal 没清理导致的内存泄漏？或者，有没有因为队列配错导致线上 OOM 的经历？评论区聊聊，把你的案例贴出来，大家互相学习，避坑指南永远在路上。 3个致命坑：cytoplasm图解原理助你避开Java并发雷区
3个致命坑：cytoplasm图解原理助你避开Java并发雷区
官方文档翻了三遍，java.util.concurrent 包下的 API 描述依然云里雾里？别怪你笨，是 JDK 文档太学术，没给你画张图。想搞懂 cytoplasm（此处借指线程池内部核心机制的复杂生态，虽非标准类名，但常用来比喻线程池中那些看不见的调度逻辑与状态流转），光看文字绝对抓不住重点。
这篇不整虚的，直接上图解原理。咱们把线程池那个黑盒拆开，看看里面的“细胞质”是怎么流动的。很多初学者一上来就 new ThreadPoolExecutor，参数乱填，线上跑着跑着 OOM 或者任务堆积，最后排查半天发现是队列配错了。今天就把这三个最典型的坑，用代码和逻辑图给你讲透。
坑一：无界队列导致的内存爆炸
现象：CPU 飙高，Full GC 频繁，最终 OOM
这是新手最常踩的雷。你在业务代码里写了这么一段：
// 错误写法：典型的“看似合理”配置
ExecutorService executor = Executors.newFixedThreadPool(10);或者手动创建：
// 错误写法：手动创建，但队列无界
ThreadPoolExecutor pool = new ThreadPoolExecutor(10, // corePoolSize10, // maximumPoolSize0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue(), // 致命点：无界队列new ThreadFactory() {private final AtomicInteger counter = new AtomicInteger(0);@Overridepublic Thread newThread(Runnable r) {return new Thread(r, biz-pool- + counter.incrementAndGet());}}
);看起来挺完美：核心线程 10 个，最大线程 10 个，队列用 LinkedBlockingQueue。平时流量小的时候，跑得挺欢。一旦上游流量突增，任务提交速度远超消费速度，会发生什么？
LinkedBlockingQueue 的默认容量是 Integer.MAX_VALUE。这意味着，只要 corePoolSize 的线程没忙完，新任务会全部进入队列排队，而永远不会创建超过 corePoolSize 的线程（除非队列满了，但无界队列永远不“满”）。
结果就是：线程池只有 10 个线程在干活，但队列里可能堆了几十万个任务对象。每个任务对象都占内存，随着时间推移，堆内存被任务对象填满，触发 Full GC，GC 后内存依然降不下来，最后抛出 java.lang.OutOfMemoryError: Java heap space。
根本原因：对线程池扩容机制的误解
很多开发者误以为 maximumPoolSize 是“当核心线程忙不过来时，最多能启用的线程数”。这是错的！
JDK 源码里 ThreadPoolExecutor.execute() 的逻辑是这样的：如果当前线程数 corePoolSize，直接创建新线程。
如果当前线程数 = corePoolSize，尝试将任务加入工作队列。
只有当队列满了，且当前线程数 maximumPoolSize，才会创建新的非核心线程。
如果队列满了，且线程数 = maximumPoolSize，才执行拒绝策略。既然你用了无界队列，第 3 步永远走不到，maximumPoolSize 形同虚设。线程数永远等于 corePoolSize，所有压力都转化为内存压力。
正确写法：有界队列 + 合理的拒绝策略
必须使用有界队列。根据业务场景选择 ArrayBlockingQueue 或 LinkedBlockingQueue 并指定容量。
// 正确写法：有界队列，保护内存
ThreadPoolExecutor pool = new ThreadPoolExecutor(10, // corePoolSize20, // maximumPoolSize：队列满时，最多扩展到20个线程60L, TimeUnit.SECONDS, // 非核心线程空闲60秒后回收new ArrayBlockingQueue(1000), // 关键：有界队列，容量1000new ThreadFactory() {private final AtomicInteger counter = new AtomicInteger(0);@Overridepublic Thread newThread(Runnable r) {Thread t = new Thread(r, biz-pool- + counter.incrementAndGet());t.setUncaughtExceptionHandler((t, e) - {// 日志记录，避免静默失败log.error(Thread {} uncaught exception, t.getName(), e);});return t;}},new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略：由调用者线程执行，起到反压作用
);图解逻辑：任务来 - 线程数 10 - 建新线程。
任务来 - 线程数 = 10 - 入队（容量 1000）。
队列满 - 线程数 20 - 建新线程。
队列满 - 线程数 = 20 - 触发 CallerRunsPolicy，让上游线程自己跑，上游变慢，自然减缓提交速度。坑二：线程复用导致的上下文污染
现象：A 用户的请求返回了 B 用户的数据，日志混乱
这种坑更隐蔽。你用了线程池，没问题。但是，你在任务里用了 ThreadLocal 来传递用户 ID 或 Trace ID。
// 业务代码
public void handleOrder() {// 假设这是从 HTTP 请求入口设置的 ThreadLocalUserContext.setUserId(getCurrentUserId());executor.submit(() - {// 异步任务String userId = UserContext.getUserId();log.info(Processing order for user: {}, userId);// 业务逻辑...});
}你以为是线程隔离，安全无虞。但实际上，线程池里的线程是复用的。
场景复现：用户 A 发起请求，主线程设置 UserContext 为 A，提交任务到线程池。线程池中的 thread-1 取出任务，执行，UserContext 为 A。任务执行完，thread-1 回到池子等待。
注意： thread-1 并没有销毁，ThreadLocal 中的值 A 依然存在！
用户 B 发起请求，主线程设置 UserContext 为 B，提交任务。线程池正好轮到 thread-1 执行这个任务。
如果业务代码中忘记在任务开始时重新设置 UserContext，或者依赖主线程传递的值（但 ThreadLocal 不会自动从主线程复制到子线程），那么 thread-1 里的 UserContext 还是 A。
结果：用户 B 的订单处理逻辑里，读到的用户 ID 是 A。数据错乱，日志张冠李戴。更严重的是，如果 ThreadLocal 存储的是大对象，且没有 remove()，这些对象会一直被 thread-1 持有的 ThreadLocalMap 引用，导致内存泄漏。
根本原因：线程复用与 ThreadLocal 生命周期的错配
ThreadLocal 是绑定在 Thread 对象上的。线程池的核心优势是线程复用，但这恰恰是 ThreadLocal 的噩梦。线程不死，ThreadLocal 里的引用就不释放。
在掘金技术社区的一篇高赞文章《Java 线程池与 ThreadLocal 的那些坑》中，作者指出：“线程池 + ThreadLocal 是内存泄漏的温床，除非你像管理线程一样管理 ThreadLocal 的清理。”
正确写法：显式传递或使用 TransmittableThreadLocal
方案一：显式传递（推荐，简单可靠）
不要依赖隐式的 ThreadLocal 传递。把需要的上下文作为参数传入任务。
// 正确写法：显式传递上下文
public void handleOrder() {final String userId = getCurrentUserId(); // 在主线程获取executor.submit(() - {// 直接使用 userId 参数，不依赖 ThreadLocallog.info(Processing order for user: {}, userId);// 业务逻辑...});
}方案二：使用 Alibaba 的 TransmittableThreadLocal (TTL)
如果必须使用 ThreadLocal 风格，且项目依赖较重，可以使用 TTL。它通过装饰 Runnable 和 Callable，在任务提交时捕获当前线程的 TTL 值，在任务执行前设置到工作线程，执行后恢复。
// 需要引入依赖：com.alibaba:transmittable-thread-local
private static final TransmittableThreadLocalString USER_CONTEXT = new TransmittableThreadLocal();public void handleOrder() {USER_CONTEXT.set(getCurrentUserId());// 使用 TtlExecutors 包装线程池ExecutorService ttlExecutor = TtlExecutors.getTtlExecutorService(executor);ttlExecutor.submit(() - {String userId = USER_CONTEXT.get(); // 这里能正确拿到主线程设置的值log.info(Processing order for user: {}, userId);// 业务逻辑...});
}避坑要点：
无论哪种方案，务必在任务执行的 finally 块中清理 ThreadLocal，防止内存泄漏。
executor.submit(() - {try {// 业务逻辑} finally {UserContext.clear(); // 必须清理！}
});坑三：忽略线程池监控，故障后无法定位
现象：线上报警“线程池拒绝任务”，但不知道是哪个池子，也不知道为什么满
你写了五个线程池：订单池、支付池、日志池、缓存刷新池、报表池。线上突然报警 RejectedExecutionException。
你打开日志，看到 Task ... rejected from java.util.concurrent.ThreadPoolExecutor@1234abcd。
然后呢？1234abcd 是什么鬼？是订单池还是日志池？你连线程名都没打印，或者打印了但日志里混杂着几千行，根本找不到。
更糟糕的是，你完全不知道线程池当前的状态：核心线程数、最大线程数、当前活跃线程数、队列长度、已完成任务数。没有这些指标，你就只能靠猜。
根本原因：缺乏可观测性设计
线程池是一个复杂的并发组件，其内部状态是动态变化的。如果不暴露这些状态，它就是黑盒。
正确写法：暴露关键指标 + 自定义线程名自定义线程名：这是最基本的。给每个线程池的线程起个有意义的名字，包含业务前缀。ThreadFactory namedThreadFactory = new ThreadFactory() {private final AtomicInteger counter = new AtomicInteger(0);@Overridepublic Thread newThread(Runnable r) {Thread t = new Thread(r, order-pool- + counter.incrementAndGet());t.setUncaughtExceptionHandler((t, e) - {log.error(Order pool thread uncaught exception, e);});return t;}
};定期打印状态：写一个定时任务，每隔 30 秒打印一次线程池状态。// 在 Spring 中注册一个 Bean
@Component
public class ThreadPoolMonitor {@Autowiredprivate ThreadPoolExecutor orderPool;@Scheduled(fixedRate = 30000) // 每30秒执行一次public void monitor() {int activeCount = orderPool.getActiveCount();int queueSize = orderPool.getQueue().size();int largestPoolSize = orderPool.getLargestPoolSize();long completedTaskCount = orderPool.getCompletedTaskCount();long taskCount = orderPool.getTaskCount();long rejectedCount = orderPool.getRejectedExecutionHandler() instanceof ThreadPoolExecutor.CallerRunsPolicy ? 0 : 0; // 简化处理，实际需自定义计数器log.info(Order Pool Status: Active={}, QueueSize={}, LargestPool={}, Completed={}, Total={},activeCount, queueSize, largestPoolSize, completedTaskCount, taskCount);// 如果队列使用率超过80%，告警if (queueSize orderPool.getQueue().remainingCapacity() * 0.8) {log.warn(Order Pool queue is nearly full! QueueSize={}, queueSize);}}
}接入 Prometheus/JMX：如果是生产环境，建议通过 JMX 或 Prometheus 暴露 ThreadPoolExecutor 的 MBean，接入监控系统。ThreadPoolExecutor 本身实现了 ExecutorService，可以通过 java.util.concurrent 包的 MBean 暴露。进阶技巧： 自定义 RejectedExecutionHandler，记录被拒绝的任务，方便事后分析。
new RejectedExecutionHandler() {@Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {log.error(Task rejected! Task: {}, QueueSize: {}, ActiveCount: {}, r.toString(), executor.getQueue().size(), executor.getActiveCount());// 可以选择抛出异常，或者降级处理throw new RejectedExecutionException(Task rejected);}
}规避建议与最佳实践总结永远不要使用 Executors.newFixedThreadPool 或 newCachedThreadPool：newFixedThreadPool 使用无界队列，有 OOM 风险。
newCachedThreadPool 使用无界线程数，有线程爆炸风险。
始终手动创建 ThreadPoolExecutor，明确指定每个参数。参数设置原则：corePoolSize：根据业务基线流量设置，通常等于 CPU 核心数 * 2（CPU 密集型）或 CPU 核心数 * 10（IO 密集型）。
maximumPoolSize：根据业务峰值流量设置，通常为核心线程数的 1.5-2 倍。
Queue：必须有界。容量根据“能容忍的最大积压量”设置。
KeepAliveTime：非核心线程的空闲存活时间，建议 60 秒。
RejectedExecutionHandler：根据业务重要性选择。高优先级业务用 CallerRunsPolicy 反压，低优先级业务用 DiscardOldestPolicy 丢弃旧任务。ThreadLocal 清理：在 finally 块中 remove()。
优先使用显式参数传递，避免隐式依赖。
考虑使用 TTL 框架。监控与告警：线程名必须可读。
定期打印或暴露关键指标。
对队列长度、活跃线程数设置阈值告警。单元测试：模拟高并发场景，测试线程池的行为。
测试拒绝策略是否正确触发。
测试 ThreadLocal 是否被正确清理。结尾互动
线程池的坑，往往不在代码逻辑本身，而在于你对并发模型的理解深度。很多人觉得“我会用线程池了”，其实只是会调用 API，没搞懂背后的调度机制和内存模型。
你在项目里踩过这个坑吗？比如，有没有遇到过因为 ThreadLocal 没清理导致的内存泄漏？或者，有没有因为队列配错导致线上 OOM 的经历？评论区聊聊，把你的案例贴出来，大家互相学习，避坑指南永远在路上。