张彦峰ZYF头像
提交成功不等于开始执行:Java 线程池的线程数标定、队列选型、拒绝策略、堆积治理与上下文传递封面图

提交成功不等于开始执行:Java 线程池的线程数标定、队列选型、拒绝策略、堆积治理与上下文传递

目录

一、提交成功到底承诺了什么?

(一)execute 返回之后,四件事都没有被保证

1、没有保证这个任务会被执行

2、没有保证这个任务什么时候被执行

3、没有保证执行时的环境与提交时相同

4、没有保证失败会被人看见

(二)一个队列切断的四条因果链

1、时间因果:提交时刻不再等于执行时刻

2、调用栈因果:抛出的异常没有上游可去

3、上下文因果:线程本地存储不会跟着任务走

4、背压因果:提交方感受不到执行方的慢

(三)为什么"线程池调优"这个说法把问题带偏了

(四)真正要覆盖的八件事

(五)动手之前先算出来的七个数

1、进程里的线程池个数

2、线程总数与常驻线程数

3、无界队列的池个数

4、排队时延的分位数

5、拒绝次数与丢弃次数

6、跨线程上下文的种类数

7、任务异常的可见率

二、执行语义:七个参数背后只有一条判定链

(一)一次提交要过的四道关口

(二)判定顺序带来的三个反直觉后果

1、最大线程数常常是一个死参数

2、无界队列让两个参数同时失效

3、核心线程数才是常态并发度

(三)核心线程、最大线程与存活时间怎么配

(四)线程池的五个状态:关闭是一个过程

(五)execute 与 submit:异常的两条不同去向

三、线程数标定:把一个抄来的数变成一个可辩护的数

(一)先分清三类任务,再谈数字

(二)用排队论把并发度算出来

(三)等待与计算的比值怎么测

(四)四步标定法与吞吐拐点

(五)上界不是公式给的,是下游给的

四、队列选型:队列不是缓冲区,是延迟的储存罐

(一)六种队列的语义对照

(二)无界队列:把容量问题伪装成内存问题

(三)队列容量用延迟预算倒推

五、拒绝策略:拒绝不是故障,是容量保护在生效

(一)四种内置策略把压力推给了谁

(二)调用者执行策略:它是背压,不是兜底

(三)自定义策略要做的五件事,以及与限流降级重试的分工

六、任务堆积:从形状到根因到处置

(一)堆积的四种形状

(二)六类根因与三个指标的切分

(三)现场处置顺序:止血、归因、恢复

(四)四段时延:排队时延为什么必须单独埋

七、上下文传递:跨线程丢的不只是链路号

(一)线程本地存储为什么不跟随任务

(二)可继承的那个为什么在池化下必然失效

(三)捕获、回放、还原:三段模型

(四)五类必须搬运的上下文

(五)不还原比不传递更危险

八、失败收口:异常、超时与取消

(一)任务失败的五条去向

(二)超时与取消:中断只是一个请求

九、可观测:九个指标与它们各自回答的问题

(一)必须暴露的九个指标

(二)动态调参:可调什么,不可调什么

十、隔离与共享:一个池不能装两种任务

(一)共池的传导链与切池的四条判据

(二)你没有创建却正在使用的公共池

十一、生命周期:停机编排与框架替你创建的池

(一)停机编排:顺序错一步就丢一批任务

(二)框架替你创建的四个线程池

十二、虚拟线程:改变了什么,没改变什么

(一)三件事变了,四件事没变

(二)迁移前必须确认的四件事

十三、防线与门禁:把结论变成不会复发的规则

(一)四层防线各自能拦住什么

(二)十二条可以直接转成静态检查的门禁规则

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 任务异常必须有明确归宿

4.3 关闭流程必须完整且可证明不丢

(三)三阶段落地

十四、十四条高频误区

十五、一页纸速查与三条结构性解释

(一)从一次提交到一次复盘的全流程

(二)为什么这类问题长期高发

参考资料


干货分享,感谢您的阅读!

把一段代码交给线程池,方法立刻返回,没有异常,日志干净。这一刻你以为自己完成了一次调用,实际上你只是完成了一次投递。会不会被执行、什么时候被执行、执行时还能不能看见调用者的身份、失败之后有没有人知道——这四件事,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);超时(每一层都要有自己的超时,取消之后的副作用要收口)。

上线阶段要有九个指标与三条告警线。三条告警线分别是:队列容量占比超过七成、排队时延分位数超过上游超时的一半、拒绝计数从零变为非零。

故障阶段先看堆积形状,再切三个指标,最后按止血、归因、恢复、复盘的顺序处置。

验收阶段有四条可以逐项打勾的标准:参数可辩护(每个参数都能说出来源与推导);过载可预期(预发环境真实触发过一次拒绝);失败可见(任意一次任务异常都会出现在告警里);停机可证明(完成数、中断数、落档数三者对账)。

(二)为什么这类问题长期高发

最后回答一个结构性问题:线程池的用法已经被讨论了十几年,为什么相关事故仍然层出不穷。有三条解释。

第一,它的错误配置在开发环境永远表现正常。 无界队列在本地不会堆积,因为本地没有流量;上下文串号在本地不会发生,因为本地只有一个请求在跑;停机丢任务在本地看不出来,因为本地停机时没有在途任务。所有这些问题都需要"并发 + 持续时间 + 真实流量"三个条件同时具备才会显现,而这三个条件只在生产环境同时存在。这意味着常规的测试与评审天然拦不住它们,必须靠专门设计的演练。

第二,它的正确做法需要跨越三个知识领域。 线程数标定属于排队论,队列与拒绝属于流量控制,上下文传递属于运行时机制,停机编排属于分布式系统的生命周期管理。任何一个领域的知识缺口,都会在对应的环节留下一个洞。而这四个领域通常分属不同的学习路径,很少有人会主动把它们串起来。

第三,也是最根本的一条:它的默认值都是"看起来能用"的。 不设拒绝策略,默认抛异常,能用;不设线程名,默认自动编号,能用;不设队列容量,默认无界,也"能用"。每一个默认值单独看都不算错,它们只是把成本推迟到了流量上来的那一天。而"能用"是一种非常强的假象——它让所有这些决策都不会在评审中被提出来讨论。

这三条解释指向同一个结论:这类问题不能靠个人经验解决,只能靠把口径写进类型、把规则写进检查、把行为写进演练。这也是本文用十二条门禁规则和四层防线收尾的原因——因为一次修好并不难,难的是让它不再回来。

参考资料

语言与运行时规范

虚拟线程与并发模型演进

并发与容量的理论基础

背压、限流与过载保护

上下文传递

框架与工程实践

规范与检查规则

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/xiaofeng10330111/article/details/166601743

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--