知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# Dubbo 通信、序列化与线程模型 > 导读:本文从"服务调用明明只是发个请求,为什么线上会出现心跳超时、连接被断开、偶发超时"这个具体的痛点出发,把 Dubbo 支持的协议与选型、底层基于 Netty 的通信与编解码、序列化方式与选型、线程模型与 Dispatcher 策略、线程池与队列、IO 线程与业务线程的边界这几个主题逐项讲透,最后给出生产用法与踩坑。适合已经会写 Dubbo 服务、但想搞清楚"请求到底是怎么走完这一路的"同学。 ## 一、先建立全局认知 ### Q:一次 Dubbo 调用在"通信"这条线上到底经过了哪些环节? A:结论先行——一条完整的通信链路是:**代理对象 → ClusterInvoker → Protocol → ExchangeClient(Request 封装)→ 编码器(Codec)→ Netty 客户端 → TCP 长连接 → Netty 服务端 → 解码器 → 派发(Dispatcher)→ 业务线程池 → Protocol 分发 → Invoker → 实现类**。理解这条链的分段,才能定位"到底是序列化慢、IO 线程堵了、还是线程池满了"。  *图:Dubbo 通信全链路:协议、编解码与线程模型* ```text ┌───────────────┐ │ 业务代码调用 │ └──────┬────────┘ ▼ ┌───────────────┐ ┌──────────────┐ ┌───────────────┐ │ ClusterInvoker│──▶│ Protocol │──▶│ ExchangeClient│ │ 路由/负载/容错 │ │ (dubbo/tri) │ │ Request/Response│ └───────────────┘ └──────────────┘ └──────┬────────┘ ▼ ┌────────────────────────────────────────┐ │ Codec:DubboCodec(16 字节协议头) │ │ Serialize:Hessian2 / Protobuf / ... │ └───────────────────┬────────────────────┘ ▼ ┌────────────────────────────────────────┐ │ NettyClient ──── TCP 长连接(多路复用) │ └───────────────────┬────────────────────┘ ▼ ┌────────────────────────────────────────┐ │ NettyServer:IO 线程(Boss/Worker) │ └───────────────────┬────────────────────┘ ▼ ┌────────────────────────────────────────┐ │ Dispatcher 决定:是否派发到业务线程池 │ └───────────────────┬────────────────────┘ ▼ ┌────────────────────────────────────────┐ │ 业务线程池(fixed/cached/eager/limited)│ └───────────────────┬────────────────────┘ ▼ ┌────────────────────────────────────────┐ │ DubboProtocol 分发 → Invoker → 实现类 │ └────────────────────────────────────────┘ ``` 三个"看不见但特别容易出事"的位置,先标出来: 1. **序列化**:它决定了报文体的大小与 CPU 开销,也是"跨版本不兼容"的高发区。 2. **IO 线程**:数量很少(取决于 Netty 的 worker 线程配置),一旦被阻塞,会连带影响同一条连接上的所有请求与心跳。 3. **业务线程池**:队列与拒绝策略决定了"压力大时是变慢还是直接报错"。 ### Q:Dubbo 支持哪些协议?默认用哪个? A:结论先行——Dubbo 的协议是 SPI 扩展点,常见的有 `dubbo`、`triple`、`rest`、`grpc`、`hessian`、`thrift`、`rmi`、`http`、`webservice` 等。**默认协议在 2.x 是 `dubbo`;3.x 推荐并逐步向 `triple` 演进,但具体默认值需结合版本确认。** 端口默认 `20880`(`dubbo` 协议,需结合版本与配置确认)。  *图:各协议的承载方式、默认序列化与典型场景* ```text 协议 承载方式 序列化默认(约) 典型场景 ───────────────────────────────────────────────────────────────────── dubbo 私有二进制协议 hessian2 Java 内网高频调用 triple HTTP/2 protobuf(可变) 跨语言 / 流式 / 网关 rest HTTP/1.1(JAX-RS) JSON 对外 REST 风格接口 grpc HTTP/2 protobuf 与 gRPC 生态互通(历史实现) hessian HTTP hessian2 轻量、跨语言(较少用) rmi JRMP Java 原生 老系统兼容(基本淘汰) http HTTP JSON/表单 与遗留 HTTP 系统对接 ``` **注意**:表里的"序列化默认"是方向性描述,**不同版本、不同协议的实际默认值可能不同,落地前必须结合版本确认**;`grpc` 协议在 Dubbo 2.7 中是实验性的,与 Dubbo 3 的 `triple` **不是同一个东西**,不要混用。 ## 二、协议选型:什么时候用 dubbo,什么时候用 triple / rest ### Q:`dubbo` 协议有什么特点?适合什么场景? A:结论先行——`dubbo` 协议是 Dubbo 的私有二进制协议,特点是**单一长连接 + 多路复用 + 自定义 16 字节协议头**,序列化效率高、传输开销小,非常适合"Java 与 Java 之间、调用量大、报文不大"的内部服务调用;代价是**跨语言支持弱、抓包分析不友好、网关治理成本高**。 `dubbo` 协议的报文结构(概念示意):  *图:Dubbo 协议:16 字节定长头与变长 body* ```text ┌────────┬────────┬────────┬─────────────────┬───────────────┬─────────────┐ │ magic │ flag │ status │ request id │ data length │ body │ │ 2 字节 │ 1 字节 │ 1 字节 │ 8 字节 │ 4 字节 │ 变长 │ │ 0xdabb │ 序列化/ │ 响应码 │ 请求唯一标识 │ 报文体长度 │ 序列化后的 │ │ │ 请求标志 │ │ │ │ 对象字节 │ └────────┴────────┴────────┴─────────────────┴───────────────┴─────────────┘ ▲ 共 16 字节协议头,用于解决 TCP 粘包/拆包问题 ``` 为什么这个设计"快": 1. **固定长度头部 + 长度字段**:接收方先读 16 字节头,从 `data length` 知道后续要读多少字节,从而解决 TCP 流式协议的粘包/拆包问题,避免反复试探。 2. **`request id` 做多路复用**:同一条 TCP 连接上并发发多个请求,用 8 字节请求 ID 关联响应。这样**少量连接就能承载大量并发**,不必"一个请求一条连接"。 3. **二进制 + 紧凑序列化**:报文体用 Hessian2 等二进制序列化,相比 JSON 体积与解析开销都更小。 **适用边界**:`dubbo` 协议写死了 Dubbo 自己的协议头,非 Java 客户端要实现同样的编解码成本很高;同时报文是二进制的,抓包只能看到"魔数 + 长度",排查要看日志。所以它更适合"内网 Java 服务之间"。 ### Q:`triple` 协议呢?它和 `dubbo` 协议的核心取舍是什么? A:结论先行——`triple` 协议基于 **HTTP/2**,兼容 gRPC 语义,支持**流式调用**,优势是跨语言互通、易被网关与 Service Mesh 治理;代价是相比私有二进制协议**协议头开销更大**,并且**引入与默认值随版本变化大,必须结合版本确认**。 ```text 互联互通能力 传输开销 dubbo 协议 ●○○○○(基本只能 Dubbo 客户端) ●●●●●(最小) triple 协议 ●●●●●(HTTP/2 + gRPC 语义) ●●●○○(相对更大) 流式支持 网关/网格治理 dubbo 协议 不支持(一问一答) 需要专门适配 triple 协议 支持(四种流模式) 原生 HTTP/2 友好 ``` 选型建议: - 纯 Java 内网、调用量大、报文小、延迟敏感 → 优先 `dubbo`,生态最成熟、踩坑资料最多。 - 需要与非 Java 服务互通、需要流式(推送、大报文分片)、需要被 HTTP/2 网关统一治理 → 选 `triple`。 - 需要对外提供 REST 风格接口 → 用 `rest` 协议,或者更常见的是**在网关层用 HTTP/JSON 转 Dubbo**(网关持有 Dubbo 泛化调用,见生产实践篇)。 ### Q:多个协议能同时暴露吗?配置上要注意什么? A:结论先行——可以。一个服务可以同时用多个协议导出(多协议暴露),典型做法是"内网走 `dubbo`、对外走 `triple`/`rest`"。配置上最需要注意的是**端口冲突**与**协议对应的序列化配置**。 ```yaml # 解决什么问题:同一个服务同时用 dubbo 和 triple 暴露,分别服务内部调用与跨语言调用 dubbo: application: name: stock-service protocols: d1: # 协议配置的 key,可自定义名字 name: dubbo port: 20880 serialization: hessian2 t1: name: triple port: 50051 provider: protocol-ids: d1,t1 # 关键:声明该 Provider 使用哪几个协议 timeout: 3000 ``` ```java // 解决什么问题:注解方式声明本服务同时用两个协议暴露(配置项名称需结合版本确认) @DubboService(protocol = {"d1", "t1"}) // 2.7.7+ / 3.x 支持 public class StockServiceImpl implements StockService { @Override public int query(Long skuId) { return stockMapper.selectCount(skuId); } } ``` 关键点与边界: - `protocol-ids`(`protocol` 属性 / 注解的 `protocol` 属性)决定 Provider 用哪些协议导出;**不写则用默认协议**。不同版本配置项名称可能为 `protocol` 或 `protocol-ids`,需结合版本确认。 - **端口必须互不冲突**,并且在容器/防火墙中都要放通。 - 多协议暴露会让注册中心里的 URL 变多(每个协议一条),如果同时有接口级/应用级服务发现的迁移,排查"发现不到"时一定要先看清"注册了哪个协议的 URL"。 - 多协议会**成倍增加暴露面**(端口、安全策略、网关路由),非必要不要为了"以后可能用得上"提前暴露。 ## 三、序列化机制与选型 ### Q:为什么序列化这么关键?它到底影响什么? A:结论先行——序列化(Serialize)决定了**报文体大小**与**CPU 开销**,同时决定了**跨版本兼容性**和**安全边界**。选错了序列化,轻则带宽与延迟上升,重则升级时大面积"反序列化失败"。  *图:序列化与反序列化:两处开销所在* ```text 序列化位置(Provider 返回时方向相反) 业务对象 ──序列化──▶ 字节数组 ──写入 TCP──▶ ... ──读取字节──▶ 反序列化 ──▶ 业务对象 ▲ ▲ CPU 开销大头 ClassLoader 与 (尤其大对象/嵌套集合) 类型兼容性敏感区 ``` 三类影响展开: 1. **性能**:序列化后的字节数直接决定网络传输量;序列化/反序列化的 CPU 开销在高 QPS 下会成为瓶颈。**注意:不要相信任何"某某序列化比某某快 N 倍"的固定结论,它与对象结构、字段数量、是否含大集合强相关,必须用你自己的业务对象压测。** 2. **兼容性**:Provider 加了字段、改了字段类型、改了类名,Consumer 用旧版本反序列化会失败或得到默认值。这是**发布期间最常见的故障类型之一**。 3. **安全**:部分序列化(尤其是 Java 原生序列化)存在反序列化漏洞风险,Dubbo 也因此在序列化选择、类检查(`serialize.check.status` 之类开关)上有持续加固,**具体开关与默认行为需结合版本确认**。 ### Q:Dubbo 常见序列化方式怎么选? A:结论先行——`dubbo` 协议的默认序列化是 **Hessian2**(需结合版本确认);`triple` 协议默认走 **Protobuf** 语义(部分版本支持 Hessian2 等非 Protobuf 模式)。除此之外常见选择有 **Fastjson2**、**JDK 原生**、**Kryo**、**FST**、**Protostuff**、**Avro** 等。**内部 Java 调用优先 Hessian2;有跨语言/契约需求优先 Protobuf;JDK 原生序列化不要用于生产。** | 序列化 | 跨语言 | 可读性 | 兼容性策略 | 适用场景 | 主要风险 | | --- | --- | --- | --- | --- | --- | | Hessian2 | 弱(有规范但生态少) | 二进制 | 字段增删相对友好 | `dubbo` 协议默认,Java 内部调用 | 复杂对象/循环引用需注意;某些类型转换行为需验证 | | Protobuf | 强 | 需 `.proto` | 有明确的兼容规则 | `triple`、跨语言、强契约 | 需要维护 IDL;字段编号改错会破坏兼容 | | Fastjson2 | 弱 | 文本/JSON | 较宽松 | 便于调试、与 JSON 生态互通 | 文本体积大;类型信息处理需谨慎 | | JDK 原生 | 无 | 二进制 | 依赖 `serialVersionUID` | 学习/临时验证 | 体积大、慢、安全风险高,**生产禁用** | | Kryo / FST | 无 | 二进制 | 需注册类 | 对性能有极致要求且能统一客户端 | 类注册维护成本高;版本升级兼容性差 | | Protostuff | 弱 | 二进制 | 基于 Protobuf 规则 | Java 内部想用 Protobuf 又不写 IDL | 生态与维护活跃度相对一般 | 配置方式(Consumer/Provider 均可配,**优先级遵循"精确优先、Consumer 优先"**): ```xml <!-- 解决什么问题:显式指定序列化方式,避免依赖默认值带来的版本不确定性 --> <dubbo:protocol name="dubbo" port="20880" serialization="hessian2"/> <dubbo:reference id="stockService" interface="com.example.StockService" serialization="hessian2"/> ``` ```yaml # 3.x 常见 YAML 写法 dubbo: protocol: name: dubbo port: 20880 serialization: hessian2 ``` ### Q:序列化这块最常见的坑有哪些? A:结论先行——高频坑集中在四类:**跨版本字段变更、特殊类型处理、大对象与嵌套结构、多语言契约不一致**。 1. **字段变更导致兼容性问题**。DTO(Data Transfer Object)增删字段、改类型(`Integer` → `String`)、改类名/包名,都可能让对端反序列化失败。**做法**:接口与 DTO 视作"对外契约",变更走"先加后删"(先发消费端容忍新字段,再发提供端启用),不要在老字段上直接改类型。 2. **特殊类型跨序列化行为不一致**。`BigDecimal` 精度、`LocalDateTime`/`Instant` 时区、`Enum` 的按名还是按序号、`null` 与空集合的区分,在不同序列化下行为可能不同。**做法**:跨服务传输统一用"约定过的类型",例如时间统一用 `Long` 时间戳或 ISO 字符串,枚举统一传 `String` code。 3. **大对象与深嵌套**。大 `List`/`Map` 嵌套会让序列化 CPU 与内存放大,容易触发传输大小限制(`dubbo` 协议默认报文上限 8MB 量级,**务必结合版本确认并显式配置**)与 GC 压力。 4. **多语言契约不一致**。Java 里一个 `Map<String, Object> genericParam` 在 Go 侧可能无法直接映射,需要用 `triple` + `.proto` 明确定义结构。**做法**:跨语言接口不要用"泛型 + Object"这种弱类型结构。 关于"序列化器能否被双方识别"还有一个机制点:`dubbo` 协议的协议头里携带了序列化方式的标识位,**当 Consumer 与 Provider 配置的序列化不一致时,可能出现"收到但反序列化报错"或"无法识别序列化方式"**。这类报错的关键字通常与 `Serialization`、`Codec` 相关,遇到时**先核对两端 `serialization` 配置与版本是否一致**。 ## 四、线程模型与 Dispatcher 策略 ### Q:Dubbo 的线程模型里,有哪几类线程?各自干什么? A:结论先行——Dubbo(基于 Netty 的传输实现)里主要有三类线程:**Netty Boss 线程(接受连接)、Netty Worker IO 线程(读写数据、编解码)、业务线程池线程(执行你的服务实现)**。`Dispatcher` 决定"哪些消息从 IO 线程派发到业务线程池",`ThreadPool` 决定"业务线程池长什么样"。  *图:线程模型:IO 线程解码后派发到业务线程池* ```text ┌──────────────┐ ① accept ┌───────────────────────────┐ │ Netty Boss │ ────────────▶ │ Netty Worker(IO 线程, │ │ 线程(少量) │ 建立连接 │ 数量通常与 CPU 相关,较少) │ └──────────────┘ └─────────────┬─────────────┘ │ ② 解码(Codec + 反序列化) ▼ ┌──────────────────────┐ │ Dispatcher 决策 │ │ 派发 or 就地执行 │ └──────────┬───────────┘ │ ③ 派发 ▼ ┌──────────────────────┐ │ 业务线程池 │ │ fixed/cached/eager/ │ │ limited(含队列与拒绝)│ └──────────┬───────────┘ │ ④ 执行 ▼ ┌──────────────────────┐ │ Invoker → 服务实现类 │ └──────────────────────┘ ``` 关键点: - **IO 线程数量远少于业务线程**(业务线程池默认量级是 200,**需结合版本确认**;IO 线程数量则和 Netty 配置、CPU 核数相关)。 - **反序列化通常发生在 IO 线程**(解码阶段的一部分),所以"报文特别大 / 反序列化特别慢"会直接占用 IO 线程,这时候业务线程池再大也没用。 - 业务线程池的存在,目的就是**把耗时业务逻辑从 IO 线程上剥离**,避免阻塞网络收发。 ### Q:Dispatcher 的五种策略分别是什么?默认是哪个? A:结论先行——`Dispatcher` 有 `all`(默认)、`direct`、`message`、`execution`、`connection` 五种策略,区别在于"哪些消息交给业务线程池"。**默认是 `all`,即所有消息(请求、响应、连接事件、心跳)都派发到线程池。** | 策略 | 请求 | 响应 | 连接/断开事件 | 心跳 | 说明 | | --- | --- | --- | --- | --- | --- | | `all`(默认) | 派发 | 派发 | 派发 | 派发 | 全部走业务线程池,隔离最彻底,但对线程池依赖最重 | | `direct` | 不派发 | 不派发 | 不派发 | 不派发 | 全部在 IO 线程执行,延迟最低但**极易被阻塞拖死** | | `message` | 派发 | 派发 | 就地执行 | 就地执行 | 只把请求/响应交给线程池 | | `execution` | 派发 | 就地执行 | 就地执行 | 就地执行 | **只把"请求"交给线程池**,响应与心跳留在 IO 线程 | | `connection` | 派发 | 派发 | 队列化逐个执行 | 派发 | 连接事件单独排队串行执行 | **为什么默认 `all` 有时反而会出问题**(重要且反直觉):既然所有消息都要进业务线程池,那么当**业务线程池被打满**时,**心跳消息也会被排队**——心跳(heartbeat)得不到及时处理,连接对端会认为"这条连接没响应",进而**主动断开连接**。这会造成"服务不是慢,而是连接被断"的现象。 因此有一类常见优化建议是:**把 Dispatcher 调整为 `execution`(或至少 `message`)**,让心跳与响应在 IO 线程上尽快处理,只有业务请求进线程池。**但这不是无条件最优**:`execution` 意味着"响应处理在 IO 线程",如果响应处理里有耗时逻辑(比如大对象序列化),又会反过来阻塞 IO 线程。**结论:策略选择取决于你的瓶颈在哪,不要照搬。** 配置方式: ```xml <!-- 解决什么问题:让心跳与响应不被业务线程池排队拖累 --> <dubbo:protocol name="dubbo" port="20880" dispatcher="execution"/> ``` ### Q:线程池类型有哪些?默认的 `fixed` 为什么容易"打满即报错"? A:结论先行——常见线程池类型有 `fixed`(默认)、`cached`、`limited`、`eager`。**`fixed` 的默认线程数是 200、队列长度为 0,而"队列长度为 0"在实现上对应一个不缓存的队列(`SynchronousQueue` 语义):线程一满就直接触发拒绝策略**,这就是"线程池打满就立刻报错"的根源(默认值**需结合版本确认**)。 | 线程池 | 核心/最大线程 | 队列默认 | 特点 | 适用 | | --- | --- | --- | --- | --- | | `fixed`(默认) | 固定(默认 200) | 0(不缓存) | 线程数固定、队列不缓冲,满即拒绝 | 逻辑耗时可控、希望"快速失败" | | `cached` | 核心较小 / 最大很大 | 0(不缓存) | 用完即回收,尖峰时可暴涨线程 | 调用耗时波动大、并发瞬时尖峰 | | `limited` | 固定 | 有界(默认 0,可配) | 类似 fixed,但可控 | 需要固定线程 + 排队缓冲 | | `eager` | 核心较小 / 最大较大 | 有界 | 线程不够时优先新建线程而非入队,减少排队延迟抖动 | 对延迟抖动敏感 | 关键机制说明: - **队列长度为 0 时用的是"不缓存"的队列**:只有当有空闲线程时任务才能立刻被接手,否则直接走拒绝策略。所以 `fixed` 的表现是"并发超过 200 就报错",而不是"变慢"。**这是生产上"偶发 `RejectedExecutionException`"的直接原因。** - **`AbortPolicyWithReport`**:Dubbo 默认的拒绝策略不是静默丢弃,而是**抛出异常并打印线程栈与诊断信息**(含线程名、URL 等),这是排查"谁把线程占了"的关键线索,日志里一定要保留。 - **想"排队缓冲"就要显式配队列长度**:例如把 `queues` 配成一个正数(对 `fixed` 而言相当于有界队列,满了才拒绝)。**代价是延迟上升**:请求排队时间计入总耗时,容易触发调用方超时,形成"越忙越超时"。 ```yaml # 解决什么问题:给业务线程池留一点缓冲,同时保留快速失败能力 dubbo: protocol: name: dubbo port: 20880 threads: 300 # 线程数(默认 200 量级,需结合版本确认) threadpool: fixed queues: 100 # 队列长度 100,满了才拒绝 ``` **适用边界**:调大队列是"把崩溃变成变慢",调大线程数是"把 CPU 压力变大"。真正的解法是**让业务逻辑变快**(减少同步阻塞、缩短 DB/第三方调用、避免在 Provider 里做重活),或者**从源头限流**(见治理篇的并发控制)。 ### Q:Dispatcher 与 ThreadPool 是什么关系?为什么"不能在 IO 线程做阻塞操作"? A:结论先行——`Dispatcher` 决定"消息去哪执行",`ThreadPool` 决定"业务线程池长什么样",两者独立配置、组合生效。**不能在 IO 线程做阻塞操作的根本原因是:IO 线程数量很少且被大量连接共享,一旦被阻塞,同一条 IO 线程上其他连接的所有请求都会被卡住,表现为大面积超时、心跳失败、连接被判死。**  *图:IO 线程被阻塞:连接排队与心跳超时* ```text 假设 IO 线程数 = 8,承载 500 条连接 正常情况:8 个 IO 线程快速分发 → 业务线程池执行 → IO 线程立即回到下一个事件 阻塞情况:某请求在 IO 线程里 sleep/等锁/同步调外部接口 5 秒 ┌───────────────────────────────────────────────┐ │ IO 线程 #3 被占用 5s │ │ └─ 该线程上其余几十条连接的读写事件全部排队等待 │ │ └─ 心跳无法及时回复 → 对端判定连接失活 → 断开 │ │ └─ 业务线程池即使空闲,也无事可做(请求还没派发) │ └───────────────────────────────────────────────┘ ``` 典型的"在 IO 线程阻塞"的行为(自己写 Filter 或扩展时最容易犯): - 在 `Filter` 里做同步 HTTP/RPC 调用、`Thread.sleep`、等待 `CountDownLatch`。 - 在自定义 `Codec` 或序列化扩展里做重 IO。 - 把 `Dispatcher` 配成 `direct`,然后业务实现里做数据库/第三方调用——**`direct` 就是把业务逻辑直接放在 IO 线程上跑,除非你确定逻辑是纯 CPU 且极快,否则不要用**。 **实践结论**: - 默认保持 `all`(或按上文权衡改成 `execution`),**让业务逻辑始终跑在业务线程池里**。 - 自定义 Filter 里如果要调用外部依赖,必须有超时与熔断,且尽量异步。 - 排查"IO 线程阻塞"的证据来源是**线程栈(jstack)**:看 `NettyServerWorker` 之类线程名(不同版本命名不同,**需结合版本确认**)是否卡在业务代码上。 ## 五、连接模型与 IO/业务线程边界 ### Q:"单一长连接 + 多路复用"到底是什么意思?为什么要这么设计? A:结论先行——**单一长连接**指一个 Consumer 对一个 Provider(的服务)默认复用**一条** TCP 连接(`connections` 默认为 0,表示共享连接,需结合版本确认);**多路复用**指这条连接上可以并发跑多个请求,通过协议头里的 `request id` 与响应配对。好处是**连接数少、握手开销小、资源占用低**;代价是**所有请求共享同一个 IO 线程的读写能力,存在"队头/大报文"影响**。  *图:一请求一连接与多路复用的连接数对比* ```text 不用多路复用(一请求一连接) 用多路复用(一条连接跑 N 个请求) ┌──────┐ conn1 → req A ┌──────┐ conn1 ═════════════════▶ │ Cons │ conn2 → req B │ Cons │ req A(id=1) │ │ conn3 → req C │ │ req B(id=2) 并发 └──────┘ ... 连接数爆炸 └──────┘ req C(id=3) ▲ 响应按 id 回填各自的 Future ```  *图:request id 复用:乱序响应唤醒对应 Future* ```text request id 复用示意(客户端侧) 发出 req(1) req(2) req(3) (同一连接,交错写入) 收到 resp(2) resp(1) resp(3) (返回顺序可乱序) │ │ │ ▼ ▼ ▼ Future(2) Future(1) Future(3) ← 按 id 找到对应的等待者并唤醒 ``` 多路复用带来的两个实践要点: 1. **请求 ID 必须唯一且长期不冲突**:这是"响应不会串"的前提,框架内部保证,但**自定义协议/编解码扩展时要特别小心**。 2. **同一条连接上的大报文会挤占其他请求**:如果某个接口返回 8MB 的大报文,它在单条连接上传输时,同连接的其他小请求也要排队等带宽。这正是"大数据量传输"要做单独治理(单独接口、单独连接数、避免大报文)的原因,详见生产实践篇。 ### Q:`connections` 该怎么配?什么时候需要多连接? A:结论先行——默认 `connections=0` 表示"该服务所有方法共享一条连接"。当出现"单连接成为瓶颈"时(比如同一服务里有超大报文接口、或单连接吞吐打满),可以把 `connections` 调到 N,为该 Provider 建立 N 条连接并在其上做负载。 ```xml <!-- 解决什么问题:给调用量大或报文大的服务分配更多连接,避免单连接成为瓶颈 --> <!-- connections="5":与该 Provider 建立 5 条连接 --> <dubbo:reference id="reportService" interface="com.example.ReportService" connections="5" timeout="10000"/> ``` 使用边界: - **大多数服务不需要调**。默认共享连接在同连接多路复用的支撑下,吞吐通常够用;盲目调大等于"人为放大连接与内存开销"。 - **"连接数"和"IO 线程"是两笔账**:增加连接会增加 IO 事件,但 IO 线程数并不会自动增加,所以"单连接瓶颈"换成"多连接"之后,瓶颈可能转移到 IO 线程或业务线程池。 - **`lazy` 参数**决定连接是"启动即建"还是"首次调用才建"(`lazy=true` 延迟连接)。**生产建议保持启动即连**,否则"首次调用"会因为建连而额外增加一次超时风险;但这也意味着 Consumer 启动时会去连所有 Provider,**Provider 数量很多时启动耗时与连接数要评估**。 ### Q:把 IO 线程与业务线程的边界总结成可执行的规则 A:结论先行——一条简单规则:**IO 线程只做"收发与编解码",其余一切(业务逻辑、外部依赖、锁等待、大计算)都必须在业务线程池里做**;写扩展时把这条规则当红线。 | 位置 | 允许做的事 | 禁止做的事 | | --- | --- | --- | | Netty Boss 线程 | accept 连接 | 任何阻塞逻辑 | | Netty Worker(IO)线程 | 读写字节、编解码、快速派发 | 业务逻辑、DB/外部 RPC、锁等待、`sleep` | | 业务线程池 | 业务逻辑、外部依赖调用(带超时) | 无界阻塞、无超时调用 | | Filter(默认在业务线程池) | 鉴权、日志、埋点、限流 | 同步阻塞调用且无超时 | 排查线索速查表: | 现象 | 优先怀疑 | 看什么 | | --- | --- | --- | | 大面积超时、心跳失败 | IO 线程被阻塞 / 线程池打满 | jstack 看 IO 线程与业务线程栈、找 `RejectedExecutionException` | | 偶发 `RejectedExecutionException` | `fixed` + 队列 0,线程打满 | 线程池配置、业务耗时 P99 | | 调用方超时但服务端日志显示处理很快 | 请求在队列里排队 / 序列化慢 / 网络 | 服务端排队时间、报文大小 | | 反序列化报错 | 两端序列化配置/版本不一致、DTO 变更 | 两端 `serialization` 配置、接口契约变更记录 | ## 小结 - **通信链路**:代理 → Cluster → Protocol → Exchange(Request)→ Codec/Serialize → Netty → TCP → Netty Server → Dispatcher → 业务线程池 → Invoker → 实现类。排查问题时按这条链分段定位。 - **协议**:`dubbo`(私有二进制、长连接多路复用,Java 内网首选)与 `triple`(HTTP/2、跨语言、流式)是两条主线;`rest` 用于 REST 风格对外接口。**默认协议与端口在不同版本下不同,必须结合版本确认。** - **序列化**:`dubbo` 默认 Hessian2、`triple` 默认 Protobuf 语义(版本相关)。选型围绕"跨语言需求 / 体积 / 兼容性 / 安全"四个维度;**JDK 原生序列化生产禁用**;DTO 当契约管理,做到"先加后删"。 - **线程模型**:Dispatcher 五种策略(`all` 默认 / `direct` / `message` / `execution` / `connection`),线程池四类(`fixed` 默认 / `cached` / `limited` / `eager`)。**`fixed` 默认队列长度为 0 → 线程满即刻拒绝**,这是偶发报错的直接原因。 - **红线**:IO 线程只做收发与编解码,任何阻塞操作都会拖垮同线程上的所有连接(表现为超时、心跳失败、连接断开)。用 `execution`/`message` 可以在线程池打满时保护心跳,但要权衡响应处理是否耗时。 - **连接模型**:单一长连接 + `request id` 多路复用是默认形态(`connections=0`);大报文或高吞吐服务才考虑增加 `connections`,并同步评估 IO 线程与业务线程容量。 ## 思考题 1. 你的服务出现"偶发 `RejectedExecutionException`",日志里能看到线程栈。你会先看哪几个配置项?把 `queues` 从 0 改成 100 之后,报错少了但超时多了,为什么? 2. 为什么把 `Dispatcher` 从 `all` 改成 `execution` 能缓解"线程池打满导致连接被断"?改成 `execution` 之后可能引入什么新问题? 3. 假设某接口返回一个包含 10 万条记录的 `List`,在"单一长连接 + 多路复用"模型下会产生什么连锁影响?你会怎么治理? 4. `dubbo` 协议和 `triple` 协议都支持长连接多路复用吗?它们在"响应配对"上的实现差异是什么? 5. 你要把 Provider 从 Hessian2 迁移到 Protobuf,接口和 DTO 需要做哪些准备?迁移过程中如何保证新旧版本 Consumer 都能调用成功?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入