Skip to content

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 上所有连接一起被拖死。

  • 分层要点:

    1. Netty 的两类线程:boss 线程负责 accept 新连接(通常 1 个),worker(IO 线程)负责 read/write、解码、心跳。一个 worker 线程会服务成百上千个 channel,所以 IO 线程上的任何阻塞都是“连坐”。
    2. Dispatcher 决定“谁来执行业务”:all(默认,所有事件进业务池)、direct(全部在 IO 线程)、message(只有消息进池,连接事件在 IO 线程)、execution(只有请求进池,响应在 IO 线程)、connection(连接事件进独立有序池,消息进业务池)。配置项 dispatcher,是 Protocol 级参数。
    3. 业务线程池由 ThreadPool SPI 决定:fixed(默认,核心=最大=threads)、cached(SynchronousQueue + 无限线程,风险高)、limited(增长到 threads 后不再回收)、eager(先建线程再排队,适合突发流量)。queues=0 表示用 SynchronousQueue,线程满直接拒绝,不是“无上限队列”。
    4. 线程池是“按协议共享”的:同一个 ProtocolConfig(同端口)下所有 service 共用一个业务线程池;要让慢服务不影响快服务,得拆协议/端口,或用 executes(provider 方法级并发上限)、actives(consumer 方法级并发上限),或在业务内部再做隔离。
    5. Provider 侧的完整路径:Netty worker 收包 → NettyServerHandler.channelRead → HeaderExchangeHandler.handleRequest → DubboProtocol.requestHandler.reply → Dispatcher 投池 → ProtocolFilterWrapper 的 Filter 链 → AbstractProxyInvoker → Wrapper.invokeMethod → 服务实现 → 响应写回(编码在 IO 线程)。
    6. Consumer 侧的回调线程:同步调用是业务线程 future.get(timeout) 阻塞等待;异步调用的回调默认在 IO 线程执行(DefaultFuture 在收到响应时完成),回调里做阻塞操作会卡住该 channel 上所有请求。要么用 whenCompleteAsync(..., executor) 切线程,要么把耗时逻辑再丢业务池。
    7. 超时、心跳、重试都和线程模型相关:心跳(默认 60s,3 倍无响应断连)在 IO 线程;超时由 DefaultFuture 的定时任务触发;超时后 provider 可能仍在业务线程里执行——超时不等于取消,重试会进一步放大线程池压力,形成雪崩。
    8. 调参用排队论,不靠感觉:阻塞型服务 threads ≈ QPS × 平均RT,再留 20%~30% 余量;queues>0 只是把过载变成延迟,容易掩盖问题;IO 线程数按 CPU 核数,不要为了“扛并发”盲目调大业务线程,瓶颈通常在 DB/RPC 下游。
  • 图/流程:

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
  • 版本/源码锚点:

    • 线程池:ThreadPool SPI、FixedThreadPool、CachedThreadPool、LimitedThreadPool、EagerThreadPool、ThreadPoolExecutor(Dubbo 自定义,带拒绝日志)。
    • 派发:Dispatcher SPI(@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(默认)业务池业务池业务池通用;响应处理也占池
directIO 线程IO 线程IO 线程极轻量逻辑;禁止阻塞
message业务池业务池IO 线程连接事件想快速处理
execution业务池IO 线程IO 线程高吞吐,减少池占用
connection业务池业务池独立有序池连接事件多、需保序
  • ThreadPool 对比:
类型队列线程增长风险场景
fixed(默认)SynchronousQueue(queues=0)固定 threads满即拒绝稳定负载、快速失败
cachedSynchronousQueue无上限线程爆炸、上下文切换短任务突发(慎用)
limitedLinkedBlockingQueue到 threads 为止,不回收空闲线程常驻稳定长连接
eager自定义队列先建线程再排队线程数偏高突发流量、避免排队
  • 关键参数:
参数默认作用调整建议
iothreadsCPU+1(≤32)Netty worker 数按 CPU,不要盲目调大
threads200业务线程数按 QPS × RT 估算
queues0业务队列保持 0 快速失败,或小队列
threadpoolfixed池类型突发可用 eager
dispatcherall派发策略高吞吐试 execution
accepts0最大连接数按容量设上限
heartbeat60000ms心跳间隔跨机房可调大
executes0provider 方法并发上限保护慢方法
actives0consumer 方法并发上限保护下游
payload8MB报文上限大对象改分页
  • 失效场景与定位:
现象根因处理
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 个):

    1. 请求到底在哪个线程执行:默认 dispatcher=all,Netty worker 解码后由 AllChannelHandler 把事件提交到业务线程池,Filter 和 service 都在业务线程;IO 线程只负责读写和编解码。如果改成 direct,全部在 IO 线程,任何阻塞都会让该 EventLoop 上的所有 channel 卡住——这是“为什么不能阻塞 IO 线程”的标准答案。
    2. execution 为什么更快:ExecutionDispatcher 只把请求投递到业务池,响应在 IO 线程直接处理。Provider 返回响应、Consumer 处理响应都不占业务线程,池的利用率更高;代价是响应的序列化/回调逻辑跑在 IO 线程,不能阻塞。高 QPS 场景常用。
    3. queues=0 到底是什么:FixedThreadPool 在 queues=0 时用 SynchronousQueue,它是“手递手”队列,没有容量;线程都在忙时 offer 失败,配合 AbortPolicy 直接抛 RejectedExecutionException,日志打 Thread pool is EXHAUSTED 并 dump 线程栈。这是快速失败设计,不是配置错误;把 queues 调大只是把拒绝变成排队延迟。
    4. 为什么一个慢接口能拖垮整个应用:同一协议的所有 service 共享业务池;慢接口占满 200 个线程后,快接口也拿不到线程。解决不是简单调大 threads(会加重下游和 GC),而是隔离:拆协议/端口、给慢接口独立部署、executes 限制单方法并发、consumer 侧 actives 限流、超时+熔断。
    5. Consumer 回调为什么危险:DefaultFuture 在 IO 线程收到响应并完成 future,whenComplete 的回调就在 IO 线程执行;Dubbo 默认单连接(connections=0 共享连接),一个回调阻塞会影响该连接上所有请求的响应处理。异步编程要么用 whenCompleteAsync(..., bizExecutor),要么只做轻量转换。
    6. 线程数怎么估:阻塞型服务按 Little's Law:并发线程 ≈ QPS × 平均RT(秒)。例如 2000 QPS、RT 50ms → 100 线程,留 30% 余量约 130;再结合下游连接池、DB 最大连接数取最小值。IO 线程数按 CPU 核数(CPU+1)即可,调大不会提升吞吐,反而增加上下文切换。
  • 追问链:

    1. Dubbo 线程模型分几层? → Netty IO 线程 + 业务线程池。
    2. 默认 dispatcher? → all。
    3. 有哪些 dispatcher? → all/direct/message/execution/connection。
    4. all 做什么? → 所有事件进业务池。
    5. direct 做什么? → 全部在 IO 线程。
    6. execution 做什么? → 只请求进池,响应在 IO 线程。
    7. message 和 all 区别? → 连接事件是否进池。
    8. connection 用途? → 连接事件独立有序池。
    9. IO 线程默认几个? → CPU+1,上限 32。
    10. 业务线程默认几个? → 200。
    11. 默认线程池类型? → fixed。
    12. queues=0 是什么队列? → SynchronousQueue。
    13. 池满会怎样? → 拒绝,Thread pool is EXHAUSTED。
    14. 为什么默认队列是 0? → 快速失败,避免延迟堆积。
    15. cached 池风险? → 线程无限增长。
    16. eager 池特点? → 先建线程再排队。
    17. limited 池特点? → 到上限不回收。
    18. 线程池按什么维度共享? → 按协议/端口。
    19. 怎么隔离慢服务? → 拆协议、独立部署、executes。
    20. executes 是什么? → provider 方法级并发上限。
    21. actives 是什么? → consumer 方法级并发上限。
    22. 超时后 provider 会停吗? → 不会。
    23. 心跳默认多少? → 60s。
    24. 多久断连? → 3 倍心跳无响应。
    25. 心跳在哪个线程? → IO 线程。
    26. 响应在哪个线程编码? → IO 线程(all 时响应处理在池)。
    27. Consumer 回调在哪个线程? → 默认 IO 线程。
    28. 回调阻塞会怎样? → 卡住该连接所有响应。
    29. 怎么避免? → whenCompleteAsync 切业务池。
    30. 同步调用怎么等? → future.get(timeout)。
    31. 为什么不能阻塞 IO 线程? → 一个 EventLoop 服务多连接。
    32. dispatcher=direct 适合什么? → 极轻量、无阻塞逻辑。
    33. 怎么判断 IO 线程被阻塞? → 线程栈里业务代码出现在 NettyServerHandler。
    34. 线程池满怎么排查? → 日志 + 线程栈 + 慢 SQL/RPC。
    35. 线程数怎么估? → QPS × RT,留余量。
    36. IO 线程能调大吗? → 能,但通常无益。
    37. 连接数和线程数关系? → 连接多不等于线程多,默认共享连接。
    38. connections 参数? → 每个 provider 的连接数,0 表示共享。
    39. 单连接会阻塞吗? → 会,响应处理共享 IO 线程。
    40. Dubbo 3 线程池有变化吗? → ExecutorRepository 按作用域管理。
    41. Triple 线程模型一样吗? → HTTP/2 协议栈,独立处理。
    42. GC 对线程模型的影响? → STW 导致心跳/请求超时。
    43. 异步调用怎么用? → async=true 返回 CompletableFuture。
    44. 异步和线程池关系? → 回调线程需自己控制。
    45. 怎么保护下游? → actives + 超时 + 熔断。
    46. 怎么防雪崩? → 限流、隔离、熔断、快速失败。
    47. 线程池监控看什么? → 活跃线程、队列、拒绝数、RT。
    48. 为什么要 dump 线程? → 定位阻塞点。
    49. 虚拟线程能用吗? → 需版本支持,阻塞模型下可评估。
    50. 面试怎么总结? → 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 同步/异步与回调线程 → 超时/心跳/重试与雪崩 → 线程数估算与隔离手段 → 生产故障与调优取舍。