从 MQ 积压查出 4000 个线程:不是泄漏,是事件总线的设计代价

0 阅读15分钟

📝 摘要:一次 RocketMQ 消息积压告警,诱因是一台消费实例的机器故障;排查时却在另一台上查出 3950 个线程,整机 free 只剩 335M,1 ~ 3 秒一次 YGC。用 top/jstat/jinfo/jmap/jstack 分组统计,靠线程名后缀反推架构:约 120 个 @RemoteEvent 各自注册 Consumer,有消息的 60 个各占满 20 个消费线程。结论是设计代价而非泄漏;后来关掉 trace、消费线程默认降到 2 个,线程降到 1200 左右,CPU 空闲多 14 个点。

早上 7:40 钉钉炸了:「RocketMQ 消息积压触发告警」。

上机器一看 top——java 进程 150% CPU、4.3G 内存、整机 free 仅 335MB。

我以为这是个 RocketMQ 客户端泄漏的剧本,跟一个月前那个 LangFuse 线程泄漏一模一样。结论是错的。

4000 个线程不是泄漏——是设计的代价。从消息积压到揭开整个事件总线设计,这次排查跨越了 5 个工具、3 个反推公式、1 次大型自我打脸。

这篇讲怎么用线程名后缀反推系统架构,以及怎么避免把「设计选型」误判成「代码 bug」。


一、问题现象:MQ 积压只是个开始

7:40 起,告警一条接一条:

RocketMQ 消息积压        触发告警
开始时间: 07:40:00

【P1】线程池[biz-async-task] 任务队列堆积
当前值: 5063 → 13948 (3 分钟内翻倍)
阈值: 0

存活监控告警
- ai-service-A: 8m42s 失活
- gateway-2: 3m42s 失活
- consumer-2: 6m42s 失活

回头看大盘,积压本身的来龙去脉很清楚:

  • 7:36,consumer-2 先开始变慢:定时任务耗时从 1 秒涨到 8 秒,内部线程池队列一路上涨;
  • 7:38,积压出现,每隔一两分钟冲到七八千条;
  • 8:40 前后,consumer-2 彻底失联,同一时段云厂商也发了实例和云盘性能下降的故障通告;
  • 9:10 左右,新起一台机器、拷上同一个 jar 顶替 consumer-2,告警陆续恢复。

最难受的是 consumer-2 半死不活的那一个小时:RocketMQ 集群消费是按队列分给实例的,它还在消费组里,分给它的队列就一直归它,可它消费不动,消息就堆在这几个队列里。等它彻底失联、触发重平衡,队列才被另一台接走。所以积压的解法是尽快把坏实例停掉、摘出消费组,再补一台,加线程没用。

但上另一台 consumer-1 看的时候,我发现了更扎眼的东西:它没出故障,却带着 3950 个线程,整机 free 只剩 335M。这两天它一直带着这么多线程跑,积压却是今早 consumer-2 坏了才出现的——它不是这次的病因,是一颗一直埋着的雷。下面查的都是这台。


二、第一层排查:top 找进程 → top -Hp 找线程

2.1 进程级 top

top - 09:12:56 up 638 days,  load average: 2.25, 3.16, 2.95
Tasks: 277 total
%Cpu(s): 27.9 us, 16.2 sy, 0.0 ni, 52.9 id, 0.0 wa, 2.9 si

MiB Mem : 7727 total, 335 free, 6058 used, 1332 buff/cache
MiB Swap: 0 total, 0 free, 0 used

  PID USER  %CPU  %MEM   COMMAND
14751 app   150.0 57.3   java

三个反常点:

信号含义
单进程 150% CPU多线程在烧
单进程占系统 57% 内存4.3G / 7.7G,一个进程就吃掉一大半
整机 free 仅 335M已用 6.0G(78%),连 1.3G 缓存算上余量也不到 2G,而且没有 swap 兜底

2.2 钻进进程:top -Hp <pid>

$ top -Hp 14751
Threads: 3950 total, 5 running, 3945 sleeping
%Cpu(s): 38.1 us, 15.7 sy, 44.2 id

   PID  %CPU  %MEM  TIME+      COMMAND
164540  15.9  57.3  95:37.92   java
164501  13.3  57.3  37:04.10   java
166839  12.3  57.3   9:42.57   java
166914   5.2  57.3  21:20.62   java

3950 个线程,是我至今见过最大的数字。最热的线程也才 16%,没有一个打满一核的热点——这是个「分布式吃 CPU」的特征:大量线程各占一点点,加起来 CPU 就上去了。

2.3 反推热点:把 nid 喂回 jstack

$ printf '%x\n' 164501
28295

$ jstack 14751 | grep '28295' -A 2
"Gang worker#0 (G1 Parallel Marking Threads)" os_prio=0 nid=0x28295 runnable

热点 #2 是 G1 GC 标记线程。再看一眼,热点 #4-#10 里好几个是 G1 Concurrent Refinement Thread —— GC 在持续 marking。

到这里我已经有个初步判断:不是业务死循环,是 GC 一直在忙。但比 GC 更扎眼的,是那 3950 个线程。


三、第二层排查:jstat + jinfo 看 GC 与堆配置

3.1 jstat:GC 频率高得吓人

$ jstat -gcutil 14751 1000 10
  S0    S1     E      O      M     CCS    YGC    YGCT    FGC   GCT
  0.00 100.00 33.80  59.43  91.25  87.13  11815  207.68    0   207.68
  0.00 100.00 57.75  59.43  91.25  87.13  11815  207.68    0   207.68
  0.00 100.00 90.14  59.43  91.25  87.13  11815  207.68    0   207.68
  0.00 100.00 27.78  60.08  91.26  87.15  11817  207.71    0   207.71
  0.00 100.00 91.67  60.08  91.26  87.15  11817  207.71    0   207.71
  0.00 100.00 36.11  60.08  91.31  87.22  11818  207.73    0   207.73

读数:

指标实测解读
E 33% → 91% 反复6 秒内 +3 次 YGC1 ~ 3 秒就一次 YGC,频率非常高
O 60% 缓慢上涨老年代逐步累积大量对象提前晋升到老年代
YGCT=207s累计 1.18 万次、207 秒单次只要约 18ms——停顿不长,烦的是频率
FGC=0没发生过 Full GCG1 还在勉强支撑

3.2 jinfo:GC 配置在跟业务对着干

$ jinfo -flags 14751 | tr ' ' '\n' | grep -E 'Xmx|GC|Heap'

-Xms3G  -Xmx3G
-XX:+UseG1GC
-XX:G1HeapRegionSize=16m
-XX:InitiatingHeapOccupancyPercent=30   ← 堆占用过 30% (≈900MB) 就启动并发标记
-XX:ConcGCThreads=1                      ← 只给 1 个并发标记线程
-XX:G1ReservePercent=25

老年代已经 60%,远超 IHOP=30% 的门槛——并发标记几乎一轮接一轮,而干这活的只有 1 个并发标记线程,这正是 top -Hp 里 G1 标记线程挂在热点上的原因。这不是 GC 病了,是 GC 资源被严重低估了。

GC 为什么这么忙,得去找是谁在大量分配对象;但比它更扎眼的,还是那 3950 个线程。继续往下挖。


四、第三层排查:jmap histo 看内存大户

$ jmap -histo:live 14751 | head -30

 num     #instances         #bytes  class name
   1:    1202279      363604408   [C
   2:     324769      255772808   [Ljava.lang.Object;
   3:     131430       86218080   io.netty.util.internal.shaded.org.jctools.queues.MpscArrayQueue
   4:      32321       35045304   [B
   5:    1339245       32141880   java.lang.String
   ...
   9:     232860       11177280   org.aspectj.weaver.reflect.ShadowMatchImpl
  12:     232860        7451520   org.aspectj.weaver.patterns.ExposedState
  ...
  23:     121320        3882240   io.netty.buffer.PoolThreadCache$SubPageMemoryRegionCache

两个数字特别扎眼:

4.1 13 万个 Netty 队列 + 12 万个线程缓存

MpscArrayQueue 13.1w + PoolThreadCache$SubPageMemoryRegionCache 12.1w。

这两个是一回事:Netty 给每个在池化分配器上分配过内存的线程配一份 PoolThreadCache,里面每个规格档位一个缓存,每个缓存背后一个 MpscArrayQueue。关键算式:

SubPage 档缓存   121,320 ÷ 36 档/份(tiny 32 + small 4,Netty 4.1.52 之前的默认)= 3,370 份
Normal 档缓存     3,370 份 × 3 档 = 10,110
121,320 + 10,110 = 131,430 = MpscArrayQueue 总数 ✓

一个都不差,说明这 13 万个队列全是线程缓存。3370 份线程缓存,和 3950 个线程是同一个量级——每多一个线程,就多一份几十个档位的缓存(堆内、堆外两种 arena 都用上时每线程两份,线程数要再减半)。

4.2 23 万个 AspectJ 切点匹配对象

ShadowMatchImpl: 232,860 + ExposedState: 232,860,1:1 严格配对。

这是 Spring AOP 的切点匹配缓存(AspectJExpressionPointcut 里的 shadowMatchCache):按「方法 × 切点」各存一份匹配结果,启动建代理时算好、之后常驻。合计约 18MB,是常驻内存,不是喂 YGC 的临时对象。

但这条还是配角。主咖仍然是那个 3950 线程。


五、关键转折:Grafana 揭示了一个反常事实

到这里有个困惑:线程数为啥不降?

跑去看 Grafana 近 2 天的线程曲线([live + daemon + peak] 三条线叠图):

live :  3.9K ━━━━━━━━━━━━━━━━━ 2 天稳定在 3.9K,重启后立刻爬升回来
daemon: 431  ━━━━━━━━━━━━━━━━━ 几乎不变
peak :  3.9K ━━━━━━━━━━━━━━━━━ 跟 live 完全重合

live ≈ peak 这条规律 2 天没破过。

正常应用 peak 会比 live 高很多——高峰期创建一批线程,闲时回收一部分。这里 live = peak 意味着:

线程池常态保持在最大线程数。要么是池配的 fixed,要么是负载持续到所有池都满载、没有空闲触发回收。

更进一步:non-daemon 线程数 = live - daemon = 3470 个——绝大部分是业务侧和中间件客户端的线程池起的。

现在唯一的问题是:3470 个 non-daemon 线程到底是哪些?


六、决定性的一步:从线程名后缀反推架构

到这步如果还按「客户端泄漏」的思路找代码,是大海捞针。换个思路:让 jstack 自己说话——按线程名分组统计。

6.1 一行命令分组统计

# 取出线程名,UUID 换成 <id>、数字换成 N,再计数
$ jstack 14751 | grep -oE '^"[^"]+"' | tr -d '"' \
    | sed -E 's/[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}/<id>/; s/[0-9]+/N/g' \
    | sort | uniq -c | sort -rn | head -20

 1200  ConsumeMessageThread_N
  700  MQTraceSendThread_N
  300  event-executor-N
  280  AsyncSenderExecutor_N
  200  biz-async-task-N
  140  RequestHouseKeepingService
  140  CleanExpireMsgScheduledThread_N
  140  MQ-AsyncTraceDispatcher-Thread-<id>
   80  pool-N-thread-N   ← 匿名池
   37  Thread-N          ← 匿名 Thread
   ...

光列出来的 6 类 RocketMQ 线程就有 2600 个,占了 2/3。而且每类都是整十整百的数——像是很多个客户端实例各开了一套同样的池。

6.2 反推公式:从后缀分布看实例数

进一步看 ConsumeMessageThread_<i> 的后缀:

$ jstack 14751 | grep -oE 'ConsumeMessageThread_[0-9]+' \
    | sed -E 's/^.*_([0-9]+)$/\1/' | sort -n | uniq -c

  60 1
  60 2
  60 3
  ...
  60 19
  60 20      ← 后缀范围 1 ~ 20,每个出现约 60 次

重点来了——每个 Consumer 的消费池核心线程数是 consumeThreadMin(默认 20),线程独立编号 1 ~ 20。所以:

后缀 i=1 出现的次数 = 起过消费线程的 Consumer 数 = 60 个

60 × 20 = 1200,正好等于 ConsumeMessageThread 总数 ✓

但 60 还不是 Consumer 总数:消费线程是来了消息才创建的,没收过消息的 Consumer 一个都不起。总数要看 CleanExpireMsgScheduledThread——每个 Consumer 一启动就有一个,140 个。也就是说这个进程里有 140 个独立的 RocketMQ Consumer,其中 60 个收到过消息。

同样手法看消息轨迹(trace)的发送线程:

$ jstack 14751 | grep -oE 'MQTraceSendThread_[0-9]+' \
    | sed -E 's/^.*_([0-9]+)$/\1/' | sort -n | uniq -c

  70 1
  70 2
  ...
  70 10      ← 70 个发过轨迹的客户端 × 10 trace 线程 = 700 ✓

开了 trace 的客户端,不管是 Producer 还是 Consumer,都会自带一个 AsyncTraceDispatcher:1 个分发线程,加一个 10 线程的发送池和一个内部 trace Producer。剩下几行就都对上了:

  • MQ-AsyncTraceDispatcher-Thread 140 个——和 Consumer 数一样,140 个 Consumer 全开了 trace;
  • MQTraceSendThread 也是有轨迹要发才创建,70 个发过轨迹的客户端,和有消费的 60 个 Consumer 大体对得上(业务 Producer 的 trace 在配置里是关的);
  • RequestHouseKeepingService 是每个 Producer 一个(构造时就起),140 个基本就是 140 个内部 trace Producer;
  • AsyncSenderExecutor 是内部 trace Producer 异步发送用的,每个 4 线程(= CPU 核数),70 × 4 = 280。

顺带排除一个怀疑:这么多客户端,MQClientInstance 是不是也裂成了几百份?没有。没配 ACL 时 rocketmq-spring 不改 instanceName,进程内的 Consumer 共用一个实例——不然每个实例还要再带一个内部 Producer,RequestHouseKeepingService 就不止 140 了。

到这里我以为找到泄漏了——肯定是 Producer/Consumer Bean 没单例化,每次注入都新建一个。

这个判断错了。


七、原来不是 bug 是 feature:揭开事件总线设计

抓代码 grep -rn "DefaultMQPushConsumer\|DefaultMQProducer" .,找到这么一段:

@Configuration
public class RemoteEventListenerAutoCreator
        implements ApplicationContextAware, SmartInitializingSingleton {

    @Override
    public void afterSingletonsInstantiated() {
        // 启动时遍历所有 @RemoteEvent 注解 Bean
        Map<String, Object> beans = applicationContext
            .getBeansWithAnnotation(RemoteEvent.class);

        beans.forEach((beanName, instance) -> {
            String tag   = beanName + "_tag";
            String group = beanName + "_group_" + suffix;
            String topic = beanName + "_" + suffix;

            // 给每个 Bean 注册一个独立的 DefaultRocketMQListenerContainer
            // → 每个 Container 内部一个 DefaultMQPushConsumer
            registerBean(containerName, DefaultRocketMQListenerContainer.class,
                () -> buildContainer(topic, tag, group));
        });
    }
}

读完这段代码的时候我在工位上沉默了 5 秒。

这不是泄漏,是设计。

启动时扫描所有 @RemoteEvent 注解 Bean,给每个 Bean 自动注册一个独立的 RocketMQ Consumer Container(独立 topic / group / tag)。这是个典型的「远程事件总线」实现——业务代码只需要在事件 Bean 上加注解,Consumer 自动创建、订阅、消费。

项目里有约 120 个 @RemoteEvent Bean → 启动时自动注册约 120 个 Container,加上约 20 个手写的 @RocketMQMessageListener,正好凑成那 140 个 Consumer → 有消息的 60 个各起满 20 个消费线程 → 1200 个 ConsumeMessageThread 是设计的代价。

设计目的是事件按业务隔离 topic + 不同 consumer group 各自维护 offset,避免一个慢消费拖累其他事件。代价是线程数随 @RemoteEvent Bean 数量线性增长。

回到 Grafana 那个 live = peak 的现象:RocketMQ 消费池的核心线程数就是 consumeThreadMin(20),核心线程不会超时回收——有消息的 60 个 Consumer,线程起来了就不退,所以 live 永远等于 peak。不是泄漏,是 60 套池子各自常驻。


八、重新定位优化方向

既然不是泄漏,「找 leak 修代码」这条路就废了。但优化空间还有,按收益从高到低排:

优化点实现预计收益
关闭低 QPS 事件的 trace@RocketMQMessageListener 默认开 trace,按事件关 enableMsgTrace每关一个省 1 个分发线程 + 1 个内部 Producer,发过轨迹的再省 10 + 4 个;全关约 1260 个
调小单 Consumer 线程数在 RemoteEventListenerAutoCreator 里显式 setConsumeThreadMin(8)(Max 同设 8)。⚠️ 只调 Max 没用:消费池用的是无界队列,线程数永远停在 Min60 × 8 = 480 → 砍掉 ~720 ConsumeMessageThread
合并低频事件到同 topic 用 tag 区分改 @RemoteEvent 注解定义减少 Container 数(架构改动)

按客户端源码推算,前两项叠加能从 3950 砍到 2000 左右,省下的是堆外内存:每个线程的栈、Netty 线程缓存。后来线上真这么改了,而且改得更狠:trace 全关,消费线程默认降到 2 个,只有十来个高频事件单独给 8 ~ 32 个。同一个 Arthas thread --all 前后各拍一次,总线程 3755 → 1185,日均 CPU 空闲从 59% 涨到 74%。两项是同一批上线的,分不清各占多少。

但别指望它治 GC:VM Thread(JVM 协调 GC 和 safepoint 的线程)改前改后都在约 23% 的采样里冒头成高 CPU 线程,一点没少,分配大户另有其人。

至于 GC 配置(ConcGC=1 → 2 ~ 4、IHOP=30% → 45 ~ 50%),可以同步调整——但它治的是「标记跟不上」,治不了「分配太多」。


九、举一反三:从这次诊断里能沉淀什么

9.1 线程名后缀反推架构 —— 通用方法

任何用线程池的中间件,线程命名规则都隐含着内部结构。掌握几个常见公式:

中间件线程命名规则反推公式
RocketMQ ConsumerConsumeMessageThread_<i>i 范围 = consumeThreadMin;i=1 出现次数 = 收到过消息的 Consumer 数(总数看 CleanExpireMsgScheduledThread,每个 Consumer 一个)
RocketMQ traceMQTraceSendThread_<i>i 范围 = trace 池大小(10);i=1 出现次数 = 发过轨迹的客户端数
NettynioEventLoopGroup-<g>-<i>g = EventLoopGroup 实例编号;i 范围 = 该 group 线程数
Tomcathttp-nio-<port>-exec-<i>i 范围 = maxThreads;port 数 = 监听端口数
Kafkakafka-producer-network-thread | <client-id>client-id 数 = Producer 实例数
任意 ThreadPoolExecutorpool-<N>-thread-<M>N 是池序号,N 数 = 匿名池总数

口诀:看到大量同前缀线程时,先 grep -oE 抓后缀分布,后缀的最大值 × 后缀=1 的出现次数 ≈ 该类线程总数——这告诉你有几个实例在干活。池子是按需起线程的,闲着的实例不出现在这里,总数要找「每个实例启动就有一个」的线程来数。

9.2 警惕「看似泄漏,实为设计代价」

写完 LangFuse 那篇线程泄漏复盘后,我下意识觉得「线程数大 = 泄漏」。这次差点就掉进去。

但实例数多本身分不出是设计还是泄漏——泄漏出来的客户端,后缀一样是 1 ~ 20 整整齐齐。真正的判据是会不会涨:

线程数大
   ├─ 稳定在一个水位(重启后爬回同一水位就不再涨)→ 大概率是设计代价(多实例 × 池大小)
   │     └─ 数出实例总数,和代码里应有的数量对账(本文:约 120 个 @RemoteEvent Bean + 约 20 个手写 Listener = 140)
   └─ 随时间单调上涨、重启后又从头涨 → 大概率是泄漏
         └─ MAT 看 GC Roots 找引用源

9.3 多数据源交叉验证才靠谱

这次排查涉及 6 个数据源,缺一不可:

数据源关键贡献
top / top -Hp锁定进程 + 热点线程(GC marking 提示了「对象产出过快」)
jstat量化 GC 频率和老年代水位
jinfo看 GC 配置和启动参数
jmap histo内存大户里的 Netty 线程缓存,数量和线程数同一量级
Grafana 历史曲线live = peak 揭露了「线程不退」
jstack 分组统计决定性的反推架构步骤

任何一个工具单独看都不够。真正破案的是跨数据源的算式对应:jmap 算出 3370 份线程缓存,top -Hp 看到 3950 个线程,jstack 按后缀算出「60 × 20 = 1200、70 × 10 = 700……」——几个数字互相印证,结论才稳。


十、总结

维度改前改后(线上实测)
总线程数3755 ~ 39501185
日均 CPU 空闲59%74%
VM Thread 在高 CPU 采样里出现的比例(GC / safepoint)23%23%,没动

核心教训:

  1. 告警指向的,和你顺手查出来的,不一定是一回事——积压是坏机器造成的,3950 个线程是另一台上埋着的雷,要分开处理
  2. 不要想当然套用「上一次问题」的诊断模板——这次跟 LangFuse 那次表面像,根因完全不同
  3. 看似简单的线程命名隐藏着架构信息——会读就是免费的代码考古工具
  4. 设计代价不是 bug,但仍可优化——一个事件总线设计能开 120 个 Consumer 不是错,每个 Consumer 都吃默认的 20 个线程、不按流量调才是错
  5. 多工具交叉,让数字互相印证——不要只信一个数据源,三个数字对得上的结论才可靠

至于事件总线的设计本身——为什么要给每个事件 Bean 一个独立 topic?这个设计的取舍是什么?什么场景下值得这么做?详见姊妹篇 《@RemoteEvent 自动事件总线:1 个注解换 1 个 Consumer,赚还是亏?》。

而本次排查里如果你看完发送侧代码,会发现还有一个90% Java 项目都踩过的 Spring 事务消息陷阱——事务还没 commit 就发了消息、事务回滚了消息却发出去了,详见 《事务回滚了消息却发出去:Spring 事务消息的 4 种姿势对比》。

最后一个甩给读者的小问题:如果你的 JVM 跑在 K8s 里、HPA 按内存阈值扩缩容,「每加一个有消息的 @RemoteEvent 就多出 30 多个线程」这件事会怎么把你坑了? 评论区聊。


延伸阅读

📅 最后更新:补上积压本身的原因(另一台机器故障),3950 线程是顺带查出的隐患;补线上实际改动后的实测:线程降到 1185、CPU 空闲多 14 个点、GC 开销不变;此前写的「关 trace 后 CPU 和 GC 基本没变」不成立——那次关 trace 改的是 yml 开关,在 rocketmq-spring 2.1.1 里不生效,trace 其实没关。订正:Consumer 总数 140(其中约 120 个是 @RemoteEvent 自动注册,其余是手写 Listener),i=1 只数出有消息的 60 个;MQClientInstance 实为共享,删掉对应优化;调线程要调 consumeThreadMin;删掉 jstat 两项误读和「只能 kill -9」;泄漏判据改为看涨不涨。