全站成功率从 99.98% 掉到 41%,元凶是一个导出接口

引言

晚上 21:07,运营在后台点了一次"导出本月订单"。数据量 18 万条,按日期分 200 批,每一批调一次订单服务的 Dubbo 接口。

三分钟后,订单服务的成功率从 99.98% 掉到 41%,商品、库存、用户三个服务跟着一起异常——它们和订单服务在同一批 Pod 里,探针也挂了,K8s 开始滚动重启。

日志里刷的是同一行:

Thread pool is EXHAUSTED! Thread Name: DubboServerHandler-10.0.3.17:20880,
Pool Size: 200, Active: 200, Task: 4827133, Completed Task: 4820681

Active: 200,线程池满;Task 是个六位数——Dubbo 统计的是"累计提交任务数",不是队列长度,这一点当时把我带偏了十分钟。

结论先给:Dubbo 的线程池不是队列,是稀缺资源。默认 queues=0,200 个线程一满,新请求不是排队,是被直接拒绝——而且整个应用的所有服务共用这一个池。

一、第一反应:流量没涨,为什么 RT 涨了 50 倍

先看监控,几个数很反常:

  • QPS 没有明显上涨,从 3,200 到 3,400
  • P99 从 60ms 涨到 3,100ms
  • 错误率飙升,但错误类型全是 Thread pool is EXHAUSTED,不是超时

如果只是流量大,QPS 应该同步上涨;如果只是慢查询,错误类型应该是超时。"QPS 平稳 + RT 暴涨 + 拒绝"这个组合,指向的是线程不够用,而不是流量或数据库。

还有一个细节值得记:消费方看到的报错不是 TimeoutException,而是 RpcException,message 里带着服务端那行 Thread pool is EXHAUSTED。服务端拒绝的异常被原样透传到了调用方,所以排查时先在消费方日志里搜 EXHAUSTED,比去翻服务端日志快得多。

更迷惑的是失败的不只是订单接口,商品详情、用户信息这些毫不相关的接口也在报同样的错。那一刻我才意识到一个一直被忽略的事实:这些服务在同一个 JVM 里,共用同一个 Dubbo 线程池。

二、排查:三行日志 + 一条 jstack

2.1 从 EXHAUSTED 那行日志里读信息

Dubbo 的拒绝日志会打印线程池快照:Pool Size 是最大线程数,Active 是正在执行的任务数,Completed Task 是累计完成数。

Pool Size: 200, Active: 200 意味着 200 个线程全部在跑。关键是要找"它们都在跑什么",日志本身不会告诉你。

Task: 4827133 看着像个巨大的积压量,其实是 ThreadPoolExecutor#getTaskCount()——进程启动以来累计提交的任务总数,Completed Task 是其中已完成的。两者差 6,452,说明此刻真正"在手上"的只有 200 来个,队列里一个都没有。这是最容易误判的一处:把累计数当积压量,会误以为要扩队列,而实际要扩的是隔离。

2.2 jstack:200 个线程全卡在同一个方法

jstack 21789 | grep -A 20 'DubboServerHandler' > /tmp/dubbo.txt
grep -c 'DubboServerHandler' /tmp/dubbo.txt        # 线程总数
grep -A 8 'DubboServerHandler' /tmp/dubbo.txt | grep 'at com.' | sort | uniq -c | sort -rn

输出很干净:200 个线程里,187 个停在同一个方法栈上——OrderExportService.exportBatch,下面挂着一条没有走索引的 select ... where create_time between ? and ? 全表扫描。

这说明线程不是"忙得均匀",而是"全都堵在同一个地方"。均匀忙碌是容量不足,集中堵塞是某个调用太慢。

顺带看线程状态:如果这 187 个是 RUNNABLE,说明在烧 CPU(比如死循环、大量 JSON 序列化);如果是 WAITING 停在 socket read 或数据库调用,说明在等外部资源。我们这批是后者——等 MySQL 返回,不是算不动。 区分这两种,才知道该扩 CPU 还是该优化 SQL。

2.3 消费方那边的账

再看导出的调用方:它把 18 万条按日期切成 200 批,同一个线程串行地一批一批调 RPC,每批在服务端要跑 2~3 秒。

200 个线程 × 2.5 秒 = 500 秒的处理总量,而导出任务每分钟还在继续提交。只要有 80 个导出任务同时在跑,就能把整个池长期占满——事实上有 5 个运营在同时点导出。

一个容易忽略的放大效应:消费方 timeout 配的 30 秒,服务端一批要 2.5 秒,看起来绰绰有余。但线程池打满后,请求在进入业务逻辑之前就已经被拒绝,消费方的重试逻辑(很多框架默认重试 2 次)会把请求量放大 3 倍,让"已经满了"的池雪上加霜。事故期间服务端收到的请求量是平时的 2.8 倍,其中一大半是重试。

三、根因:三个设计假设都错了

3.1 queues=0:Dubbo 默认不排队

Dubbo 的 provider 默认线程池参数是 threads=200、queues=0。queues=0 不代表"没有限制",而是用 SynchronousQueue——任务要么立刻被线程接走,要么直接创建新线程,线程到 200 之后就被拒绝。

所以"打满"的那一刻不是变慢,是立刻开始拒绝。这是很多人以为是"请求堆积、慢慢处理"的误解来源。

线程池的扩容逻辑也值得说清楚:SynchronousQueue 的 offer 只有在有空闲线程等待时才会成功。所以前 200 个请求每来一个就新建一个线程,到 maximumPoolSize 之后,第 201 个请求发现"没空闲线程、队列也塞不进",直接走拒绝策略。整个过程没有任何缓冲,从"完全正常"到"全部拒绝"只隔一个请求。

3.2 所有服务共用一个池

默认情况下,provider 侧所有 service 共享同一个 ExecutorService。设计初衷是"资源复用",代价是一个慢服务能拖垮整个应用的所有服务。

这个共享池由 SharedExecutorRepository 按"线程池参数"缓存:只要两个 service 的 threads、queues、keepalive 配置完全相同,拿到的就是同一个实例。反过来说,想隔离不一定要改隔离模式,给某个 service 单独配一套不同的线程池参数也能"意外地"隔离——但那是靠配置副作用实现的,别依赖它。

这也解释了为什么商品、用户服务会"无故"失败——它们没有 bug,只是被邻居饿死了。

3.3 批量接口和在线接口没有物理隔离

导出是后台任务,特征是"单次耗时长、可延迟、允许失败";下单是在线请求,特征是"毫秒级、不可失败"。两者住在同一个池里,后台任务永远有能力把在线请求挤死。

这不是 Dubbo 的缺陷,是使用方式的问题:把离线负载和在线负载放进同一个资源池,任何限流都救不了。

四、修复:隔离优先于调参

4.1 第一步:按服务隔离线程池

dubbo:
  provider:
    threads: 200               # 在线服务的池
    executor-management-mode: service   # 每个 service 独立线程池
  protocols:
    dubbo:
      threads: 200

executor-management-mode=service 让每个 service 拥有自己的线程池。导出服务被单独关进一个小池(threads=20),打满只影响自己,不再殃及商品和用户服务。

这个参数在 Dubbo 3.x 里走的是 dubbo.application.executor-management-mode(应用级)或 dubbo.provider.executor-management-mode(服务端级),可选值 framework_service / service / all。默认 framework_service,意思是"只有框架内部服务(心跳、回调)用独立池,业务 service 还是共享"。升级到 3.x 之后如果没显式配这一项,隔离效果和 2.7 一样。

代价是线程总数变多:5 个服务 × 200 = 1,000 个线程,堆内存和上下文切换都会涨。隔离不是免费的,要按"这个服务允许多少并发"来配,而不是一律 200。

4.2 第二步:给批量接口限制并发

// 服务端:限制该方法的并发执行数,超过直接返回"稍后重试"
@DubboService(executor = "exportExecutor")
public class OrderExportService {
    // 消费方也可用 actives 限制"每个消费者对该方法的并发调用数"
}

消费方侧配 actives=5(每个消费者对某方法的并发上限),服务端再用独立的 exportExecutor 兜底,两层都能挡住"5 个运营同时点导出"。

actives 有个反直觉的边界:它是每个消费者实例的上限,不是全局。导出任务如果部署了 4 个副本,总并发就是 20。所以服务端那一层不能省——消费方限流只能防止"自己打别人",管不住"大家一起打"。

4.3 第三步:批量接口本身要能被打断

导出不该是"一次 RPC 处理 900 条",而是"一次 RPC 处理 100 条 + 游标"。消费方改成分页拉取、丢弃已过期的任务,服务端每批控制在 500ms 内返回。批量接口的设计原则是"单次可预期的耗时",而不是"一次搞定"。

4.4 拒绝策略:别顺手改成 CallerRuns

Dubbo 的 reject-policy 可以配 callerruns、discard、discardoldest。有人以为 callerruns 更优雅——让提交任务的线程自己执行,起到"反压"作用。

在 Dubbo 里这是个陷阱:提交任务的线程是 Netty 的 IO 线程,让它在 IO 线程里跑 2.5 秒的业务逻辑,会把整个 channel 的读写都堵住,比直接拒绝更糟。provider 侧保持默认的 abort,让客户端快速失败并重试,是更安全的选择。

discard 更不能用:它静默丢弃任务,消费方会收到超时而不是明确拒绝,排查时完全看不出"服务端主动放弃了请求",只看到一堆超时。拒绝要吵,不要静默。

五、预防:三条能落地的监控

方案配置隔离粒度代价适用场景
不隔离(默认)threads=200全应用共享一个慢服务拖垮全部只有 1~2 个轻量服务
按服务隔离executor-management-mode: service每个 service线程数 × 服务数服务数 ≤ 10、有明显冷热差
独立线程池@DubboService(executor="xxx")单个 service需自己管理池参数批量/离线类接口
消费方限并发actives=5每消费者每方法会误伤正常高峰有明确调用方的内部接口
拆批 + 游标业务改造单次耗时可控改造成本导出、同步、批量写

监控上抓三个指标就够了:线程池 Active 是否长期 > 80%、拒绝次数(RejectedExecutionException 计数)、同一类线程的堆栈聚集度(用 jstack 定时采样,187/200 卡在同一方法是极强的信号)。

Active 可以从 Dubbo 的 Metrics 或 jvm 线程数间接观察,DubboServerHandler 线程数一直贴着 threads 上限就是危险信号。想更直接,用 QoS 的 count 命令看方法级调用量和耗时,或者开 dubbo.metrics 把 provider.executor 相关指标打到 Prometheus。别等到拒绝日志开始刷才报警,那时候已经在拒绝了。

避坑清单:

  • queues=0 不是没队列,是没缓冲,打满即拒绝,别指望"排队消化"。
  • 默认全应用共享一个池,任何批量接口都可能是全站单点。
  • 拒绝日志里的 Task 是累计提交数,不是积压量,别拿它判断队列长度。
  • reject-policy=callerruns 会阻塞 Netty IO 线程,provider 侧不要用。
  • 线程池调大不是解,200 调到 500 只是把崩溃推迟 3 分钟,隔离才是解。

收尾

Dubbo 线程池的关键认知是"它是共享的、无缓冲的、会直接拒绝的"——所以隔离批量接口,比调大 threads 重要得多。

你们的 Dubbo provider 是默认共享池还是按服务隔离?有没有因为一个导出接口把在线服务带崩过?

关注我,每周拆一个真实生产故障。


标题:全站成功率从 99.98% 掉到 41%,元凶是一个导出接口
作者:jiangyi
地址:http://jiangyi.space/articles/2026/11/07/1793800680069.html
公众号:服务端技术精选
    评论
    0 评论
avatar

取消