目录
干货分享,感谢您的阅读!
把一段代码交给线程池,方法立刻返回,没有异常,日志干净。这一刻你以为自己完成了一次调用,实际上你只是完成了一次投递。会不会被执行、什么时候被执行、执行时还能不能看见调用者的身份、失败之后有没有人知道——这四件事,execute 的返回值一件都没有承诺。
线程池不是一台让代码变快的加速器,它是一个把提交与执行分开的准入与排队系统;而"分开"这个动作,同时切断了四条在同步调用里自动成立的因果链:提交时刻与执行时刻的对应、异常沿调用栈回传的通路、线程本地存储的可见性、以及下游变慢时压力向上传导的能力。
行业里被反复讨论的线程数怎么配、队列怎么选、拒绝策略怎么定、任务为什么堆积、上下文为什么丢失,全部是这四条断链的派生问题。
本文按这条线索把它们重新组织:先算清七个数确定处置顺序,再逐一给出线程数的推导方法、队列容量的反推公式、拒绝策略的选择判据、堆积的四种形状与六类根因、上下文传递的捕获—回放—还原三段模型,最后收敛成十二条可以被静态检查直接判定的门禁规则。
一、提交成功到底承诺了什么?
(一)execute 返回之后,四件事都没有被保证
几乎每一次关于线程池的讨论,都是从"核心线程数配多少"开始的。这个起点看似务实,实则已经跳过了最关键的一步:在讨论参数之前,我们应该先搞清楚,把一个任务交给线程池,究竟意味着什么。
同步调用的语义非常干净:方法返回,意味着这段逻辑执行完了,结果可用,异常会沿着调用栈自己找上门来。这份干净是免费的,以至于我们从来不会专门去想它。而当同一段逻辑被 execute 出去之后,返回的含义就彻底变了——它只表示"任务对象的引用被池接收了",除此之外的一切都还没有发生。
具体来说,下面这四件事,一件都没有被保证。
1、没有保证这个任务会被执行
任务可以在四种情况下从此消失。队列已满且线程已达上限时,它会被拒绝策略处置,而某些策略的处置方式就是静默丢弃;进程重启时,内存队列里排着的全部任务一起消失,数量无人知晓;调用 shutdownNow 时,未开始的任务会被从队列里倒出来作为返回值,而这个返回值在多数代码里被直接忽略;最后,如果拒绝策略被配成了丢弃,那么丢弃这件事本身默认不产生任何日志、任何指标、任何痕迹。
这四种消失方式的共同点是:提交方完全无从感知。它拿到的是一个 void,连一个可以检查的返回值都没有。
2、没有保证这个任务什么时候被执行
任务进入队列之后,它的开始时间由排在它前面的任务数量决定,而不是由它自己的性质决定。一个耗时五毫秒的任务,如果前面排着一万个同样耗时五毫秒的任务、而池的并行度是十,那么它要等五秒才能开始。
这意味着端到端时延里出现了一段在同步调用中不存在的成分:排队时延。它不由任务代码决定,不由下游服务决定,只由容量与到达率的关系决定。绝大多数团队没有单独测量这一段,于是它被整体计入了"系统变慢了",归因方向从一开始就偏了。
3、没有保证执行时的环境与提交时相同
执行这个任务的是另一个线程。这个线程有自己的线程本地存储,那里面没有提交方的链路标识、没有登录用户、没有租户信息、没有日志诊断上下文。更麻烦的是,它未必是空的——线程池会复用线程,上一个任务留下的值可能还躺在那里。
于是有两种截然不同的缺陷形态:上下文丢失,表现为链路断裂、日志缺字段,运维一眼能看出来;上下文串号,表现为这次操作被记在了别人名下,数据完全"正确"地写入了错误的归属,可能几个月都没有人发现。
4、没有保证失败会被人看见
任务抛出异常时,调用栈的栈底是工作线程的运行循环,而不是提交方的方法。异常无处可去。它的最终归宿取决于你用的是哪个提交方法:execute 会让它冒到未捕获异常处理器(如果你设置过),submit 则会把它悄悄封进 Future 的内部状态里,只有调用 get 的人才能看见。
而在大量真实代码里,submit 之后返回的 Future 被直接丢弃了。这意味着任务可以连续失败几个月,错误率曲线上什么都不会出现。

(二)一个队列切断的四条因果链
上面四件事看起来是四个独立问题,实际上它们有同一个来源:提交与执行之间被插进了一个队列。这个队列带来的不只是"延迟",它同时切断了四条在同步调用里自动成立的因果链。这四条链构成了本文的统一视角,后面所有章节都是它们的展开。
1、时间因果:提交时刻不再等于执行时刻
同步调用里,"现在提交"就是"现在执行",两者是同一个时刻。有了队列之后,它们之间插进了一段长度不定的等待,而这段等待的长度不由任务本身决定,由它前面还排着多少任务决定。
这条链断开之后派生出的工程问题是:队列该选什么类型、容量该定多少、堆积了怎么办。这些问题在同步调用中根本不存在。
2、调用栈因果:抛出的异常没有上游可去
同步调用里,异常沿栈向上传播,总会遇到一个能处理它的调用者,最不济也会到达线程的顶层并被打印出来。跨线程之后,工作线程的栈底就是池的循环代码,异常在那里终止,不会回到提交方。
这条链断开之后派生出的问题是:异常怎么收口、结果怎么获取、失败怎么被观测到。
3、上下文因果:线程本地存储不会跟着任务走
同步调用里,链路标识、登录态、日志上下文都在同一个线程上,天然可见,我们甚至意识不到自己在依赖这一点。跨线程之后,执行它的是另一个线程,槽位是空的,而且可能残留着上一个任务的值。
这条链断开之后派生出的问题是:上下文怎么传递、传过去之后怎么清理、清理不干净会怎样。
4、背压因果:提交方感受不到执行方的慢
同步调用里,下游变慢,调用方就一起变慢,压力自动向上传导,最终传导到最外层的流量入口,形成一个天然的自适应闭环。有了队列之后,执行方再慢,提交方也照样以原速率提交——压力被队列吸收进了内存,直到撞上某个硬边界。
这条链断开之后派生出的问题是:线程数怎么标定、队列满了怎么办、过载信号怎么回传给上游。
把这四条链放在一起看,会发现一件事:线程池的每一个参数,本质上都是在为其中某一条断链打补丁。队列容量是给时间因果打的补丁,拒绝策略是给背压因果打的补丁,任务包装器是给调用栈因果和上下文因果打的补丁。参数配得对不对,取决于补丁有没有打在对应的那条链上。

(三)为什么"线程池调优"这个说法把问题带偏了
"调优"这个词暗含一个前提:存在一组更好的参数,找到它,问题就解决了。这个前提在多数场景下是错的,它把一个结构性问题描述成了一个数值问题。
一个具体的例子。某个服务的异步池频繁堆积,团队的处置过程是这样的:先把核心线程从 10 调到 20,好了两天;再调到 40,好了一周;再调到 80,开始出现下游超时;把队列从一千调到一万,超时消失了但时延变成了分钟级;最后把最大线程调到 200,某天晚上进程内存溢出。整个过程持续了两个月,每一步都是"调优",每一步都短暂有效,而根本问题——一个批量导出任务和在线查询共用了同一个池——从头到尾没有被识别出来。
这不是一个能力问题,而是提问方式的问题。"参数配多少"这个问法预设了答案在参数空间里,于是搜索永远在参数空间里进行。正确的问法应该是四个:这个池装的是什么任务、它的容量由谁封顶、它满了之后压力去哪、它出问题时我能看见什么。这四个问题里,只有第一个的答案落在参数空间里。
本文接下来的所有内容,都是在回答这四个问题,而不是在寻找一组更好的数字。
(四)真正要覆盖的八件事
把上面的分析展开,一次严肃的线程池治理实际要覆盖八项能力。它们相互独立,缺任何一项都会在某个特定场景下暴露。
第一是执行语义:说得出核心线程、队列、最大线程、拒绝这条判定链的先后顺序,并知道顺序不可调换。第二是容量标定:能从服务时间、目标吞吐与下游容量推出线程数,而不是套一个经验公式。第三是排队设计:把队列当成延迟的储存罐来算容量,而不是当成越大越安全的缓冲区。第四是拒绝设计:把拒绝当成正常路径来设计,并明确压力被推给了谁。第五是背压传导:能说清一次过载沿链路怎么向上回传、在哪一层被吸收、在哪一层被挡住。第六是上下文治理:能列出必须跨线程搬运的上下文清单,并处理好归还与清理。第七是失败收口:任务异常、超时、取消三条路径各有明确归宿与告警。第八是可观测与门禁:关键指标上报齐全,危险写法能被静态规则挡住。
技术评审与代码走查里,真正拉开差距的地方几乎全部落在第五、第六、第七这三项上。能背出七个构造参数的人很多;能说出"队列满时压力回传到了哪一层、此刻谁在等"的人少得多;能说出"线程复用后上下文残留会造成什么后果"并给出防御测试的人更少。
一句可以直接用的自评:随手指一个线上的线程池,能不能在三十秒内说出它的线程数依据、队列满时的行为、以及一次任务静默失败会在哪个指标上露头。说不出来不代表它现在有问题,代表它现在是靠运气正确的。

(五)动手之前先算出来的七个数
在改任何一个参数之前,有七个数值得先花一两天统计出来。它们决定的不是"要不要治",而是"先治哪一个、按什么顺序、治到什么算完"。
1、进程里的线程池个数
扫描所有显式构造的执行器、定时调度器、异步注解使用的执行器,再加上框架与中间件自带的池。多数存量系统的实际值是团队估计值的三倍左右——因为没有人记得中间件客户端内部也有池。
这个数是治理面积的分母。它超过十五个之后,靠人工维护各池参数已经不现实,必须转向统一工厂与统一模板。
2、线程总数与常驻线程数
把全部池的核心线程数相加,再加上容器工作线程、定时任务线程与中间件线程,与机器规格对照。常见结果是核数的几十倍。
这个数决定上下文切换与栈内存的固定开销。它本身不直接造成故障,但它决定了后面每一次"加线程"的边际成本有多高。
3、无界队列的池个数
统计工作队列为不带容量的链式队列的池,以及用工厂方法创建的固定大小池与单线程池——后两者内部用的就是无界队列。
这是七个数里唯一必须立刻处置的。它把一个本可以在几秒内暴露为拒绝计数的容量问题,推迟成了几十分钟后暴露的内存溢出。
4、排队时延的分位数
在任务上打两个时间戳,入队一次、开始执行一次,差值上报。多数团队没有这个指标,于是把排队时间整体算进了"下游变慢"。
这个数决定端到端时延该向谁归因。它是本文认为最值得优先补上的一个指标,没有之一。
5、拒绝次数与丢弃次数
在拒绝策略里埋计数,并区分"显式拒绝"与"静默丢弃"两类。要注意:丢弃计数长期为零通常不代表没丢,更可能是根本没埋。
这个数回答一个很直接的问题:现在有没有任务正在无声消失。
6、跨线程上下文的种类数
清点全部线程本地存储及其派生用法,标出哪些会被异步任务读取。别忘了框架内部持有的那些:日志诊断上下文、安全上下文、事务与数据源路由。
这个数决定一次上下文治理要包装多少个提交入口,也决定了改造是"包一层执行器"还是"改几十处调用点"。
7、任务异常的可见率
统计 submit 之后从未调用 get 的位置数,以及没有设置未捕获异常处理器的池数。两者之和就是"失败不可见"的面积。这个数通常大得让人意外。
七个数拿到之后,处置顺序基本自动确定:第三个数大于零就先止血,把无界队列改成有界;第五个数没有埋点就先补埋点,否则改完看不出效果;第二个数远大于核数就先合池,而不是继续调单个池的参数;第七个数偏高就先收口异常,因为它决定了其余全部工作是否可被验证。

二、执行语义:七个参数背后只有一条判定链
(一)一次提交要过的四道关口
线程池的构造函数有七个参数,看起来是七个可以独立调节的旋钮。实际上它们不是并列关系,而是被一条固定的判定链串起来的:一次提交依次经过四道关口,前一道不放行才会走到下一道。
第一道关口:当前线程数是否小于核心线程数。是,则新建一个核心线程直接执行这个任务,流程结束。这里有一个容易被忽略的细节——即使此刻已经有空闲线程,只要线程数还没到核心数,池仍然会新建线程。这是一个刻意的设计,目的是让池尽快达到核心规模。
第二道关口:队列是否还塞得下。是,则任务进入队列等待,流程结束。这是绝大多数任务实际走的那条路。
第三道关口:当前线程数是否小于最大线程数。是,则新建一个非核心线程来执行这个任务。注意这道关口的前提是第二道关口没有放行,也就是队列已经满了。
第四道关口:以上都不成立,交给拒绝策略处理。
这条链的关键不在于每一步做什么,而在于它们的顺序:先加核心线程,再排队,队列满了才加线程,加不动才拒绝。把这个顺序想反——尤其是把"排队"和"加线程到最大值"这两步的先后想反——会直接造出三种典型的错误配置。
第一种是"压力大了会自动扩容到最大线程"。基于这个理解,团队配出核心 5、最大 200、队列无界的组合,以为平时省资源、忙时能顶住。实际上队列永远塞得下,第三道关口永远走不到,这个池永远只有 5 个线程在跑,最大线程数是纯粹的摆设。
第二种是"队列越大越不容易拒绝"。基于这个理解,队列被设成十万。确实不拒绝了,但代价是排队十分钟——而上游的超时是三秒,所以这十万个任务里绝大多数跑完时早已无人关心。
第三种是"核心线程数只是个初始值,靠最大值兜底"。基于这个理解,核心配成 1。结果常态并行度就是 1,而扩容要等队列先被填满,在此之前系统的表现已经劣化到不可接受。

(二)判定顺序带来的三个反直觉后果
上面三个错误配置背后,是三条值得单独写出来的后果。它们决定了参数应该怎么配才会真正生效。
1、最大线程数常常是一个死参数
只有队列先被填满,池才会去创建第 核心数 + 1 个线程。如果队列容量很大,那么在它被填满之前,排队时延早已超出可接受范围——于是最大线程数从来没有机会被用上。
由此得到一条与直觉相反的配法:想让扩容更早发生,应该把队列改小,而不是把最大线程数改大。队列容量在这里扮演的是"扩容触发阈值"的角色,而不是"缓冲区大小"的角色。这是理解线程池参数的一个关键转折点。
2、无界队列让两个参数同时失效
队列永远塞得下,第二道关口永远返回是,于是第三、第四道关口永远不会被走到。最大线程数失效,拒绝策略也失效。
此时这个池在行为上等价于:一个固定大小为核心线程数的池,加上一个没有上限的内存黑洞。你配的七个参数里,有两个是装饰品。
3、核心线程数才是常态并发度
日常流量下,池的实际并行度等于核心线程数,与最大线程数无关。"核心设小、最大设大"这种看起来很有弹性的配法,在有队列的前提下并不成立——它只是把弹性推迟到了最坏的时刻才发生。
因此,核心线程数应该按稳态负载来配,最大线程数用于应对短时尖峰,且两者差距不宜过大。差距越大,说明你越依赖那个几乎不会被触发的扩容路径。
这三条合起来给出一个很有用的检查方法:如果你无法说出"这个池的队列被填满需要多久",那么它的最大线程数与拒绝策略都还没有真正投入使用。 因为在队列填满之前,这两个参数在整条判定链上一次都不会被读到。

(三)核心线程、最大线程与存活时间怎么配
三个参数共同决定池的伸缩形态,各自的语义如下。
核心线程数是常驻线程数,也是日常流量下的实际并行度。默认情况下这些线程创建之后不回收,即使长期空闲。如果开启了允许核心线程超时的开关,它们也会被回收,这适用于低频后台任务——省下的是常驻的栈内存。
最大线程数是线程数上限,只在队列已满时才起作用。超出核心数的那部分是可回收的临时线程。它与核心数的差值就是这个池的弹性空间。
存活时间决定临时线程空闲多久之后被回收。取值太短,会在尖峰期反复创建和销毁线程,白白付出创建成本;取值太长,则会让临时线程在低峰期继续占着栈内存。合理的参考量级是尖峰的持续时间:如果尖峰通常持续一分钟,那么存活时间设成几十秒是合理的。
除了这三个,还有三个参数值得单独强调,因为它们常常被"默认值就行"带过。
线程工厂必须设置。 给线程起一个带业务含义的名字前缀,这是排查时最便宜的信息来源——一个没有名字的线程栈几乎无法归因到某个具体的池。顺带可以在这里设置未捕获异常处理器和守护线程标记。
拒绝策略必须设置。 默认策略是直接抛异常,它会把一次容量问题伪装成一次代码错误,上游多半会把它当成系统故障来告警。
队列必须指定容量。 不带容量的构造是这七个参数里最危险的一处默认,原因上一节已经说过。
四种常见配法的实际形态可以这样对照:核心与最大相等、配有界队列,是最推荐的默认形态,线程数恒定、压力由队列吸收、容量可算;小核心大最大配小队列,尖峰时能快速扩线程、空闲后回收,适合流量突发明显且下游能承压的场景;小核心大最大配大队列,则会退化成固定小池,弹性从不发生,这是一种误配;核心与最大相等并开启核心线程超时,适合低频后台任务。

(四)线程池的五个状态:关闭是一个过程
线程池有五个生命周期状态:运行中、关闭中、停止中、整理中、已终止。理解它们的价值不在于背下名字,而在于认识到一件事——关闭是一个过程,不是一个瞬间。优雅关闭出问题,多半是把某一次状态迁移当成了原子动作。
运行中状态接受新任务,也处理队列里的任务。调用 shutdown 之后进入关闭中:不再接受新任务,但会把队列里已有的任务全部排干。调用 shutdownNow 则进入停止中:不接受新任务,丢弃队列内容并向正在执行的线程发出中断。任务全部结束、工作线程归零后进入整理中,随后回调终止钩子,最终进入已终止。
三个关闭相关的方法分工明确,但它们各自"不做什么"更值得记住。
shutdown 拒绝新任务并排干队列,但它不中断正在执行的任务,也不等待——它会立刻返回。所以调用它之后必须紧接着 awaitTermination,给一个明确的期限。
shutdownNow 清空队列并向工作线程发中断,但它不保证任务真的停下来(下一章会详细讲中断的边界)。它会把未执行的任务作为返回值交出来,这个返回值必须被接住并落档,否则这些任务就是凭空消失的。
awaitTermination 只是等待,它自身不触发关闭。单独调用它不会有任何效果,这是一个常见误用。
isShutdown 返回是否已发起关闭,但它不代表任务已经跑完。判断是否真正跑完要用 isTerminated。
由此可以给出一套可以照抄的关闭序列:第一步停止上游投递,先摘流量再关池;第二步调用 shutdown 并给一个与业务时长匹配的期限;第三步超时未终止则调用 shutdownNow,并把返回的剩余任务落档;第四步再等一个短期限,仍未终止则告警,而不是静默退出。

(五)execute 与 submit:异常的两条不同去向
这是线程池里最容易造成静默失败的一处分岔,而它的表面差异只有一个方法名。
走 execute 提交时,任务抛出的异常会向上冒出工作线程的运行循环。afterExecute 钩子能拿到这个异常;随后线程终止,池会补建一个新线程;异常最终交给未捕获异常处理器(如果线程工厂里设置过),否则打印到标准错误。
走 submit 提交时,任务会先被包装成一个 FutureTask。任务抛出的异常被这个包装类捕获并存为结果状态。此时有三个后果:afterExecute 收到的异常参数是 null(很多人在这里踩坑,覆写了钩子却什么都没抓到);工作线程没有终止,它会继续取下一个任务;异常只有在有人调用 get 时才会以执行异常的形式抛出来。
于是产生了一条在生产环境真实存在的失败路径:用 submit 提交了一批任务,没有人保存返回的 Future,任务全部抛异常,没有任何日志、没有任何指标变化,三个月后业务方问"为什么那批数据一直没生成"。
这不是一个假想案例。它是"提交成功不等于开始执行"这句话最贵的一种兑现方式。
四种写法的收口动作可以这样归纳:用 execute 时,必须在线程工厂里设置未捕获异常处理器并接入告警;用 submit 并会调用 get 时,get 必须带超时,且要区分超时与执行失败两种情况;用 submit 但不取结果时,正确做法是改用 execute,如果因为历史原因不能改,则必须覆写 afterExecute 并从 Future 里把异常挖出来;用组合式异步链时,链尾必须有终端异常处理,否则异常会在链的末端消失。
更彻底的做法是不依赖每一处调用点自觉,而是把异常收口做进统一的任务包装器——这一点会在第八章展开。

三、线程数标定:把一个抄来的数变成一个可辩护的数
(一)先分清三类任务,再谈数字
"核数乘二"是流传最广的一条经验,也是错得最稳定的一条。它错的不是数值,而是它给了一个不区分场景的答案,让人误以为这个问题已经有答案了。
在给出任何数字之前,必须先把任务分成三类,因为这三类任务的合理线程数在同一台机器上可以相差两个数量级。
计算密集型:典型的有序列化、压缩、加解密、图像处理、大批量内存计算。这类任务的线程几乎不让出 CPU,增加线程不会增加吞吐,只会增加上下文切换与缓存抖动。参考区间是核数到核数加一。判断依据很直接:对该池的线程做状态采样,可运行状态的占比长期高于九成。
阻塞等待型:典型的有远程调用、数据库访问、文件读写、锁等待、消息投递。这类任务的线程大部分时间在等待,增加线程确实能提高吞吐,直到撞上下游或连接池的上限。参考区间是核数乘以「一加等待计算比」。判断依据是线程状态采样中等待与限时等待占主导。
混合型:一次请求里既查库又做复杂的内存聚合与序列化。公式给出的值对这类任务往往偏大,因为等待与计算的比例会随流量变化而不是保持常数。更好的做法是把它拆成两个池分别标定。判断依据是等待计算比在不同时段的差异超过一倍。
回到"核数乘二",它在生产上失效有四个具体原因,值得逐条说清楚。
第一,它没有区分任务性质,同一个数字既给了计算密集型也给了阻塞型,前者浪费、后者远远不够。第二,它假设整机独占,而容器里的可用核数与宿主机核数不是一回事,读错分母则全盘皆错——这是容器化之后新增的一类系统性偏差。第三,它忽略了进程里的其他池,一个进程有十几个池,每个都按核数乘二,总线程数会达到核数的几十倍。第四,它没有下游约束项,线程数超过下游能承接的并发时,多出来的线程只是把排队搬到了对端。
经验公式的正确用法是给一个起点,而不是给一个答案。

(二)用排队论把并发度算出来
有一条比任何经验公式都更值得记住的关系:所需并发度等于到达率乘以单次服务时间。这是排队论里的基本结论,它的价值在于把三个可测量的量变成一个可辩护的数。
到达率是每秒进入这个池的任务数,取业务高峰的分位值而不是均值——用均值会系统性地低估。单次服务时间是任务从开始执行到结束的耗时,包含下游耗时,但不含排队时间。两者相乘,得到的是"同一时刻需要有多少个任务正在跑",这就是核心线程数的下界。
举一个完整的算例。
第一步,算出理论并发度。 高峰到达率每秒 400 个任务,单次服务时间 80 毫秒(其中远程调用占 65 毫秒),理论并发度为 400 乘以 0.08,等于 32。
第二步,留出波动余量。 任务到达并非均匀分布,瞬时速率会高于平均值。按 P99 到达率计算,或者对结果乘以 1.3 到 1.5 的余量系数,得到 32 乘以 1.4,约等于 45。
第三步,施加下游约束。 下游客户端的连接池上限是 30,超过这个数的请求会在连接层排队。线程数超过 30 只是把排队从这里搬到了那里,因此取两者的较小值,得到 30。
第四步,施加本地资源约束。 每个线程的栈约占一兆,进程内已有九个池。确认 30 在总线程预算之内;如果不在,那么该做的事是先合池,而不是委屈这一个池。
最终取值是核心线程 30、最大线程 30、有界队列容量按延迟预算另算。这个数字可以被辩护:它有来源、有约束、有可复现的取数方式,当任何一个输入参数变化时可以重新推导——这正是"抄来的数"与"算出来的数"的根本区别。
这套算法有三个使用边界需要明确。它给出的是下界而不是最优值,低于这个数一定排队,高于它未必更快;服务时间会随负载变化,下游被压满之后单次耗时会自己变长,所以应该用压测时的实测值迭代一轮,而不是用空载值;它假设任务是同质的,混在一起的长短任务会互相干扰,正确做法是先分池再各自套用。

(三)等待与计算的比值怎么测
对阻塞型任务,还有一个更常见的公式:线程数约等于可用核数乘以目标利用率再乘以「一加等待计算比」。三项分别对应:机器给了多少算力、你愿意用掉多少、每个线程有多少时间其实在闲着。
前两项相对容易确定。可用核数在容器场景下必须读配额而不是宿主机核数;目标利用率对在线服务通常取 0.6 到 0.8,留出突发与垃圾回收的余量。真正需要现场测量的是第三项。
测这个比值有三种方式,精度与成本依次上升。
从时延拆解读出来。 把一次任务的耗时拆成本地计算段与远程等待段,在两段之间各打一个时间戳。等待段包含下游调用、数据库、缓存与锁等待。成本是改几行埋点代码,精度对绝大多数场景已经够用,这是推荐做法。
从线程状态采样估出来。 周期性抓取线程栈,统计属于该池的线程处于运行态与等待态的比例,等待占比除以运行占比就是近似值。成本是接一个采样器,无需改代码;精度偏粗,但足以判断量级与归类。
从线程 CPU 时间与墙钟时间算出来。 取线程的累计 CPU 时间与它的存活墙钟时间,两者之差即为等待时间,比值等于「墙钟减 CPU」除以 CPU。精度最高,可用于校准前两种方式,代价是需要开启线程 CPU 时间统计。
几类常见任务的典型比值可以给一个直观参照(按 8 核、目标利用率 0.7 计算):纯内存聚合与序列化的比值是 0,线程数约 6;一次远程调用加少量处理,计算 5 毫秒、等待 45 毫秒,比值 9,线程数约 56;多次串行数据库访问,计算 8 毫秒、等待 120 毫秒,比值 15,公式给出约 90——但连接池只有 30,此时真正的上限是 30;读取远端大文件后解析,比值 5,线程数约 34。
第三行值得特别注意:公式只给候选值,约束才给最终值。这也是下一节要展开的内容。
还有一点必须提醒:这个比值会随下游状态漂移。下游变慢时等待时间变长,比值随之变大,公式会建议你加更多线程——而此时正确的动作恰恰相反,应该是降级或限流。把公式当成自动调参的依据,会在下游故障时把局部问题放大成全链路问题。

(四)四步标定法与吞吐拐点
把上面的内容组织成流程,就是一套可以照做的四步标定法。只做第二步的团队会反复调参;做完四步的团队换机型也不用重来。
第一步,测量。 采集到达率、执行时延、等待计算比、可用核数配额。产物是四个带时间戳的实测值。
第二步,计算。 用并发度公式与利用率公式各算一个候选值,取较小者。产物是一个有推导过程的候选线程数。
第三步,压测。 在候选值上下各取三档,画出吞吐与时延随线程数变化的曲线。产物是吞吐拐点与时延膝点的位置。
第四步,回归。 把参数、依据与拐点写进配置注释,并加一条断言参数范围的启动检查。产物是一份可以被下一个人读懂的记录。
第三步的核心产物是一条曲线,它有三个区段。
线性增长区:加线程直接换来吞吐,此时瓶颈还在并发度不足。收益递减区:吞吐几乎不再上升,时延开始抬头,最优取值就在这一段的左端。劣化区:吞吐下降、时延暴涨,上下文切换、锁竞争与下游排队同时发作。
取值纪律是:取吞吐拐点略偏左的那一档,而不是曲线的最高点。最高点没有余量,流量再涨一成就直接落进劣化区。
压测有一个前提必须强调:必须打到真实的下游依赖上。打到桩上测出来的拐点只反映本地开销,而真实场景中拐点的位置往往由下游容量决定——这两个数字可以相差好几倍。

(五)上界不是公式给的,是下游给的
前面反复提到"下游约束",这一节把它讲透。
考虑一条典型链路:业务线程池并发度 60,客户端连接池最大连接 30,下游服务的线程池并发度 40,数据库可用连接 20。这四层里,你能自由设定的只有第一层,而系统的有效并发度是四者的最小值——20。
把第一层从 60 调到 100,有效并发度仍然是 20,唯一的变化是多了 80 个线程在某处等待。那么这些多出来的线程去了哪里?有三种去处,没有一种能提升吞吐。
在连接池上排队。 线程拿不到连接,阻塞在获取连接这一步。现象是线程栈里大量线程停在同一行,连接池的等待时延指标飙升。此时加线程只会让等待队列更长。
在下游服务里排队。 请求发出去了,但对端在它自己的队列里等。现象是本端时延上升而下游 CPU 并不高,下游的排队时延指标同步上升。此时加线程等于替对端制造堆积——你把自己的问题变成了两个团队的问题。
在操作系统里排队。 线程数远超核数,就绪线程互相抢时间片。现象是上下文切换次数陡增,系统态 CPU 占比明显抬头。此时加线程会让所有任务一起变慢,包括那些本来很快的。
由此得到四条容量纪律。
第一,先画出这条链,再谈线程数。把从提交到最终资源之间的每一层容量列出来,最小值才是有效并发度。第二,上游余量不应显著超过下游容量,超出的部分只会变成等待与超时。第三,扩容要从最窄的那一层开始,瓶颈在数据库连接时,改线程池参数不会带来任何改善。第四,每一层都要能拒绝,如果只有最后一层会拒绝,压力就会一路堆到最贵的那个资源上。
一句可以记住的提醒:线程是本地资源,容量是全链路属性,用本地资源去解全链路问题必然无效。

四、队列选型:队列不是缓冲区,是延迟的储存罐
(一)六种队列的语义对照
换一个队列实现,等于换掉整个池的伸缩逻辑。这句话不夸张——队列类型决定了第二道关口的行为,而第二道关口决定了后面两道关口有没有机会被走到。
有界数组队列:容量在创建时定死,满了返回失败。队列满才扩线程,扩满才拒绝,四道关口全部生效。这是推荐的默认选择,容量需按延迟预算计算。
无界链式队列:容量近乎无限,入队永远成功。最大线程数与拒绝策略双双失效。禁止在业务池中使用。
有界链式队列:构造时指定容量,语义与数组队列一致,吞吐略高、内存略碎。高并发入队时表现更平滑,是可用的选择。
直接交接队列:零容量,没有空闲线程接手就入队失败。不排队,立刻扩线程,到顶即拒绝。适合短任务、要求低时延的场景,但必须配一个可信的线程上限。
优先级队列:按比较器排序插入,默认无界。它同时带来两个问题——既无界,又可能饿死低优先级任务。要用就必须自行加容量与老化机制。
延迟队列:无界,按到期时间出队,未到期不可取出。定时与延迟任务专用,它不做背压,不应用作通用业务池的工作队列。
把这六种归纳一下,实际上队列是在三种模式之间选一个。
排队优先(有界数组或链式队列):先把任务放进队列,队列满了才扩线程。线程数稳定,时延随队列长度上升。适合任务量大、单任务短、时延允许波动的场景。代价是扩容发生得晚,尖峰前期只能靠排队扛。
交接优先(直接交接队列):不排队,来一个任务就要一个线程。时延最低,线程数随流量剧烈波动。适合任务耗时短、要求低时延、下游能承压的场景。代价是必须设可信的线程上限,否则线程数会失控。
有限排队加交接(容量很小的有界队列):队列只留一两个位置,用于吸收微小抖动。兼顾低时延与少量缓冲,适合多数在线服务的异步旁路任务。代价是需要同时把线程上限与拒绝策略配对。
选队列的第一个问题不是"用哪个类",而是"这批任务在积压时,应该等,还是应该被挡回去"。答案是"应该等",就用有界队列并按可接受时延算容量;答案是"应该被挡回去",就用零容量或极小容量并把拒绝策略设计好。这个问题回答不了,说明这批任务的业务语义还没想清楚,参数怎么配都会错。

(二)无界队列:把容量问题伪装成内存问题
无界队列值得单独一节,因为它是本文认为最应该被立刻消除的一种配置。它的危险不在于"可能会堆积",而在于它把一条本应在几秒内暴露的故障链,改造成了一条持续几十分钟、且每一步都不报错的链路。
这条链路是这样走的:
流量上涨,到达率超过池的处理能力。队列开始增长,但任务入队全部成功,没有任何失败信号。排队时延上升,端到端变慢,而错误率仍然是零。上游开始超时,按重试策略重试,到达率进一步上升。队列加速膨胀,重试放大形成正反馈,增长从线性变成指数。老年代被撑满——注意这里不只是任务对象本身,还包括任务闭包捕获的全部入参。垃圾回收变得频繁且无效,每次回收都收不回来,停顿时间越来越长。最后进程内存溢出,此时才第一次出现明确的错误信号。
这条链路上有三个位置本可以打断它,无界队列把它们全部拆掉了。
本该在第二步:入队失败。 有界队列在这里就会返回失败,拒绝策略随即被触发,问题在几秒之内暴露为明确的拒绝计数,而不是几十分钟后暴露为内存溢出。这两种暴露方式的处置成本相差一个数量级。
本该在第四步:背压回传。 拒绝会让提交方立刻感知到过载,从而触发限流、降级或排队让位。队列吸收了这个信号,于是上游继续以原速率加压,正反馈得以形成。
本该在全程:容量可算。 有界队列的最坏内存占用是可以算出来的:容量乘以单个任务对象的保留大小。无界队列的这个乘积没有上限,容量评审因此无从谈起。
有三处写法最容易在不经意间引入无界队列:用工厂方法创建固定大小的池,内部是无界链式队列;用工厂方法创建单线程池,同样是无界链式队列;自己构造链式队列时不传容量参数,默认就是无界。
这三处都可以被一条静态检查规则挡住:禁止不带容量参数的队列构造,禁止用工厂方法创建执行器。这是本文十二条门禁规则中最应该优先落地的一条。

(三)队列容量用延迟预算倒推
确定了要用有界队列之后,下一个问题是容量填多少。这个数字在多数代码里是拍出来的——一千、一万、十万,取决于写代码那天的心情。
实际上它有一个明确的物理含义:队列里排着 N 个任务时,队尾任务的预期等待时间等于 N 除以并行度再乘以单任务服务时间。把这个关系倒过来用,就得到了容量的计算方式:
队列容量小于等于「可接受排队时延除以单任务服务时间再乘以并行度」。
这条式子的价值在于,它把一个凭感觉的容量数字,变成了一个可以和产品经理讨论的时延承诺。同样一个池,三种时延要求会给出三种完全不同的容量。
交互式请求的旁路任务,可接受排队时延 200 毫秒。并行度 30、单任务 80 毫秒,每毫秒可消化 0.375 个任务,容量约为 75。结论:容量 75,超出即拒绝。
准实时的后台处理,可接受排队时延 5 秒。五秒内可消化约 1875 个任务,容量取 2000。结论:容量 2000,同时监控水位。
离线批量任务,可接受排队时延 5 分钟。五分钟内可消化约 11 万个任务——此时内存约束先于时延约束生效。结论:容量由内存预算决定,而不由时延决定。
这就引出了第二道约束。算完时延约束之后,还要用内存约束再夹一次:队列的最坏占用等于容量乘以单个任务对象的保留大小。这里的"保留大小"包含任务闭包捕获的全部入参——一个持有大列表的 Lambda,单个可能就是几兆。这个乘积必须显著小于老年代的可用空间。两个上界取小者,才是最终容量。
容量取得过大有四个副作用,值得一并列出:排队时延超出上游超时时间,任务跑完也没人要了;任务对象长期存活并晋升到老年代,加重回收压力;过载信号被延后,故障发现时间被拉长;重启时队列内容丢失,丢失量与容量成正比。
结论是:容量大不等于更安全,只是更晚失败。而更晚失败通常意味着更贵。
一个可以立刻做的检查:如果算出来的排队时延已经超过上游的超时时间,那么超出的这一段队列纯粹是在制造无用功——任务跑完时,调用方早已返回失败。这种情况下正确的做法是把队列改小,让拒绝提前发生。

五、拒绝策略:拒绝不是故障,是容量保护在生效
(一)四种内置策略把压力推给了谁
拒绝策略是线程池里唯一一段"只在过载时才会执行"的代码。正因如此,它是最少被测试、也最容易配错的一处。
四种内置策略的区别不在于"怎么拒绝",而在于"把压力推给了谁"。这个视角比记住它们的类名有用得多。
中止策略:抛出拒绝执行异常。压力推给提交方的调用栈,提交方会收到一个明确的运行时异常。适合调用方有能力降级或返回失败的场景。风险在于上游往往把它当成系统错误直接告警,于是一次正常的容量保护被记成了一次故障。必做的动作是捕获它并转成业务语义的失败。
调用者执行策略:让提交方自己把任务跑掉。压力推给提交任务的那个线程,提交方被迫同步执行,提交速率自然下降。适合离线批处理这类生产者可被阻塞的场景。风险极大——在 Web 容器线程上使用它会拖垮入口,下一节专门讲这一点。
丢弃策略:静默丢掉新提交的任务。压力不推给任何人,任务凭空消失,不抛异常、不打日志、不留痕迹。适合可丢的采样上报、缓存预热等场景。风险是默认状态下没有任何计数,你无法知道丢了多少。必做的动作是自己包一层,至少要有计数与采样日志。
丢弃最老策略:扔掉队首,再把新任务塞进去。压力推给队列里等得最久的那个任务。本质上是把队列从先进先出改成了后进先出优先。适合新数据可以覆盖旧数据的行情推送、状态同步等场景。对需要顺序或不可丢的任务是灾难。
选择判据其实只有两个问题。
问题一:这个任务可以丢吗。 可以丢且丢了也不需要知道,用丢弃策略加计数;可以丢但需要知道丢了多少,用自定义策略加指标;不能丢但可以晚点做,落库或落消息队列后异步补做;绝对不能丢,那么这个任务本来就不该只放在内存队列里——它需要一个持久化的载体。
问题二:提交方可以被阻塞吗。 提交方是离线任务的主循环,调用者执行策略最合适;提交方是 Web 容器线程,绝不能用调用者执行策略;提交方是另一个线程池,会造成跨池的连锁阻塞;提交方是消息消费者,阻塞等价于停止消费,需要评估消息侧的堆积。
无论选哪一种,都有三件事必须做:拒绝次数必须成为一个独立指标并接入告警,它是过载最早、最准确的信号;拒绝日志必须带上任务标识与当时的队列水位,否则事后无法复盘;拒绝行为必须在预发环境被真实触发过一次,确认上游的处理逻辑符合预期。
最后一句值得展开:一个从不拒绝的线程池,通常只是把故障推迟到了更贵的地方。拒绝本身不是故障,它是容量保护正在生效的证据。

(二)调用者执行策略:它是背压,不是兜底
这个策略被广泛误解为"一种更温和的兜底方式"。它不是。它是一种非常有效的背压机制,而背压机制用在错误的位置上,就是一场事故。
先看它成立的场景:离线批处理的主循环。主循环不断提交任务,某一刻队列满了,触发拒绝,主循环自己把这个任务跑掉。在它执行这个任务的这段时间里,它没有在提交新任务。于是提交速率自动降到与消费速率一致——这是一个完美的自适应背压闭环,不需要任何额外配置。
再看它失效的场景:Web 容器的请求线程。请求线程提交一个异步旁路任务,队列满了,触发拒绝,请求线程被迫同步执行这个任务。在它执行的这段时间里,它没有在处理请求。容器线程池的线程被逐个占住,新请求无法被接收,整个服务不可用。
同一个策略,在第一个场景里是最优解,在第二个场景里是把一个旁路功能的过载升级成了主链路故障。
差别来自一个被忽略的前提:调用者执行策略成立的前提是,占用提交方线程是可接受的。提交方是自己的主循环时,占用它就是降速,这正是我们想要的;提交方是共享的入口线程时,占用它等于减少整个服务的接待能力。
如果确实需要在入口路径上做背压,有三种更合适的形态。
提交前先问容量。 在提交之前检查队列水位,超过阈值时直接走降级分支,而不是提交之后再被拒绝。优点是入口线程完全不被占用。
有限等待的提交。 用带超时的入队方法,等待一个明确的短时限,超时即视为拒绝。优点是能吸收抖动而不吸收持续过载——这个区分很重要,抖动应该被吸收,持续过载必须被挡回去。
拒绝即降级。 自定义策略,在拒绝时立刻返回一个降级结果或写入补偿表,由离线任务后续补做。优点是主链路时延完全不受影响。
判断口诀:占用提交方线程,是在给系统降速,还是在给系统减容。前者可以接受,后者不行。

(三)自定义策略要做的五件事,以及与限流降级重试的分工
内置策略只完成了动作,没有完成交代。一个可以上生产的拒绝策略应该做五件事。
一、计数。 按池名维度累加拒绝次数,作为独立指标上报。这是过载最早的信号,通常比时延曲线早几十秒。
二、留痕。 打一条带采样的日志,记录任务标识、队列水位、活跃线程数与当时时间。必须采样——不采样会让日志本身成为故障的一部分,过载时每秒几万条错误日志会把磁盘和日志采集链路一起压垮。
三、转义。 把拒绝转换成业务语义的失败,而不是把底层异常直接抛给上游。上游需要知道的是"系统繁忙",而不是某个内部类的名字。
四、兜底。 决定这个任务的最终归宿:丢弃、落库补偿、投递消息队列,或降级为同步执行。这一步必须被显式写出来,写不出来说明这个任务的重要性还没有被想清楚。
五、联动。 触发限流阈值下调或熔断判定,让上游在下一个周期减少提交。拒绝如果不反馈给上游,下一秒还会以同样的速率到来。
这五件事写成代码大约十行,但它把一个"过载时的未定义行为"变成了一个"过载时的确定行为"。
这里需要澄清拒绝、限流、降级、重试四者的分工,它们经常被混为一谈。
限流作用在入口、提交之前,它控制到达率,让负载进入可承受区间;但它不知道内部是否已经积压。拒绝作用在池内、队列满时,它在容量耗尽时给出确定的失败;但它不能减少下一秒的到达量。降级作用在拒绝之后,用更便宜的路径给出一个可用结果;但它不能保证结果的完整性。重试作用在失败之后,补救偶发失败;但在过载时重试会放大负载,必须与拒绝联动。
最危险的一种组合是:拒绝之后立刻原地重试,且没有退避。结果是拒绝率越高、到达率越高,系统再也无法自行恢复——这是一种典型的正反馈失控,很多"莫名其妙就雪崩了"的故障根源就在这里。
推荐的组合是:拒绝计数上升触发限流阈值自动下调,到达率随之回落。系统在过载时能自己走回可服务区间,无需人工介入。

六、任务堆积:从形状到根因到处置
(一)堆积的四种形状
线上告警响起、队列水位曲线摆在面前时,第一个动作不应该是抓线程栈,而应该是看曲线的形状。形状本身就把成因范围缩小了一多半,而抓栈是一个成本不低、结论也不总是清晰的动作。
脉冲型:涨得快、退得也快。 成因通常是一次突发流量或一批定时任务同时提交。判据是到达率曲线上有对应的尖峰。多数情况下不需要处置,确认峰值在容量之内即可。但如果峰值触及了队列容量,说明容量或线程数需要复核。这种形状下最不该做的事是把队列容量加大——那只会掩盖掉本可以提前发现的峰值。
阶梯型:涨上去就不下来。 成因是处理能力发生了永久性下降,通常来自一次变更或下游劣化。判据是执行时延的分位数在同一时刻抬升并保持。处置顺序应该是先看变更、再看下游,不要先动线程池参数。这是最容易被误判为"流量涨了"的一种形状,而误判的代价是往错误的方向扩容。
锯齿型:反复涨落但底部逐渐抬高。 成因是周期性任务与在线流量互相挤占同一个池。判据是波峰周期与某个定时任务的调度周期一致——这个对照通常一分钟就能做完。根治手段是把批量任务与在线任务分池。底部抬高说明每个周期都没有完全消化掉,长此以往会演变成单调上升型。这种形状下最不该做的事是调整批量任务的执行时间点,治标一周后必然复发。
单调上升型:只涨不落。 成因是到达率持续超过处理能力,或者任务卡死不返回。判据是活跃线程数长期贴顶而完成计数不增长。这是唯一一种会自己走到进程崩溃的形状,必须立即止血——限流、扩容或强制拒绝,不能观望。这种形状下最不该做的事是"等一等看看会不会自己好",它不会。
认错形状,后面每一步都会走偏。这是堆积处置里性价比最高的一个动作,成本是看一眼曲线。

(二)六类根因与三个指标的切分
形状把范围缩小之后,需要把根因收敛到具体的一类。堆积的根因有六类,处置手段完全不同,误判的代价通常是把故障时间延长一倍。
第一类:到达率真的涨了。 信号是提交计数速率同步上升。确认动作是看提交速率曲线与业务流量曲线是否同步;如果是活动或推送引起的,属于预期之内。处置是限流保护加临时扩容,不改池参数。
第二类:单任务变慢了。 信号是执行时延分位数抬升而提交速率平稳。确认动作是对比 P50 与 P99 的变化:P99 单独恶化通常是下游抖动,整体抬升多半是变更。处置的前提是先定位慢在哪一段,不要先加线程。
第三类:线程被卡住不返回。 信号是活跃线程贴顶、完成计数几乎不增长。确认动作是抓线程栈,看是否大量线程停在同一行——常见于无超时的远程调用、锁等待、死循环。这是最危险的一类,需要立即隔离实例并在保留现场后重启。
第四类:线程数配得不够。 信号是活跃线程持续等于核心数,队列稳定增长。确认动作是检查是否所有线程都在有效工作且下游尚未饱和。此时提高线程数确实有效,但要先确认下游容量,并按标定流程重新算一次,而不是直接翻倍。
第五类:池被别的任务挤占。 信号是队列里混着两种耗时差异巨大的任务。确认动作是按任务类型拆分执行时延,看分布是否呈双峰。典型场景是批量导出与在线查询共用一个池。分池是唯一的根治手段。
第六类:下游或依赖资源饱和。 信号是本端时延升高但本端 CPU 与线程都不忙。确认动作是看连接池等待时延与下游服务的排队指标——线程都在等连接或等对端,与本池参数无关。处置方向是往下游看,本池只需要保证不放大压力。
在故障现场,有一个更快的办法:用三个指标把六类根因切成三组。
提交速率上升、执行时延平稳、活跃线程贴顶,落在第一类。提交速率平稳、执行时延上升、活跃线程贴顶,落在第二类或第六类。提交速率平稳、执行时延无法统计(因为任务不返回)、活跃线程贴顶且完成数不增,落在第三类,这是最高优先级。三个指标都平稳但队列在涨,落在第四类或第五类。
这三个指标必须提前埋好。故障发生时再去加埋点,等于放弃了归因——等你发上线,故障已经结束了。

(三)现场处置顺序:止血、归因、恢复
顺序颠倒是这类故障最常见的放大方式——一边查原因,一边看着队列继续涨。
第一阶段:止血,目标是不再变得更坏。 上游限流,把到达率压到当前处理能力之下;切走非关键流量,批量任务、预热任务先停;必要时主动拒绝,让队列停止增长比让它慢慢涨更安全;如果是线程卡死,隔离该实例并保留现场后重启。
第二阶段:归因,目标是找到可以被修复的那一个点。 先看变更——最近一次发布、配置推送、开关切换;再看三个指标;抓两次线程栈快照,间隔十秒,比较线程停留的位置;按上一节的判定表把根因收敛到一类,再深入。
第三阶段:恢复,目标是把积压安全地消化掉。 确认根因已消除,否则消化会再次堆积;逐步放开限流,而不是一次性全放;观察队列水位是否单调下降,不下降就退回上一步;积压任务如果已经超过业务时效,应当丢弃而不是补跑——补跑一批早已无人关心的任务,只会让恢复期变得更长。
有三条判断在现场特别容易做错。
直接重启了事。 重启会丢掉全部内存队列里的任务,且丢了多少没人知道。先落档再重启,代价只多几分钟,换来的是可交代的丢失清单。
先加线程数。 在根因是下游饱和时,加线程等于加大对下游的压力,会把局部故障扩大成全链路故障。
等一等看看。 单调上升型堆积不会自愈。每等一分钟,后续的消化时间与丢失范围都在同步扩大。
事后必须补上四件事,否则同一个故障会在两个月内复发:补埋点,把这次缺的那个指标补上,多数情况下是排队时延与拒绝计数;补容量依据,把线程数与队列容量的推导过程写进配置注释与设计文档;补隔离,把这次互相挤占的两类任务分开,分池的成本远低于再来一次故障;补演练,在预发环境把队列打满一次,确认拒绝、降级、告警全部按预期动作。
故障复盘的验收标准可以定得很具体:下一次同类堆积,能否在三分钟内被定位到六类根因中的一类。

(四)四段时延:排队时延为什么必须单独埋
上面反复提到排队时延,这一节说清楚它的位置和价值。
一次异步任务的端到端时延由四段构成。提交段:调用方准备任务并调用 execute,通常可忽略,除非提交本身被阻塞。排队段:任务在队列里等待被取走,这是线程池独有的一段。执行段:工作线程真正在跑这个任务,这是多数团队唯一在测的一段。回传段:结果写回、回调触发、上下文还原,异常与超时最常在这里被吞掉。
上游看到的是四段之和。当只测执行段时,上游反馈的"变慢了"在本端的监控上完全看不出来——这就是为什么很多团队在故障复盘时会说"我们的监控是绿的"。
排队时延与执行时延必须分开上报,合在一起就失去了全部诊断价值。
排队时延的取法是在任务对象里记入队时间戳,开始执行时相减。它的含义是"这个池的容量是否够用"。它上升说明到达率超过了处理能力,或者线程被占住了。它的报警阈值应该与上游超时时间挂钩,而不是用一个固定值——排队时延超过上游超时的一半,就已经很危险了。它是判断"该不该加线程"的唯一直接依据。
执行时延的取法是开始与结束两个时间戳相减。它的含义是"单个任务本身有多贵"。它上升说明代码变更、下游变慢或数据量变大。它是判断"该不该优化任务本身"的依据。
两个指标的四种组合各自指向不同的处置:都低是健康;排队高、执行低是容量不足,任务不慢但没人来取,应该加线程或减少到达率;排队低、执行高是任务本身变贵但池还接得住,应该优化任务或下游,不要动池参数;两个都高说明任务变慢导致了容量不足,正在恶化,应该先止血限流再查任务变慢的原因。
如果整篇文章只能落地一个指标,那就是排队时延。它把"线程池的问题"和"下游的问题"一刀分开,而这一刀在故障现场值几十分钟。

七、上下文传递:跨线程丢的不只是链路号
(一)线程本地存储为什么不跟随任务
这是跨线程上下文丢失的全部机理。理解了它,后面所有方案都是自然推论,不需要记忆。
线程本地存储的值物理上存在哪里?它存在线程对象内部的一张映射表里。提交方线程的那张表里有链路标识、当前用户、租户、日志上下文;工作线程也有一张自己的表,但那是另一张表。
跨线程传过去的只有任务对象的引用。线程持有的那张表,一个字节都不会跟着过去。
工作线程的表里有什么?两种可能:什么都没有(这个线程刚创建,或者从没有人往里写过),或者是上一个任务留下的值(这个线程被复用了,而上一个任务没有清理)。
任务对象能带走的,只有它在创建时刻捕获进闭包的那些字段。这正是所有传递方案的着力点——既然只有闭包能过去,那就把上下文塞进闭包。
由此得到三条推论,它们解释了后面全部方案的形状。
推论一:必须在提交时刻捕获。 上下文只在提交方线程上是可见的。一旦任务进了队列,提交方可能已经返回并清理了自己的槽位。所以捕获必须发生在提交那一刻,不能推迟到任务开始执行时。这解释了为什么所有方案的捕获动作都写在包装器的外层,而不是内层。
推论二:必须在执行前回放。 工作线程要读到这些值,唯一办法是在任务真正开始之前,把捕获到的快照写进工作线程自己的那张表里。这一步只能由包装层完成,业务代码不应该也不会去做。
推论三:必须在执行后还原。 工作线程会被复用。任务结束时如果不把表清回原样,下一个任务就会读到上一个任务的值。这是比"丢失"严重得多的一类缺陷,因为它不报错,只是把数据算错。

(二)可继承的那个为什么在池化下必然失效
面对上下文丢失,很多团队的第一反应是换用可继承的线程本地存储。这个方案在某些场景下确实有效,但在线程池场景下它必然失效,而且失效的方式比"没生效"更糟。
它成立的场景是"每来一个任务新建一个线程":请求线程设置上下文,链路号为 A;创建子线程;创建的那一刻,父线程的值被复制给子线程;子线程读到链路号 A,正确。
关键在于复制发生在线程创建的那一刻。而线程池的本质恰恰是不创建线程。
它在池化场景下的实际执行序列是这样的:请求 A 提交任务,工作线程首次创建,复制得到链路号 A;任务跑完,工作线程活着回到池里,槽位里仍然是 A;请求 B 提交任务,复用同一个工作线程;线程没有被重新创建,于是复制动作根本不发生;任务在链路号 A 的上下文里,执行了请求 B 的逻辑。
注意最后一行的严重性:这不是"上下文丢了",而是"上下文错了"。
丢失会让链路断成两截,运维一眼能看出来,排查方向也很清楚。串号则会让 B 的操作被记在 A 的名下,数据完全"正确"地写入了错误的归属,可能几个月都没有人发现——直到有人来投诉自己的账户里出现了别人的记录。
四种方案的对照可以这样总结:普通的线程本地存储不复制,池化下不成立,只适用于同线程内传递;可继承的线程本地存储在子线程创建时复制,池化下不仅不成立而且会串号,只在"一任务一线程"时可用;可传递的线程本地存储在任务提交时复制,池化下成立,是池化异步的推荐方案;显式参数传递由调用方手工传,永远成立,在上下文项少时是最简单可靠的选择。
这里可以直接给出一条静态检查规则:可继承的线程本地存储不得与任何执行器同时出现在一个调用链上。这类缺陷的典型报告是"偶发的日志串号",而它的根因是完全确定的、可以被规则挡住的。

(三)捕获、回放、还原:三段模型
任何一种可用的方案,本质上都是三个动作的不同实现。理解了这三段,选哪个框架就变成了一个次要问题。
第一段,捕获。 在提交方线程上,把当前全部上下文拍成一个快照,塞进任务闭包。这一步必须此刻发生,不能推迟。
第二段,回放。 任务被工作线程取出、真正开始执行之前,把快照写进工作线程的槽位。任务体执行期间读到的就是提交方的上下文。
第三段,还原。 任务结束时,把槽位恢复成执行前的样子。注意是"恢复成执行前的样子",而不是"清空"——这两者的差别下一节会讲。
三段各自缺失时的后果完全不同。
缺捕获:工作线程读到的是空值或残留值。表现为链路断裂、日志缺少业务标识,或者更糟,读到上一个任务的用户号。
缺回放:快照带过去了但没有生效。表现与完全没有传递一样,但排查时会因为"代码里明明传了"而更费时间——这是一种特别消耗人的缺陷形态。
缺还原:工作线程的槽位被永久污染。这个线程之后执行的每一个任务,都会读到某一次任务留下的旧值。影响范围随时间不断扩大。
这三段写成代码不长:
Runnable wrap(Runnable task) {
Map<String, String> mdc = MDC.getCopyOfContextMap(); // ① 捕获:在提交方线程上完成
Context ctx = ContextHolder.capture();
return () -> {
Map<String, String> backup = MDC.getCopyOfContextMap();
try {
MDC.setContextMap(mdc); // ② 回放:任务体执行之前
ContextHolder.replay(ctx);
task.run();
} finally {
ContextHolder.restore(backup); // ③ 还原:无论成败都要执行
MDC.clear();
}
};
}
有一个细节必须强调:还原一定要写在 finally 里。任务抛异常时如果跳过还原,污染会一直留在这个线程上,而线程池会一直复用这个线程。

(四)五类必须搬运的上下文
清点比选框架更重要。多数团队只处理了第一类,而事故往往出在第三类和第四类。
第一类:链路追踪标识。 包括链路号、跨度号、采样标记。丢失后果是异步之后的日志无法与请求关联,表现为查一个投诉工单时异步那半段完全查不到。多数追踪框架已提供包装器,接上即可。验收标准是异步日志里能搜到与同步段相同的链路号。
第二类:日志诊断上下文。 包括订单号、用户号等业务维度。丢失后果是异步日志缺少可检索的业务字段,表现为日志能搜到但无法按订单聚合。需要在包装器里显式复制与清理。验收标准是异步日志里的业务字段与主链路一致。
第三类:身份与权限。 包括登录用户、角色、鉴权结果。丢失后果是异步任务里取不到当前用户,轻则空指针,重则用默认身份执行了越权操作。安全框架的上下文持有策略需要专门配置。验收标准是异步任务里读到的用户与请求发起者一致。
第四类:租户与数据源路由。 包括租户标识、分库分表路由键。丢失后果是异步任务连到了错误的库或错误的租户,表现为跨租户数据污染——这是本文列出的所有后果里最贵的一种。路由组件通常也用线程本地存储,必须一并处理。验收标准是异步任务写入的目标库与主链路一致。
第五类:事务与连接绑定。 这一类的正确做法与前四类相反:不要传。
前四类的正确做法是"传过去",第五类的正确做法是"不要传"。事务的边界是线程绑定的,把连接带进另一个线程会同时破坏两件事:连接的线程安全假设,以及事务的提交与回滚语义。
正确的形态是在事务提交成功之后,再由回调触发异步任务。很多"主表回滚了但下游已经收到通知"的事故,根因就在这里——异步任务在事务提交之前就被触发了,而事务随后回滚了。
清点动作可以这样执行:扫描全部线程本地存储的声明位置,包括框架与中间件持有的那些;标注每一个是否会被异步任务读取,如果会,属于上面五类中的哪一类;收口,把包装动作做进统一的执行器工厂,禁止业务代码直接构造执行器;验收,写一条测试,在异步任务里断言五类上下文与提交方完全一致。
这件事只需要半天,而它避免的是那种"三个月后才被发现"的数据污染。

(五)不还原比不传递更危险
丢失是显性缺陷,串号是隐性缺陷。后者不报错,只是把事情记到了别人头上。
看一个同一个工作线程连续执行三个任务的序列。
任务一:设置用户为 u_100,执行完毕,未清理。线程槽位当前值是 u_100。
任务二:这个请求本身是匿名的,代码里没有设置用户。它读到了 u_100。线程槽位仍然是 u_100。
任务三:设置用户为 u_200,执行完毕,未清理。线程槽位变成 u_200。
任务二的所有操作,都会被记录在用户 u_100 名下。没有异常、没有告警、没有任何日志异常——数据是"正确写入"的,只是写错了归属。
把还原做对有三个要点。
还原成执行前的样子,而不是清空。 清空看起来更简单,但如果这个线程本身也承载了别的上下文(例如池自己的标签、框架写入的标记),清空会把它一起抹掉。正确做法是先备份、后恢复。
放在 finally 里,而不是任务末尾。 任务抛异常时,写在末尾的清理不会执行,污染会永久留在这个线程上。而线程池会一直复用这个线程,影响范围随时间不断扩大——一个偶发异常,最终变成了一个持续存在的数据归属错误。
包装层统一做,而不是靠业务自觉。 把捕获、回放、还原封进统一的执行器,业务代码只管提交任务。任何"请记得在任务结束时清理"的口头约定,都会在下一个季度被新同事打破。
这里可以给出一条可以写进测试基类的断言:任务执行结束之后,工作线程的上下文槽位必须与执行之前逐项相等。几行代码,永久挡住这一类缺陷。

八、失败收口:异常、超时与取消
(一)任务失败的五条去向
线程池里的失败之所以难查,是因为它默认散落在五个互不相通的位置。
第一条:任务体内被就地吞掉。 表现是 catch 之后只打了一行调试级别的日志。收口做法是禁止空捕获与随意降低日志级别,异常必须向上抛或显式转成结果状态。
第二条:留在 Future 里无人问津。 表现是 submit 之后没有人调用 get。收口做法是不需要结果就用 execute;需要结果就必须带超时地 get 并处理。
第三条:冒到工作线程的栈底。 表现是线程被终止,池静默补建一个新线程——这个补建动作让问题更隐蔽,因为线程数看起来一直是正常的。收口做法是在线程工厂里设置未捕获异常处理器,统一上报并计数。
第四条:被 afterExecute 钩子拿到。 它的默认实现是空的,什么都不做。收口做法是覆写它,并且要同时处理 execute 与 submit 两条路径的异常——后者需要从 Future 里挖出来,这一点很容易漏。
第五条:在回调链的末端消失。 组合式异步链如果没有终端异常处理,异常会在链尾静默丢失。收口做法是链尾强制要求终端处理,这一条可以被静态检查覆盖。
五条去向意味着五套处理逻辑,而更好的做法是把它们收敛到一个地方:一个统一的任务包装器。
Runnable decorate(String name, Runnable task) {
Context ctx = ContextHolder.capture();
long enqueueAt = System.nanoTime();
return () -> {
QUEUE_LATENCY.labels(name).observe(System.nanoTime() - enqueueAt); // 排队时延
try (Scope ignored = ContextHolder.replay(ctx)) { // 上下文回放与自动还原
EXEC_TIMER.labels(name).record(task::run); // 执行时延
} catch (Throwable t) {
TASK_ERROR.labels(name, t.getClass().getSimpleName()).inc(); // 失败计数与告警
log.error("async task failed: {}", name, t);
}
};
}
这段包装器一次写好,本文前面提到的一半问题都会被它顺带解决:排队时延有了、执行时延有了、上下文传递有了、还原有了、异常收口有了。它的前提条件只有一个——所有提交入口都必须走它,也就是说业务代码不能直接接触执行器。

(二)超时与取消:中断只是一个请求
这一节要澄清一个广泛存在的误解:上层超时返回,不等于下层真的停了。
上层做的事情是:调用 get 时设置了两秒超时,两秒到了抛出超时异常,调用方记录失败并返回降级结果,然后认为"这次调用已经结束"。
下层实际发生的是:任务仍然在工作线程上运行,它占着线程、连接与内存;它跑完之后还会写库、还会发消息。上层已经返回失败,下层却成功了。
这不只是资源浪费,它还制造了一种很难排查的数据不一致:用户看到的是"操作失败",而系统里这条操作实际上生效了。
那么中断能停住什么?这是取消能力的全部边界。
阻塞在可中断的等待上(如等待队列、条件变量、休眠):中断生效,会立刻抛出中断异常并退出。应对是捕获后清理资源并结束任务。
阻塞在网络读上:多数情况下中断不生效,要等到读超时才会退出。真正的止损手段是给套接字设置读超时——这才是网络层任务真正的时间边界。
正在做纯计算:中断不生效,标记被置位但循环不会停。应对是在循环里主动检查中断标记。
阻塞在同步锁上:中断不生效,会一直等到拿到锁。应对是改用可中断的锁获取方式。
四种情况里有三种中断都不生效,这是"中断只是一个请求,不是一道命令"的具体含义。
把取消做实有三条纪律。
超时必须下沉到最底层。 上层的超时只能让调用方不再等待,真正让任务停止的是底层的读超时、连接超时与语句超时。每一层都要有自己的超时值,且应该逐层收敛。
任务要主动配合取消。 长循环里定期检查中断标记;捕获中断异常后不要吞掉,而是恢复中断状态并尽快退出。不配合的任务无法被任何机制停下来。
取消之后的副作用要收口。 已经取消的任务不应再产生外部副作用。做法是在写库、发消息之前再检查一次取消状态,或者用幂等键让重复动作无害。这是与上层降级结果保持一致的关键。
有一个可以直接查的信号:超时计数持续上升,但活跃线程数并没有随之回落。这说明超时只发生在上层,任务在下层仍在积累——这是一种缓慢的泄漏,它最终会把池占满。

九、可观测:九个指标与它们各自回答的问题
(一)必须暴露的九个指标
一个不上报指标的线程池,在故障现场等于一个黑盒。下面九个指标的采集成本只有一个包装器,而它决定了故障定位是三分钟还是三小时。
提交计数速率回答"到达率是多少",上升说明流量涨了或上游在重试。完成计数速率回答"处理能力是多少",低于提交速率即为净堆积。队列当前长度回答"现在积压了多少",适合配水位告警,比时延告警更早。队列容量占比回答"离拒绝还有多远",超过七成即应告警。排队时延分位数回答"任务等了多久才开始",本文认为这是最重要的一个。执行时延分位数回答"任务本身有多贵",必须与排队时延分开看。活跃线程数回答"有多少线程正在跑"。拒绝与丢弃计数回答"有没有任务没被执行",是过载最早、最确定的信号。任务异常计数回答"有多少任务失败了",应按异常类型打标签以便归因。
其中活跃线程数是最容易被误读的一个。单看它会得出相反的结论:活跃线程数贴顶,可能是"干得正欢",也可能是"全部卡死在同一个调用上"。这两种情况的处置完全相反——前者需要扩容,后者需要立刻隔离重启。
解决办法很简单:把它和完成计数放在同一张图上。活跃贴顶加完成计数正常上升,是容量不足;活跃贴顶加完成计数几乎不动,是线程卡死。这个判断只需要一眼,而这也是监控面板设计上最值得做的一处改进。
还有一个容易被忽略的细节:九个指标都应该带上池名标签。一个进程里有十几个池,不区分池名的聚合指标在排查时没有任何用处——你会看到一条抖动的曲线,却不知道是哪个池在抖。

(二)动态调参:可调什么,不可调什么
有了指标之后,很自然会想到动态调参:在不重启的前提下调整线程池参数。这是一个有价值的能力,但它的边界需要说清楚。
可以在线调整的:核心线程数、最大线程数、存活时间。这三个参数的设值方法本身就是设计为可在运行期调用的。调整核心线程数时,如果调小,多余的线程会在下一次空闲时被回收;如果调大,池会在有新任务到来时逐步补足。
不能直接调整的:队列容量。标准的队列实现里容量是只读的,想要可调需要换用支持容量变更的队列实现——这也是很多动态线程池组件的核心改造点之一。
可以替换但要小心的:拒绝策略。它可以在运行期替换,但替换的时机很关键:过载正在发生时替换策略,等于在飞行中换发动机,行为会变得难以预测。更稳妥的做法是在非过载时段完成变更。
动态调参的真正价值不在于"随时可以改",而在于两点:故障现场可以立刻止血,不必等一次发版;以及可以低成本地做参数实验,把标定流程中的压测环节搬到生产的低峰期做。
但它也带来一个风险:参数变得容易改之后,"改一下试试"会重新变成默认动作,而本文第一章批评的那种搜索式调参会以更快的速度重演。因此动态调参应该配套两件事:每一次变更都要有记录与操作人,以及变更后的效果要有明确的观察窗口与回滚条件。
十、隔离与共享:一个池不能装两种任务
(一)共池的传导链与切池的四条判据
共池带来的不是资源复用,而是把两类任务的最坏情况绑在了一起。
有三条典型的传导链。慢任务占满线程:批量导出占住全部线程,在线查询无线程可用,主链路超时。大任务占满队列:一次推送产生十万个任务,队列被填满,其他任务全部被拒绝。坏任务毒化线程:某类任务触发死循环,线程逐个被占死,池的有效容量单调下降——这一条最隐蔽,因为它的劣化是渐进的。
那么按什么维度切池?有四条判据,命中任意一条就应该切。
按时延要求切:在线与离线。 判据是两类任务的可接受时延相差一个数量级以上,例如用户点击触发的查询与每日报表生成。不切的后果是报表跑起来时,查询全部超时。
按耗时量级切:长任务与短任务。 判据是单任务耗时相差十倍以上,例如毫秒级的缓存刷新与分钟级的文件解析。不切的后果是短任务被长任务堵在队列后面,而短任务往往是对时延最敏感的那些。
按依赖切:不同的下游。 判据是任务依赖不同的外部服务或存储,例如调用风控与调用短信网关。不切的后果是一个下游抖动拖垮所有异步能力——这是把单点故障放大成面故障的典型路径。
按重要性切:核心与非核心。 判据是一类任务失败会影响交易而另一类不会,例如支付回调处理与埋点上报。不切的后果是埋点洪峰把支付回调挤掉。
切池不是免费的,有三笔账必须一起算。
线程总量账:切成 N 个池之后,常驻线程总数是各池核心数之和。不能每个池都按"核数乘二"配,否则总线程数会失控。正确做法是先定进程的线程总预算,再在池之间分配。
运维复杂度账:每个池都需要独立的指标、告警与容量依据。池的数量超过十个之后,人工维护参数已不现实,需要统一的池注册与默认参数模板。
利用率账:切池会降低整体利用率,某个池空闲时它的线程不能借给繁忙的池使用。这份损失应当被接受,它买到的是故障隔离。
隔离的判断标准可以很简单:这两类任务里,最坏的那一个能不能被允许影响另一个。

(二)你没有创建却正在使用的公共池
有一类线程池特别值得警惕:你没有创建它,甚至不知道它存在,但你的代码正在使用它。
这就是进程内的公共并行池。它的默认并行度是可用核数减一,全进程共享,无法按业务隔离。使用它的有四类代码:集合的并行遍历默认提交到这里;组合式异步的无执行器重载默认用它;部分库在你不知情时也在用它;以及同一个进程里其他团队写的业务代码。
于是出现这样一条链路:某处并行流里放了一个阻塞调用,公共池被占满,全进程所有用到并行流的地方一起挂起。这类问题的排查难度极高,因为受影响的模块与真正的肇事者之间没有任何代码上的关联——你在 A 模块看到的故障,根因在 B 模块,而两者从不互相调用。
有三条纪律可以避免它。
并行流里不放阻塞操作。 并行流的设计前提是纯计算任务。一旦放进远程调用或数据库访问,它就会以最坏的方式占满公共池。需要并行做阻塞调用时,用自己的池。
组合式异步必须显式传执行器。 带异步后缀的方法通常有两个重载:一个用公共池,一个接收执行器。业务代码只允许使用后者,这一条可以做成静态检查规则。
// 不推荐:使用全进程共享的公共池,容量与你的业务无关,且会被别人占满
CompletableFuture.supplyAsync(() -> queryRemote(id));
// 推荐:显式指定业务自己的执行器,容量、拒绝策略与监控全部可控
CompletableFuture.supplyAsync(() -> queryRemote(id), orderQueryExecutor);
为公共池设置可观测。 即使不用它,也要监控它的活跃度——它的异常往往是别人代码的信号。必要时可以调整它的并行度,但这只是缓解,不是解决。
一个简单的原则:凡是不需要你传执行器就能异步的接口,都值得先确认它用的是哪一个池。

十一、生命周期:停机编排与框架替你创建的池
(一)停机编排:顺序错一步就丢一批任务
线程池的关闭不是一个孤立动作,它必须排在整条链路的正确位置上。关闭顺序错一步,就会在每次发版时丢一批任务——而这种损失通常是隐性的,因为没有人在统计它。
正确的编排是六步。
第一步,摘流量。 从注册中心下线,停止接收新请求。注意此时仍有在途请求,不能立刻关池。
第二步,停投递。 停止定时任务与消息消费,断掉任务的新增来源。
第三步,排队列。 调用 shutdown 并等待一个业务级期限。这个期限应当大于单任务耗时的高分位值,否则等待就是形式主义。
第四步,落剩余。 超时未完成则调用 shutdownNow,并把返回的未执行任务写进补偿表。
第五步,关依赖。 最后关闭连接池与客户端。顺序反了会让在途任务全部失败。
第六步,再退出。 确认终止后进程退出,并上报本次丢弃与补偿的数量。
有两个顺序错误特别常见。
错误一:先关依赖,再关业务池。 容器按 Bean 的销毁顺序关闭组件,连接池往往先于业务线程池被销毁。结果是在途任务全部因为拿不到连接而失败,而这些失败往往还没有补偿机制。这个问题在本地开发时完全看不出来,因为本地停机时通常没有在途任务。
错误二:关闭期限拍成一个小数字。 等待期限设成五秒,而单任务耗时的高分位是三十秒。结果是每次发版都强制中断一批任务,且由于强制中断路径上没有落档,丢失量既不可知也不可补。
把停机做对有三个验收标准。
可证明不丢:停机日志里必须打印已完成数、被中断数、已落档数,三者能对上账。可承受时长:总停机时长必须小于编排系统的强制终止期限,否则一切编排都是空谈——编排系统会在你还没走完流程时直接发送终止信号。可重复验证:在预发环境带着流量重启一次,检查上述三个数字是否符合预期。
发版频率越高,停机编排的价值越大:它把一个每周都在发生的隐性损失变成零。

(二)框架替你创建的四个线程池
自己创建的池会被评审,框架创建的池不会——事故因此更常出在后者。有四类框架池值得专门清点。
异步注解的默认执行器。 若未配置执行器,不同版本的默认行为不同:有的会为每次调用新建线程,有的使用一个核心数很小、队列无界的默认池。两种默认都不适合生产:前者线程数不受控,后者会无限堆积。做法是显式声明一个业务执行器并在注解上指定名称,禁止使用默认。
定时任务的默认调度器。 默认是单线程调度。一个任务跑超时,后面全部顺延。常见现象是某个每分钟执行的任务偶尔跑了十分钟,期间其他所有定时任务集体停摆,且没有任何报错——这类问题往往要到业务方发现某个数据没更新时才被察觉。做法是显式配置调度线程数,并给每个任务加执行超时保护。
Web 容器的工作线程池。 它的默认容量按通用场景给定,与你的下游容量无关。它是整个服务的接待能力上限,也是最外层的排队点。把它配得过大,等于把过载压力全部引进进程内部。做法是与业务池一起纳入容量账,入口容量应与后端容量相匹配。
中间件客户端的内部池。 消息客户端、远程调用框架、数据库驱动都自带线程池。它们的线程名往往与业务无关,故障时难以归因。参数通常可配,但很少有人去看默认值是多少。做法是清点这些池并纳入监控,至少要知道它们的容量与命名规则。
一条统一做法可以覆盖以上全部:所有执行器由一个工厂集中创建,业务代码不允许直接构造。 集中创建带来三个附赠:统一命名、统一监控、统一的上下文包装。这也是把本文前面所有单点做法真正落地的唯一可靠方式。

十二、虚拟线程:改变了什么,没改变什么
(一)三件事变了,四件事没变
虚拟线程是近年来 Java 并发模型上最大的一次变化,也很容易被过度解读。它解决的是"线程太贵"这一个问题,而本文讨论的其余问题一个都没有消失。
确实改变的三件事。
线程不再是稀缺资源:阻塞时不再占用平台线程,数量可以到十万级。阻塞型任务不用再算线程数:等待与计算比这个系数失去了意义,因为不再需要用有限的线程去覆盖等待时间。同步写法可以重新使用:不必为了省线程而把代码写成回调链,这对代码可读性是一次实质性的改善。
它的本质是把"一个请求一个线程"这种写法的成本降到了可以接受的水平。
完全没有改变的四件事。
下游容量仍然有限:连接池、对端线程、数据库连接数一个都没有变多。背压仍然必须显式做:线程便宜不等于可以无限发起并发调用。上下文仍然不会自动跟随:跨线程传递的三段模型依旧成立。计算密集型仍受核数限制:虚拟线程不会让 CPU 变多。
把这两组放在一起,可以得到一个略带反直觉的结论:虚拟线程把"线程数标定"这一个问题变简单了,却把"限流与背压"这个问题变得更重要。
原因很直接:在平台线程模型下,线程数本身就是一道天然的并发上限。你配了 30 个线程,那么无论上游怎么压,同时打到下游的请求最多 30 个。这道限制虽然粗糙,但它一直在保护下游。当这道限制消失之后,唯一的保护就只剩下你显式写出来的那一个。很多团队在迁移之后遇到的第一个问题不是虚拟线程本身,而是下游被瞬间打穿。
(二)迁移前必须确认的四件事
阻塞点是否会固定线程。 同步块内的阻塞会把虚拟线程钉在平台线程上,抵消掉全部收益。迁移前需要盘点热路径上的同步块,评估是否需要改造。
并发上限由谁来给。 必须显式加信号量或限流,否则下游会被瞬间打穿。这一条是迁移过程中最容易被忽略、后果也最严重的一条。
线程本地存储的用量。 十万个虚拟线程各存一份上下文,内存开销需要重新估算。原先几十个线程时可以随意存的东西,现在需要重新评估。
池化写法是否还需要。 虚拟线程不应该被池化——池化它没有意义,因为创建成本已经很低。但"限制并发"这个语义仍然需要保留,只是实现方式从"线程池大小"换成了"信号量许可数"。
由此给出一句可以直接用的判断:如果你的池是为了"省线程"而存在的,虚拟线程可以替换它;如果你的池是为了"限制并发"而存在的,那么迁移之后你仍然需要一个等价的限制器。
大多数业务线程池同时承担了这两个职责。迁移时需要先把它们拆开,分别处理。

十三、防线与门禁:把结论变成不会复发的规则
(一)四层防线各自能拦住什么
前面十二章给出了大量单点做法。要让它们不依赖个人记忆,需要把它们组织成四层防线,每一层拦住不同的东西。
第一层,类型与封装。 不暴露原始执行器,只暴露经过包装的提交接口。它拦住的是"绕过包装器直接提交"这一类问题——包括上下文不传、指标不埋、异常不收口。这一层的成本最低,收益最高,因为它把正确做法变成了唯一可走的路。
第二层,参数与配置。 所有池由统一工厂创建,参数带推导注释,启动时校验参数范围与线程总预算。它拦住的是"参数被随手改成一个不可辩护的值"。
第三层,静态检查。 把危险写法写成机器可判定的规则,在提交或构建阶段拦截。它拦住的是"新代码引入旧问题",而这正是治理工作最容易失守的地方——存量改完了,增量又流回来。
第四层,测试与演练。 把过载、拒绝、上下文一致性、停机不丢写成会失败的测试与定期演练。它是唯一能防复发的一层,因为前三层拦的都是"写法",而这一层验的是"行为"。
四层的关系是:前三层降低出错概率,第四层保证出错时能被立刻发现。任何一层缺失,其余三层的收益都会打折。
(二)十二条可以直接转成静态检查的门禁规则
按四类分组,每一条都能被机器判定或在评审清单里固化。
1、创建类
1.1 禁止使用工厂方法创建执行器
它们隐含无界队列或无上限线程数,是本文第四章重点批评的两种配置的主要来源。
1.2 线程工厂必须设置带业务含义的名字前缀
线程名是故障现场最便宜的信息来源。没有名字的线程栈几乎无法归因到某个具体的池。
1.3 执行器必须由统一工厂创建并注册
散落各处的池无法被统一监控与治理,也无法被统一包装。
2、容量类
2.1 队列必须显式指定容量
无界队列让最大线程数与拒绝策略同时失效,并把容量问题伪装成内存问题。
2.2 线程数与队列容量必须有推导注释
写明依据与取数时间,换人之后仍可维护,也让下一次调整有据可依。
2.3 进程线程总数必须有上限并被校验
各池核心数之和不得超过既定预算,启动时断言,超出直接失败。
3、行为类
3.1 拒绝策略必须显式指定且带计数
默认策略会把容量问题伪装成代码错误;没有计数的拒绝等于没有发生过。
3.2 禁止在容器入口线程上使用调用者执行策略
它会把一个异步旁路的过载升级成主链路故障。
3.3 跨线程提交必须走带上下文包装的执行器
禁止把裸任务直接交给执行器,这一条同时解决上下文、指标与异常三个问题。
4、可观测类
4.1 九个指标必须齐全并带池名标签
缺任意一个都会在故障时留下盲区;不带池名标签的聚合指标在排查时没有用处。
4.2 任务异常必须有明确归宿
禁止 submit 之后既不取结果也不处理异常;组合式异步链必须有终端异常处理。
4.3 关闭流程必须完整且可证明不丢
三步关闭加剩余任务落档,停机日志三个数字能对账。
十二条里有九条可以被静态检查直接判定,剩下三条需要在代码评审清单里固化。

(三)三阶段落地
一次性推完十二条规则不现实,合理的节奏是三个阶段。
第一阶段,止血,以周为单位。 只做两件事:消除全部无界队列,补齐拒绝计数与排队时延两个指标。前者消除最严重的一类风险,后者建立最基本的可见性。这个阶段不要求任何参数变得"正确",只要求风险变得"可见"。
第二阶段,建立可见性与统一形态,以月为单位。 补齐九个指标,把执行器收敛到统一工厂,把上下文包装接进去,把线程总预算算清楚。这个阶段结束时,团队应该能回答"这个进程里有多少个池、每个池在干什么、它们现在健康吗"。
第三阶段,参数辩护与演练,以季度为单位。 逐个池走一遍四步标定法,把依据写进注释;在预发环境做过载演练与停机演练;把十二条规则接入静态检查。这个阶段结束时,团队应该能回答"每一个参数为什么是这个值,改了会怎样"。
三个阶段的顺序不能换。没有可见性时做参数标定,得到的是没有依据的数字;没有统一形态时做静态检查,规则会被大量豁免掏空。
十四、十四条高频误区
下面这些说法都有一个共同点:听起来都很合理。而它们每一条都对应一次真实发生过的线上问题。
线程数按核数乘二配就行——没有区分任务性质,也没有考虑下游容量与进程内其他池。
最大线程数配大一点更安全——队列没满时它根本不会被读到,配得再大也不会生效。
队列配大一点就不会丢任务——任务没丢,只是在队列里等到超时,最后一样白跑。
用无界队列可以避免拒绝——它把拒绝换成了内存溢出,代价高出两个数量级。
拒绝异常说明系统出故障了——拒绝是容量保护正在生效,真正的故障是从不拒绝。
调用者执行策略是安全的兜底——在入口线程上使用它,会把服务的接待能力吃光。
submit 比 execute 更规范——不取结果时用 submit,会让全部异常静默消失。
异步任务里能读到当前用户——线程本地存储不跨线程,读到的可能是别人的值。
上下文传递用可继承的那个就够了——线程池复用线程时复制根本不发生,还会串号。
任务结束时记得清理就行——抛异常时清理不会执行,污染会永久留在线程上。
超时返回了任务就停了——中断只是请求,网络读与纯计算都不会因此停下。
加了监控就等于可观测——只测执行时延而不测排队时延,等于没测线程池。
并行流很方便,随手就能用——它用的是全进程共享的公共池,会互相影响。
停机时调一下 shutdown 就够了——不等待、不落档,每次发版都在悄悄丢任务。
这十四条里有九条的根源是同一个误解:把线程池当成了一个"加速器",而它其实是一个准入与排队系统。加速器的心智模型会自然地导向"配得越大越好",而排队系统的心智模型会导向"先算清楚容量、再决定满了怎么办"。
拿这十四条对照自己的代码库,通常能在半天内找到三到五处。

十五、一页纸速查与三条结构性解释
(一)从一次提交到一次复盘的全流程
把全文压缩成一张可以贴在工位上的图,它按五个阶段组织。
配置阶段要回答四个问题:这批任务是什么性质(计算密集、阻塞等待还是混合,混合的先拆开再配);线程数从哪算出来(到达率乘服务时间,再与下游容量取小);队列能等多久(可接受排队时延除以服务时间再乘并行度,再用内存预算夹一次);满了之后怎么办(拒绝、降级、落补偿表,三选一,必须显式写出)。
编码阶段要收口三个位置:上下文(捕获在提交时、回放在执行前、还原写在 finally 里);异常(包装器统一捕获、计数、打日志,不取结果就不要用 submit);超时(每一层都要有自己的超时,取消之后的副作用要收口)。
上线阶段要有九个指标与三条告警线。三条告警线分别是:队列容量占比超过七成、排队时延分位数超过上游超时的一半、拒绝计数从零变为非零。
故障阶段先看堆积形状,再切三个指标,最后按止血、归因、恢复、复盘的顺序处置。
验收阶段有四条可以逐项打勾的标准:参数可辩护(每个参数都能说出来源与推导);过载可预期(预发环境真实触发过一次拒绝);失败可见(任意一次任务异常都会出现在告警里);停机可证明(完成数、中断数、落档数三者对账)。

(二)为什么这类问题长期高发
最后回答一个结构性问题:线程池的用法已经被讨论了十几年,为什么相关事故仍然层出不穷。有三条解释。
第一,它的错误配置在开发环境永远表现正常。 无界队列在本地不会堆积,因为本地没有流量;上下文串号在本地不会发生,因为本地只有一个请求在跑;停机丢任务在本地看不出来,因为本地停机时没有在途任务。所有这些问题都需要"并发 + 持续时间 + 真实流量"三个条件同时具备才会显现,而这三个条件只在生产环境同时存在。这意味着常规的测试与评审天然拦不住它们,必须靠专门设计的演练。
第二,它的正确做法需要跨越三个知识领域。 线程数标定属于排队论,队列与拒绝属于流量控制,上下文传递属于运行时机制,停机编排属于分布式系统的生命周期管理。任何一个领域的知识缺口,都会在对应的环节留下一个洞。而这四个领域通常分属不同的学习路径,很少有人会主动把它们串起来。
第三,也是最根本的一条:它的默认值都是"看起来能用"的。 不设拒绝策略,默认抛异常,能用;不设线程名,默认自动编号,能用;不设队列容量,默认无界,也"能用"。每一个默认值单独看都不算错,它们只是把成本推迟到了流量上来的那一天。而"能用"是一种非常强的假象——它让所有这些决策都不会在评审中被提出来讨论。
这三条解释指向同一个结论:这类问题不能靠个人经验解决,只能靠把口径写进类型、把规则写进检查、把行为写进演练。这也是本文用十二条门禁规则和四层防线收尾的原因——因为一次修好并不难,难的是让它不再回来。
参考资料
语言与运行时规范
- ThreadPoolExecutor 官方文档:七个构造参数与判定顺序的权威说明
- Executors 工厂类文档:注意其中固定大小池与单线程池的队列说明
- BlockingQueue 接口文档:六种队列实现的语义差异
- ExecutorService 关闭语义:shutdown 与 shutdownNow 的行为边界
- CompletableFuture 文档:带执行器与不带执行器的重载差异
- ForkJoinPool.commonPool 说明:并行流与默认异步使用的公共池)
- Thread.interrupt 文档:中断在不同阻塞状态下的实际行为)
- ThreadLocal 与 InheritableThreadLocal:复制时机的官方描述
虚拟线程与并发模型演进
- JEP 444:虚拟线程正式特性说明
- JEP 425:虚拟线程的首个孵化提案,含设计动机
- JEP 453:结构化并发提案,处理任务生命周期与取消传播
- JEP 446:作用域值,虚拟线程时代的上下文传递机制
- Oracle 官方虚拟线程使用指南:包含 pinning 与迁移注意事项
并发与容量的理论基础
- Little's Law 综述:并发度、到达率与服务时间的关系
- Universal Scalability Law:为什么加线程会在某一点之后降低吞吐
- Amdahl 定律:串行部分对并行加速比的限制
- Little's Law 在连接池与线程池容量计算中的应用(HikariCP 池大小说明)
背压、限流与过载保护
- Google SRE Book:过载处理与优雅降级
- Google SRE Book:级联故障的成因与预防
- Reactive Streams 规范:背压的形式化定义
- Resilience4j 舱壁隔离文档:线程池隔离与信号量隔离的对照
- Netflix Hystrix 设计文档:线程池隔离的经典实践与经验总结
- Netflix concurrency-limits:自适应并发限制的实现与原理
上下文传递
- TransmittableThreadLocal 项目文档:池化场景下的上下文传递方案
- Micrometer Context Propagation:跨线程与响应式场景的上下文传播
- OpenTelemetry Java 上下文传播文档:链路上下文的跨线程处理
- SLF4J MDC 文档:日志诊断上下文在异步场景下的注意事项
框架与工程实践
- Spring 异步执行与调度:执行器配置与默认行为说明
- Spring Boot 优雅停机配置文档
- Spring ThreadPoolTaskExecutor 参数映射与 TaskDecorator 用法
- Tomcat 连接器线程池配置参考
- Micrometer 官方文档:ExecutorServiceMetrics 提供的线程池指标
- DynamicTp:支持运行期调参与监控告警的动态线程池组件
- Hippo4j:另一款动态线程池方案,含队列容量可变实现
规范与检查规则
- 阿里巴巴 Java 开发手册:并发处理章节的线程池强制规约
- SpotBugs 多线程检查规则清单
- Error Prone 并发相关检查项:可用于构建期拦截危险写法
- OpenJDK 线程栈与线程状态诊断工具 jstack 使用说明
转载自 CSDN-专业IT技术社区
原文链接:https://blog.csdn.net/xiaofeng10330111/article/details/166601743




