Appearance
3.4-4 Dubbo 线程模型:IO 线程与业务线程、Dispatcher
所属:03 主流框架 / 3.4 Dubbo 分级:A 状态:◐ 初稿 关联:3.4-1、3.4-2、3.4-3、3.4-5、3.4-6、6.6-2
题型:原理 / 调优 / 排障
一句话结论:Dubbo 默认是 “Netty IO 线程收包解码 → Dispatcher 把请求丢进业务线程池 → Filter 链 → 服务实现” 的两级线程模型:IO 线程(
iothreads,默认 CPU+1、上限 32)只做网络读写、编解码、心跳;业务线程池(threadpool=fixed、threads=200、queues=0)执行真正的服务方法。默认dispatcher=all,连响应也丢进业务池;execution只把请求丢池、响应留在 IO 线程,是高吞吐场景的常用优化。核心原则只有一条:不要在 IO 线程上做阻塞操作,否则一个 EventLoop 上所有连接一起被拖死。分层要点:
- Netty 的两类线程:
boss线程负责accept新连接(通常 1 个),worker(IO 线程)负责read/write、解码、心跳。一个 worker 线程会服务成百上千个 channel,所以 IO 线程上的任何阻塞都是“连坐”。 - Dispatcher 决定“谁来执行业务”:
all(默认,所有事件进业务池)、direct(全部在 IO 线程)、message(只有消息进池,连接事件在 IO 线程)、execution(只有请求进池,响应在 IO 线程)、connection(连接事件进独立有序池,消息进业务池)。配置项dispatcher,是 Protocol 级参数。 - 业务线程池由
ThreadPoolSPI 决定:fixed(默认,核心=最大=threads)、cached(SynchronousQueue+ 无限线程,风险高)、limited(增长到threads后不再回收)、eager(先建线程再排队,适合突发流量)。queues=0表示用SynchronousQueue,线程满直接拒绝,不是“无上限队列”。 - 线程池是“按协议共享”的:同一个
ProtocolConfig(同端口)下所有 service 共用一个业务线程池;要让慢服务不影响快服务,得拆协议/端口,或用executes(provider 方法级并发上限)、actives(consumer 方法级并发上限),或在业务内部再做隔离。 - Provider 侧的完整路径:Netty worker 收包 →
NettyServerHandler.channelRead→HeaderExchangeHandler.handleRequest→DubboProtocol.requestHandler.reply→ Dispatcher 投池 →ProtocolFilterWrapper的 Filter 链 →AbstractProxyInvoker→Wrapper.invokeMethod→ 服务实现 → 响应写回(编码在 IO 线程)。 - Consumer 侧的回调线程:同步调用是业务线程
future.get(timeout)阻塞等待;异步调用的回调默认在 IO 线程执行(DefaultFuture在收到响应时完成),回调里做阻塞操作会卡住该 channel 上所有请求。要么用whenCompleteAsync(..., executor)切线程,要么把耗时逻辑再丢业务池。 - 超时、心跳、重试都和线程模型相关:心跳(默认 60s,3 倍无响应断连)在 IO 线程;超时由
DefaultFuture的定时任务触发;超时后 provider 可能仍在业务线程里执行——超时不等于取消,重试会进一步放大线程池压力,形成雪崩。 - 调参用排队论,不靠感觉:阻塞型服务
threads ≈ QPS × 平均RT,再留 20%~30% 余量;queues>0只是把过载变成延迟,容易掩盖问题;IO 线程数按 CPU 核数,不要为了“扛并发”盲目调大业务线程,瓶颈通常在 DB/RPC 下游。
- Netty 的两类线程:
图/流程:
text
Provider 线程模型:
Netty boss(1)
→ accept
Netty worker(iothreads = CPU+1,≤32)
→ read / decode / heartbeat
→ Dispatcher
all / message / execution / connection
→ 业务线程池(fixed, threads=200, queues=0)
→ Filter 链(Echo/ClassLoader/Generic/Context/Trace/Timeout/Monitor/Exception)
→ AbstractProxyInvoker
→ Wrapper.invokeMethod
→ 服务实现
← write / encode(IO 线程)text
Consumer 线程模型:
业务线程
→ proxy → ClusterInvoker → DubboInvoker
→ 发送请求(IO 线程 write)
→ 同步:future.get(timeout) 阻塞
→ 异步:返回 CompletableFuture
Netty worker 收到响应
→ HeaderExchangeHandler.handleResponse
→ DefaultFuture.received
→ 完成 future / 执行回调(IO 线程)text
Dispatcher 策略:
all → 请求/响应/连接事件 全部进业务池(默认)
direct → 全部在 IO 线程(禁止阻塞)
message → 只有消息进池,连接事件在 IO 线程
execution → 只有请求进池,响应在 IO 线程(高吞吐推荐)
connection → 连接事件进独立有序池(connect.queue),消息进业务池text
fixed 线程池(queues=0):
core = max = threads
workQueue = SynchronousQueue
reject = AbortPolicy
→ 线程都在忙时立即 RejectedExecutionException
→ 日志:Thread pool is EXHAUSTED版本/源码锚点:
- 线程池:
ThreadPoolSPI、FixedThreadPool、CachedThreadPool、LimitedThreadPool、EagerThreadPool、ThreadPoolExecutor(Dubbo 自定义,带拒绝日志)。 - 派发:
DispatcherSPI(@SPI(AllDispatcher.NAME))、AllDispatcher、DirectDispatcher、MessageOnlyDispatcher、ExecutionDispatcher、ConnectionOrderedDispatcher;ChannelHandler子类。 - 网络:
NettyServer、NettyServerHandler、NettyClient、NettyClientHandler、IdleStateHandler、HeartbeatHandler、HeaderExchangeHandler、DefaultFuture。 - 配置:
dubbo.protocol.dispatcher、dubbo.protocol.threadpool、dubbo.protocol.threads、dubbo.protocol.queues、dubbo.protocol.iothreads、dubbo.protocol.accepts、dubbo.protocol.heartbeat、dubbo.provider.executes、dubbo.consumer.actives。 - Dubbo 3:
ExecutorRepository管理每个协议/作用域的线程池;Triple(HTTP/2)走独立协议栈,线程模型与dubbo协议不同。 - 默认值:
iothreads = min(CPU+1, 32)、threads = 200、queues = 0、heartbeat = 60000、accepts = 0(不限制)。
- 线程池:
Dispatcher 对比:
| 策略 | 请求 | 响应 | 连接/心跳 | 适用 |
|---|---|---|---|---|
all(默认) | 业务池 | 业务池 | 业务池 | 通用;响应处理也占池 |
direct | IO 线程 | IO 线程 | IO 线程 | 极轻量逻辑;禁止阻塞 |
message | 业务池 | 业务池 | IO 线程 | 连接事件想快速处理 |
execution | 业务池 | IO 线程 | IO 线程 | 高吞吐,减少池占用 |
connection | 业务池 | 业务池 | 独立有序池 | 连接事件多、需保序 |
- ThreadPool 对比:
| 类型 | 队列 | 线程增长 | 风险 | 场景 |
|---|---|---|---|---|
fixed(默认) | SynchronousQueue(queues=0) | 固定 threads | 满即拒绝 | 稳定负载、快速失败 |
cached | SynchronousQueue | 无上限 | 线程爆炸、上下文切换 | 短任务突发(慎用) |
limited | LinkedBlockingQueue | 到 threads 为止,不回收 | 空闲线程常驻 | 稳定长连接 |
eager | 自定义队列 | 先建线程再排队 | 线程数偏高 | 突发流量、避免排队 |
- 关键参数:
| 参数 | 默认 | 作用 | 调整建议 |
|---|---|---|---|
iothreads | CPU+1(≤32) | Netty worker 数 | 按 CPU,不要盲目调大 |
threads | 200 | 业务线程数 | 按 QPS × RT 估算 |
queues | 0 | 业务队列 | 保持 0 快速失败,或小队列 |
threadpool | fixed | 池类型 | 突发可用 eager |
dispatcher | all | 派发策略 | 高吞吐试 execution |
accepts | 0 | 最大连接数 | 按容量设上限 |
heartbeat | 60000ms | 心跳间隔 | 跨机房可调大 |
executes | 0 | provider 方法并发上限 | 保护慢方法 |
actives | 0 | consumer 方法并发上限 | 保护下游 |
payload | 8MB | 报文上限 | 大对象改分页 |
- 失效场景与定位:
| 现象 | 根因 | 处理 |
|---|---|---|
Thread pool is EXHAUSTED | 业务池满且 queues=0 | 看线程栈定位慢点;扩池/异步化/限流 |
| 所有接口一起超时 | IO 线程被阻塞(direct/自定义 Handler) | 改 dispatcher,IO 线程不做阻塞 |
| 单个慢接口拖垮全部 | 同协议共享线程池 | 拆协议/端口、executes 限流、隔离部署 |
| 消费端回调卡住其他请求 | 回调在 IO 线程执行 | whenCompleteAsync 切线程 |
| 心跳超时断连 | GC 停顿/IO 线程阻塞 | 查 GC、线程栈、网络 |
| 超时后 provider 仍在执行 | 超时不取消 | 幂等 + 业务侧超时 |
| 重试导致雪崩 | 超时 + retries 放大 | 关非幂等重试、熔断 |
| 队列越长延迟越高 | queues 过大 | 减小队列、扩容、限流 |
cached 池线程数飙升 | 无上限 | 改 fixed/eager |
| 上下文丢失 | 跨线程 ThreadLocal | 显式传参/RpcContext 附件 |
深挖点(面试官常追的 6 个):
- 请求到底在哪个线程执行:默认
dispatcher=all,Netty worker 解码后由AllChannelHandler把事件提交到业务线程池,Filter 和 service 都在业务线程;IO 线程只负责读写和编解码。如果改成direct,全部在 IO 线程,任何阻塞都会让该 EventLoop 上的所有 channel 卡住——这是“为什么不能阻塞 IO 线程”的标准答案。 execution为什么更快:ExecutionDispatcher只把请求投递到业务池,响应在 IO 线程直接处理。Provider 返回响应、Consumer 处理响应都不占业务线程,池的利用率更高;代价是响应的序列化/回调逻辑跑在 IO 线程,不能阻塞。高 QPS 场景常用。queues=0到底是什么:FixedThreadPool在queues=0时用SynchronousQueue,它是“手递手”队列,没有容量;线程都在忙时offer失败,配合AbortPolicy直接抛RejectedExecutionException,日志打Thread pool is EXHAUSTED并 dump 线程栈。这是快速失败设计,不是配置错误;把queues调大只是把拒绝变成排队延迟。- 为什么一个慢接口能拖垮整个应用:同一协议的所有 service 共享业务池;慢接口占满 200 个线程后,快接口也拿不到线程。解决不是简单调大
threads(会加重下游和 GC),而是隔离:拆协议/端口、给慢接口独立部署、executes限制单方法并发、consumer 侧actives限流、超时+熔断。 - Consumer 回调为什么危险:
DefaultFuture在 IO 线程收到响应并完成 future,whenComplete的回调就在 IO 线程执行;Dubbo 默认单连接(connections=0共享连接),一个回调阻塞会影响该连接上所有请求的响应处理。异步编程要么用whenCompleteAsync(..., bizExecutor),要么只做轻量转换。 - 线程数怎么估:阻塞型服务按 Little's Law:并发线程 ≈ QPS × 平均RT(秒)。例如 2000 QPS、RT 50ms → 100 线程,留 30% 余量约 130;再结合下游连接池、DB 最大连接数取最小值。IO 线程数按 CPU 核数(CPU+1)即可,调大不会提升吞吐,反而增加上下文切换。
- 请求到底在哪个线程执行:默认
追问链:
- Dubbo 线程模型分几层? → Netty IO 线程 + 业务线程池。
- 默认 dispatcher? →
all。 - 有哪些 dispatcher? → all/direct/message/execution/connection。
all做什么? → 所有事件进业务池。direct做什么? → 全部在 IO 线程。execution做什么? → 只请求进池,响应在 IO 线程。message和all区别? → 连接事件是否进池。connection用途? → 连接事件独立有序池。- IO 线程默认几个? → CPU+1,上限 32。
- 业务线程默认几个? → 200。
- 默认线程池类型? →
fixed。 queues=0是什么队列? →SynchronousQueue。- 池满会怎样? → 拒绝,
Thread pool is EXHAUSTED。 - 为什么默认队列是 0? → 快速失败,避免延迟堆积。
cached池风险? → 线程无限增长。eager池特点? → 先建线程再排队。limited池特点? → 到上限不回收。- 线程池按什么维度共享? → 按协议/端口。
- 怎么隔离慢服务? → 拆协议、独立部署、
executes。 executes是什么? → provider 方法级并发上限。actives是什么? → consumer 方法级并发上限。- 超时后 provider 会停吗? → 不会。
- 心跳默认多少? → 60s。
- 多久断连? → 3 倍心跳无响应。
- 心跳在哪个线程? → IO 线程。
- 响应在哪个线程编码? → IO 线程(
all时响应处理在池)。 - Consumer 回调在哪个线程? → 默认 IO 线程。
- 回调阻塞会怎样? → 卡住该连接所有响应。
- 怎么避免? →
whenCompleteAsync切业务池。 - 同步调用怎么等? →
future.get(timeout)。 - 为什么不能阻塞 IO 线程? → 一个 EventLoop 服务多连接。
dispatcher=direct适合什么? → 极轻量、无阻塞逻辑。- 怎么判断 IO 线程被阻塞? → 线程栈里业务代码出现在
NettyServerHandler。 - 线程池满怎么排查? → 日志 + 线程栈 + 慢 SQL/RPC。
- 线程数怎么估? → QPS × RT,留余量。
- IO 线程能调大吗? → 能,但通常无益。
- 连接数和线程数关系? → 连接多不等于线程多,默认共享连接。
connections参数? → 每个 provider 的连接数,0 表示共享。- 单连接会阻塞吗? → 会,响应处理共享 IO 线程。
- Dubbo 3 线程池有变化吗? →
ExecutorRepository按作用域管理。 - Triple 线程模型一样吗? → HTTP/2 协议栈,独立处理。
- GC 对线程模型的影响? → STW 导致心跳/请求超时。
- 异步调用怎么用? →
async=true返回CompletableFuture。 - 异步和线程池关系? → 回调线程需自己控制。
- 怎么保护下游? →
actives+ 超时 + 熔断。 - 怎么防雪崩? → 限流、隔离、熔断、快速失败。
- 线程池监控看什么? → 活跃线程、队列、拒绝数、RT。
- 为什么要 dump 线程? → 定位阻塞点。
- 虚拟线程能用吗? → 需版本支持,阻塞模型下可评估。
- 面试怎么总结? → IO/业务两级 → dispatcher 五策略 → 池类型与 queues=0 → 隔离与调参 → 超时重试雪崩。
生产案例/取舍(示例,替换成你的项目):
- 大促时
Thread pool is EXHAUSTED,线程栈全卡在某个慢 SQL;加索引 + 该接口独立部署。 - 自定义 Filter 里做同步 HTTP 调用,
dispatcher被改成direct,整个 provider 卡死;恢复默认并移出阻塞逻辑。 - 消费端
whenComplete里写库,IO 线程被占满,其他请求响应超时;改whenCompleteAsync+ 独立线程池。 - 一个报表接口把 200 线程占满,订单接口一起超时;拆到独立协议/端口。
queues调到 10000 掩盖过载,RT 从 50ms 涨到 5s;改回 0 + 限流。threadpool=cached在突发流量下线程数破千,GC 飙升;改fixed。- 超时 1s + retries 2,下游抖动时请求量放大 3 倍,雪崩;关重试 + 熔断。
- 心跳 60s,跨机房网络抖动导致偶发断连;调大 heartbeat 并加连接重连监控。
executes配成 10,正常流量被限;按压测结果调整。- 异步回调里拿不到
RpcContext;显式传参或用 Dubbo 3 的上下文附件。 - 取舍:
all换简单可控,代价是池压力大;execution换吞吐,代价是响应逻辑不能阻塞;queues=0换快速失败,代价是尖峰被拒;拆协议换隔离,代价是端口/运维成本;调大线程换短期吞吐,代价是下游与 GC 风险。
- 大促时
易错点:
- 认为 Dubbo 请求直接在 Netty IO 线程执行。
- 认为默认
dispatcher=direct。 - 认为
all只派发请求、不派发响应。 - 认为
execution会把响应也丢进池。 - 认为
queues=0是无界队列。 - 认为
queues=0会缓存请求。 - 认为线程池满会阻塞而不是拒绝。
- 认为调大
threads一定能提升吞吐。 - 认为 IO 线程越多吞吐越高。
- 认为连接数等于业务线程数。
- 认为线程池按 service 隔离。
- 认为超时会停止 provider 执行。
- 认为重试没有副作用。
- 认为心跳在业务线程。
- 认为响应编码在业务线程。
- 认为 Consumer 回调在业务线程。
- 认为异步调用不会占线程。
- 认为
cached池适合生产高并发。 - 认为
eager和fixed完全一样。 - 认为
executes是 consumer 参数。 - 认为
actives是 provider 参数。 - 认为
dispatcher可以按方法配置。 - 认为 Triple 和 dubbo 协议线程模型一致。
- 认为 GC 不影响 RPC 超时。
- 认为线程池监控只看 CPU。
- 认为
Thread pool is EXHAUSTED只是日志噪音。 - 认为
RpcContext能跨线程自动传递。 - 认为虚拟线程能解决所有阻塞问题。
30 秒口述稿:
Dubbo 是两级线程模型:Netty 的 IO 线程负责读写、编解码、心跳,业务线程池跑 Filter 和服务实现,中间由 Dispatcher 决定怎么派发。默认
dispatcher=all,请求、响应、连接事件都进业务池;execution只把请求丢池、响应留在 IO 线程,高吞吐场景更常用。业务池默认fixed、200 线程、queues=0,也就是SynchronousQueue,满了直接拒绝并打Thread pool is EXHAUSTED——这是快速失败,不是 bug。IO 线程绝不能阻塞,因为一个 EventLoop 服务很多连接;consumer 的异步回调默认也在 IO 线程,阻塞会卡住整条连接。调参按 QPS×RT 估线程数,慢服务要靠拆协议、executes/actives做隔离。
- 3 分钟展开顺序:结论(IO 线程 + 业务池两级)→ Netty boss/worker 职责 → Dispatcher 五种策略与默认 all → ThreadPool 四种实现与
queues=0语义 → Provider 完整调用路径 → Consumer 同步/异步与回调线程 → 超时/心跳/重试与雪崩 → 线程数估算与隔离手段 → 生产故障与调优取舍。