知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# Dubbo 服务治理:负载均衡与集群容错 > 导读:本文从"为什么一次偶发超时最后变成了雪崩"这个具体的痛点出发,把 Dubbo 的负载均衡策略、集群容错策略、失败重试与幂等性的关系、路由与标签路由、服务降级与并发/连接数控制、超时机制与超时传递逐项讲透,最后给出生产用法与踩坑。适合已经能把 Dubbo 服务跑起来、但在生产上被"超时、抖动、灰度、降级"折腾过的同学。 ## 一、先建立全局认知 ### Q:从 Consumer 发起调用到真正打到某台 Provider,中间的"治理层"经历了什么? A:结论先行——Consumer 侧在 Cluster 层做的事是一条固定的流水线:**服务目录(Directory)给出候选列表 → 路由(Router)过滤出可用列表 → 负载均衡(LoadBalance)选出一台 → 集群容错(Cluster)负责调用与失败处理**。理解这条流水线,就能解释"为什么配置都对但请求打到了不该打的机器上"。  *图:Dubbo 服务治理:Directory → Router → LoadBalance → Cluster* ```text ┌──────────────────────────────── Cluster 层(Consumer 侧) ────────────────────────────────┐ │ │ │ ① Directory(服务目录) ② Router(路由) ③ LoadBalance(负载均衡) │ │ ┌───────────────────┐ ┌───────────────────┐ ┌───────────────────┐ │ │ │ 注册中心推送的 │ 全量 │ 条件路由 / 标签路由 │ 可用 │ 加权随机/轮询/最少 │ │ │ │ Provider 列表缓存 │ ───────▶ │ / 脚本路由 逐层过滤 │ ────▶ │ 活跃/一致性哈希... │ 选出 1 │ │ │ (含权重、协议等) │ │ │ │ │ 个 Invoker│ │ └───────────────────┘ └───────────────────┘ └─────────┬─────────┘ │ │ ▼ │ │ ④ Cluster(集群容错) │ │ Failover / Failfast / Failsafe │ │ / Failback / Forking │ │ / Broadcast / Available │ │ │ │ │ ⑤ MockClusterInvoker(降级) │ └───────────────────────────────────────────────────────────────────────┼──────────────────┘ ▼ 实际 Invoker(走协议层发请求) ``` 流水线上每一步的职责与失败表现: | 环节 | 职责 | 出问题时的典型现象 | | --- | --- | --- | | Directory | 维护从注册中心拿到的 Provider 列表,接收推送更新 | 列表为空 → "No provider available" | | Router | 按规则过滤(标签、条件、脚本) | 过滤后为空 → 同样报"无可用 Provider",但注册中心里明明有 | | LoadBalance | 从可用列表里选一台 | 流量严重倾斜、慢节点被打爆 | | Cluster | 调用 + 失败重试/切换 | 重试导致的重复写、放大流量 | | Mock | 兜底降级 | 该降级没降、或该报错却静默返回空 | ### Q:Dubbo 的服务治理能力全景是什么样的? A:结论先行——治理能力可以分成五组:**选址(路由 + 负载均衡)、容错(集群策略 + 重试 + 降级)、流控(并发数、连接数、线程池)、时间(超时)、观测(监控)**。这五组能力大部分通过 URL 参数驱动,因此都可以"动态生效"。 | 能力组 | 关键配置项 | 说明 | | --- | --- | --- | | 选址-负载均衡 | `loadbalance`、`weight` | 选哪台机器 | | 选址-路由 | `tag`、条件路由规则、脚本路由规则 | 从哪些机器里选 | | 容错 | `cluster`、`retries`、`forks` | 失败怎么办 | | 降级 | `mock` | 兜底返回什么 | | 流控 | `actives`、`executes`、`accepts`、`connections` | 限制并发与连接 | | 时间 | `timeout` | 等多久算失败 | | 观测 | `Monitor`、日志 | 看得到才治得了 | **这一篇的重点是前四组**(选址、容错、降级、流控 + 时间),因为它们直接决定"线上出事时系统的行为"。 ## 二、负载均衡策略:选哪台机器 ### Q:Dubbo 有哪几种负载均衡策略?默认是哪个? A:结论先行——常见策略有五种:**Random(加权随机,默认)、RoundRobin(加权轮询)、LeastActive(最少活跃调用数)、ConsistentHash(一致性哈希)、ShortestResponse(最短响应时间)**。默认是 `random`。 | 策略 | 扩展名 | 选择依据 | 权重支持 | 适用场景 | | --- | --- | --- | --- | --- | | 加权随机 | `random`(默认) | 按权重随机抽取 | 支持 | 通用场景,机器性能不均时用权重体现 | | 加权轮询 | `roundrobin` | 按权重平滑轮询 | 支持 | 机器性能接近、希望请求数均匀 | | 最少活跃调用数 | `leastactive` | 活跃数最少(相同则按权重随机) | 支持 | 后端处理耗时差异大,想让慢节点少接请求 | | 一致性哈希 | `consistenthash` | 相同参数总是落到同一台 | 支持 | 需要"同一用户/同一 key 固定路由"的场景 | | 最短响应时间 | `shortestresponse` | 统计窗口内响应最快 | 支持 | 后端节点性能差异大、希望自动避开慢节点 | 配置方式: ```xml <!-- 解决什么问题:把某个服务的负载均衡从默认的随机换成最少活跃 --> <dubbo:reference id="stockService" interface="com.example.StockService" loadbalance="leastactive"/> ``` ```yaml # 3.x 常见 YAML 写法 dubbo: consumer: loadbalance: random parameters: weight: 100 # 权重也可通过参数方式下发 ``` ### Q:`random` 与 `roundrobin` 的实际差别在哪里?权重从哪来? A:结论先行——`random` 是按权重比例随机、**长期看比例正确但短期有波动**;`roundrobin` 是**按权重平滑轮询**,长期与短期都均匀。**权重来自 Provider 暴露 URL 上的 `weight` 参数(默认 100,需结合版本确认)**,可以由 Provider 自己声明,也可以通过动态配置覆盖。 ```text 三台机器权重 5:3:2,发 10 个请求 random(加权随机):结果可能是 4:4:2 也可能是 6:2:2 —— 数量足够大才收敛到 5:3:2 roundrobin(平滑加权轮询):结果稳定接近 5:3:2,且请求交替分布,不会连续压同一台 ``` 权重声明与覆盖: ```xml <!-- 解决什么问题:性能更好的机器承接更多流量 --> <dubbo:provider interface="com.example.StockService"> <dubbo:parameter key="weight" value="200"/> </dubbo:provider> ``` ```yaml # 通过动态配置(配置中心)覆盖权重,可运行时生效 dubbo: provider: parameters: weight: 200 ``` **实践边界与坑**: - **权重是静态的,不会自动感知机器规格变化**。机器扩容到异构规格(8C/16C 混部)时,如果不刷新权重,流量会按旧比例分配,快机器吃不饱、慢机器被打爆。**结论:混部必须先统一权重,或改用具自动感知的策略 + 合理限流。** - **`roundrobin` 在 2.7 前后对"慢节点"的处理有过修复**(早期版本存在慢节点持续被轮到的现象)。**老版本升级时,注意确认轮询算法的行为是否符合预期。** - **`random` 不等于"完全随机"**:有权重时是按权重加权的随机,没配权重(或权重相同)时才退化为等概率随机。 ### Q:`leastactive` 和 `shortestresponse` 有什么区别?都号称"避开慢节点"。 A:结论先行——`leastactive` 看的是**"当前正在处理的请求数"(活跃数)**,是**瞬时负载**指标;`shortestresponse` 看的是**"统计窗口内的平均响应时间"**,是**历史性能**指标。前者反应快但只能体现"当前并发",后者更贴近"谁更快"但对突发变化反应慢。 ```text 场景:Provider A 很快(5ms),Provider B 很慢(200ms),当前都空闲 leastactive:两者活跃数都是 0 → 通常按权重随机 → B 仍可能分到一半流量,接了就慢 shortestresponse:A 的历史响应时间明显更短 → 优先选 A,B 被自然降权 ``` | 维度 | `leastactive` | `shortestresponse` | | --- | --- | --- | | 依据 | 活跃调用数(请求计数差) | 滑动窗口内的响应时间统计 | | 反应速度 | 快(当前状态) | 慢(依赖历史样本) | | 冷启动 | 新节点活跃数低,会先分到一些流量(有"预热"效果) | 新节点无样本,行为需结合版本确认 | | 风险 | 慢节点若持续空闲,仍会被分到请求 | 历史快的节点可能被持续加压,形成热点 | | 引入版本 | 较早版本即有 | **约 2.7.7 引入,需结合版本确认** | **结论**:`leastactive` 更适合"处理耗时差异大、且希望自然保护慢节点"的场景;`shortestresponse` 适合"机器规格/负载差异长期存在"的场景。两者都不要在没做压测验证的情况下直接上生产——它们都会改变流量分布,可能把原本次要的节点推成热点。 ### Q:`consistenthash` 的"相同参数固定路由"具体怎么理解?有哪些坑? A:结论先行——`consistenthash` 会把"方法参数"计算成哈希值并映射到一个哈希环上,让**同一组参数总是落到同一台 Provider**;默认虚拟节点数为 160,可通过 `hash.nodes`(虚拟节点数)与 `hash.arguments`(参与哈希的参数下标)调整(**默认值需结合版本确认**)。  *图:一致性哈希环:落点后顺时针找最近节点* ```text 哈希环(示意) ┌──────────────────────────────────┐ │ hash(param) 落点 │ │ P1' P2' P1'' │ │ ● ● ● │ │ ╲ │ │ │ ╲ │ 顺时针找最近节点 │ │ ▼ ▼ │ │ ● ● │ │ P3'' P2'' │ └──────────────────────────────────┘ 同一组参数总是顺时针找到同一个节点 → 稳定落点 ``` ```xml <!-- 解决什么问题:让同一个用户的请求固定落到同一台(如本地缓存命中、分片计算) --> <dubbo:reference id="userCacheService" interface="com.example.UserService" loadbalance="consistenthash"> <!-- 指定用第 0 个参数做哈希;虚拟节点数 320 --> <dubbo:parameter key="hash.arguments" value="0"/> <dubbo:parameter key="hash.nodes" value="320"/> </dubbo:reference> ``` 主要坑: 1. **节点上下线会导致"落点迁移"**:哈希环上的虚拟节点空间本身是不均匀的,扩缩容时部分 key 会重新映射到新节点。**如果落点变化会导致数据不一致(比如本地缓存、幂等状态),必须由业务侧兜底**。 2. **虚拟节点数不是越大越好**:虚拟节点越多,分布越均匀,但在 Consumer 侧参与哈希环的节点数量也更多,**构建与查询开销上升**。默认值通常够用。 3. **参数必须"稳定且可哈希"**:如果参与哈希的参数是随机 ID、时间戳,一致性哈希就退化成随机。**用于哈希的参数要选业务上稳定的维度(用户 ID、租户 ID、订单号)。** 4. **`hash.arguments` 的下标从 0 开始**,配错下标(比如想用用户 ID 却配了第 2 个参数)会得到"看起来随机"的结果,非常难排查。 ## 三、集群容错与失败重试 ### Q:Dubbo 的七种集群容错策略分别是什么? A:结论先行——常用的是 `failover`(失败切换,**默认**)、`failfast`(快速失败)、`failsafe`(失败安全,忽略异常)、`failback`(失败自动恢复,后台重发)、`forking`(并行调用取最快)、`broadcast`(广播调用所有)、`available`(调用第一台可用的)。**选择容错策略的核心依据是"这个操作是否幂等"以及"是否可以接受部分失败"。** | 策略 | 扩展名 | 行为 | 典型适用 | 风险 | | --- | --- | --- | --- | --- | | 失败切换 | `failover`(默认) | 失败后换一台重试,默认重试 2 次 | 幂等的读操作、可重试写 | **非幂等操作会重复执行** | | 快速失败 | `failfast` | 只调用一次,失败立即抛异常 | 非幂等写操作(下单、扣款) | 瞬时抖动直接失败 | | 失败安全 | `failsafe` | 出错时忽略,返回空结果 | 日志上报、审计、埋点 | 错误被静默吞掉 | | 失败恢复 | `failback` | 失败后记录到失败队列,定时重发 | 消息通知、可延迟补偿的场景 | 重发时机与幂等需自己保障 | | 并行调用 | `forking` | 同时调多个(`forks` 默认 2),一个成功即返回 | 对延迟极敏感、可接受的读操作 | 放大流量;慢请求继续占用资源 | | 广播调用 | `broadcast` | 逐个调用所有 Provider,任一失败即失败 | 缓存刷新、本地资源清理 | 全量放大;一个失败全盘失败 | | 可用优先 | `available` | 遍历找到第一个可用的 | 希望"尽量别报错"的场景 | **不重试、不做健康判断,会反复打到坏节点** | 配置方式: ```xml <!-- 解决什么问题:非幂等的写操作不要重试,避免重复扣款/重复下单 --> <dubbo:reference id="payService" interface="com.example.PayService" cluster="failfast"/> ``` ```yaml dubbo: consumer: cluster: failover retries: 2 ``` ### Q:`failover` 默认重试几次?为什么说"重试必须配合幂等"是最重要的坑? A:结论先行——`failover` 的 `retries` **默认是 2,加上第一次调用共 3 次请求**(**默认值需结合版本确认**)。如果被调用的方法不是幂等的,这 3 次请求会被重复执行,直接产生"重复下单、重复扣款、重复发券"等数据问题。**结论:不要靠"服务一定不会失败"来赌,要么让写操作幂等,要么对写操作显式关闭重试。**  *图:未配幂等加 failover:重试导致重复扣款* ```text 未配幂等 + failover(retries=2)的典型事故 Consumer ──① 扣款请求 ──▶ Provider(执行成功,但返回时网络抖动/超时) ──② 重试(换一台)──▶ Provider(第 2 次扣款) ──③ 重试(再换一台)──▶ Provider(第 3 次扣款) ▼ 用户被扣了 3 次钱、下了 3 个订单 ``` **重复执行的两大来源要分清**: 1. **框架层重试**(本篇主讲):`failover` 的重试、`forking` 的并行、`failback` 的定时重发。 2. **调用方自己的重试**:上层网关/前端也有重试逻辑,与框架重试叠加,形成乘法效应。 正确的做法(按优先级): - **首选:让写操作幂等**。用业务唯一键(订单号、请求流水号)在 Provider 侧做去重,重复请求返回第一次的结果。 - **次选:对写操作关闭重试**。配置 `retries="0"`(不同版本语义一致:失败后不再重试)或改用 `failfast`。 - **注意区分"读"和"写"**:同一个服务里读方法可以重试、写方法不能。**Dubbo 支持方法级配置**,可以按方法粒度设置 `retries`。 ```xml <!-- 解决什么问题:按方法粒度治理重试,读重试、写不重试 --> <dubbo:reference id="orderService" interface="com.example.OrderService" loadbalance="random"> <!-- 查询方法:允许重试 2 次 --> <dubbo:method name="queryOrder" retries="2" timeout="1000"/> <!-- 写方法:不重试,快速失败 --> <dubbo:method name="createOrder" retries="0" timeout="3000" cluster="failfast"/> </dubbo:reference> ``` **其他"看起来没问题其实有雷"的点**: - **`failsafe` 会把异常静默吞掉**:如果用在关键业务上,会出现"日志里啥也没有、业务以为成功了"的灾难。只用于"错误不影响主流程"的场景。 - **`broadcast` 一个失败全盘失败**:用于"刷新所有节点缓存"时,任何一台失败都会让整个调用失败,**需要评估是否可接受**。 - **`available` 不做健康判断**:它只是"遍历找第一个能连上的",并**不会**帮你避开"能连上但业务一直失败"的节点。 - **重试会放大下游流量**:下游已经快挂了,上游 3 倍放大流量会让它彻底挂掉。**重试必须配合"熔断/限流/超时收紧",否则重试就是雪崩加速器。** ### Q:`forking` 与 `failback` 的适用场景再具体一点? A:结论先行——`forking` 解决"延迟要最短"(用资源换延迟),适用于**读操作且资源充足**;`failback` 解决"最终一定要成功",适用于**可以延迟重发且天然幂等**的通知类场景。两者都**不适合非幂等写**。 ```xml <!-- forking:同时打 3 台,取最快返回;forks 默认 2(需结合版本确认) --> <dubbo:reference id="quoteService" interface="com.example.QuoteService" cluster="forking"> <dubbo:parameter key="forks" value="3"/> </dubbo:reference> ``` `forking` 的成本账:一次业务调用会产生 `forks` 个请求,被选中的 Provider 数量与实际并发成正比。**在 QPS 高的服务上使用 `forking`,等于把下游流量乘以 `forks`**,很可能直接把下游打挂。 `failback` 的机制是"失败后进入失败队列,由后台线程按间隔重试"。**重试间隔、重试次数上限、失败队列容量这些细节在不同版本中实现不同,需结合版本确认**;并且**失败队列在内存里,进程重启会丢失**——所以它不能当作可靠消息队列使用。要"最终一定成功",正解是本地消息表 / MQ 事务消息这类带持久化的方案。 ## 四、路由与标签路由 ### Q:Dubbo 的路由规则是怎么工作的?有哪些类型的路由? A:结论先行——路由(Router)在"目录给出全量列表"和"负载均衡选一台"之间做**过滤**:它按规则把不符合条件的 Provider 剔除。常见类型有**条件路由(ConditionRouter)、标签路由(TagRouter)、脚本路由(ScriptRouter)**,以及框架内部的应用级/服务级路由。  *图:路由过滤链:条件路由与标签路由逐层收窄* ```text 全量列表 ──▶ 条件路由(按 host/method/参数过滤)──▶ 标签路由(按 tag 过滤)──▶ 最终可用列表 如果路由把列表过滤为空,调用方会报"无可用 Provider" ``` 条件路由的规则语法是"**消费者匹配条件 => 提供者匹配条件**": ```text # 示例规则(语法示意,实际以配置中心/规则下发为准) # 含义:来自 10.20.153.10 的消费者,只能调用 10.20.153.11 上的提供者 host = 10.20.153.10 => host = 10.20.153.11 # 含义:find* 开头的方法,只能调用非 10.20.153.11 的提供者 method = find* => host != 10.20.153.11 # 含义:所有消费者(无限制)只能调用带 tag=gray 的提供者 => tag = gray ``` **关键机制**:当"消费者匹配条件"为空时,表示对所有消费者生效;当"提供者匹配条件"为空时,表示禁用访问(即过滤掉所有提供者)。**这个"空表示禁用"的语义是排查路由问题时最容易踩的坑——写了半条规则,结果把服务全禁了。** ### Q:标签路由(tag)怎么做灰度发布? A:结论先行——标签路由的做法是:**给一部分 Provider 打上 `tag`(如 `gray`),给指定 Consumer 或指定请求设置同名 `tag`,这样只有带该 tag 的 Consumer 会走到带该 tag 的 Provider**。它是 Dubbo 里最常用的"按流量维度灰度"手段。 ```yaml # Provider 侧:把这批实例标记为 gray(灰度分组) dubbo: provider: tag: gray ``` ```xml <!-- Consumer 侧:让整个应用只调用 gray 分组 --> <dubbo:consumer tag="gray"/> ``` ```java // 解决什么问题:按"单次请求"维度做灰度,而不是整个应用 // 在调用前把 tag 放进附件(attachment),随请求传递 RpcContext.getContext().setAttachment("dubbo.tag", "gray"); try { orderService.createOrder(req); // 这次调用会走 gray 分组 } finally { RpcContext.getContext().clearAttachments(); // 关键:一定要清理,否则污染后续调用 } ``` 关键点与边界: 1. **`force` 语义很关键**:标签路由在"找不到对应 tag 的 Provider"时,是**降级到全量列表**还是**直接报错**,由强制开关决定。**这个开关的默认值与配置项名称需结合版本确认。** 如果灰度期间不希望流量"悄悄跑到非灰度节点",必须配置为强制;反之如果希望"灰度节点挂了能自动回全量",则要允许降级。 2. **`RpcContext` 是线程绑定的、且会在调用结束后清理**,但**在异步调用、线程池复用场景下容易残留**。用 `setAttachment` 一定要配对 `clearAttachments`,否则会出现"某个请求莫名其妙走了灰度"。 3. **标签路由是"软"治理手段**:它依赖注册中心推送的 tag 信息与 Consumer 的订阅匹配,**Provider 数量、tag 分布变化时会实时影响路由结果**,灰度期间要盯紧"两个分组的实例数"。 4. **多维度灰度(按用户、按比例)不能用标签路由单独实现**:标签路由只能按 tag 整体切分。按用户 ID 做灰度通常要结合条件路由 / 脚本路由,或者直接用应用层的灰度开关。 ## 五、服务降级、并发控制与超时 ### Q:Dubbo 的 Mock 降级怎么用?有哪几种写法? A:结论先行——Mock 是 Consumer 侧的兜底机制:当调用失败(或强制指定)时,返回一个本地兜底结果,避免异常直接抛给业务。写法上通过 `mock` 参数指定,支持 `true`/`default`(走同名的 Mock 实现类)、`fail:` 前缀(失败后降级)、`force:` 前缀(直接降级不发起调用)、`return`/`throw` 两种返回方式。 | 配置 | 含义 | | --- | --- | | `mock="true"` 或 `mock="default"` | 使用接口名 + `Mock` 后缀的实现类(如 `StockServiceMock`) | | `mock="fail:return null"` | 真实调用失败后,返回 `null` | | `mock="fail:throw"` | 真实调用失败后,抛出特定异常 | | `mock="force:return 1"` | 不发起真实调用,直接返回 1(用于"强制降级开关") | | `mock="force:throw"` | 不发起真实调用,直接抛异常(用于"强制熔断") | ```java // 解决什么问题:为接口准备一个本地兜底实现,失败时返回安全值 public class StockServiceMock implements StockService { @Override public void deduct(Long skuId, int count) { // 降级逻辑:不抛异常,记录日志,让主流程继续 log.warn("stock deduct downgraded, skuId={}, count={}", skuId, count); } @Override public int query(Long skuId) { return 0; // 兜底返回 } } ``` ```xml <!-- 解决什么问题:声明式启用 Mock 降级 --> <!-- mock="true":失败后调用 StockServiceMock 中的兜底实现 --> <dubbo:reference id="stockService" interface="com.example.StockService" mock="true" timeout="2000"/> ``` **关键机制与坑**: 1. **Mock 触发的时机是"重试全部失败之后"**。也就是说配了 `mock="fail:return null"` 且 `retries=2` 时,会先真实调用 3 次,全都失败才走 Mock。**这意味着降级并不能减少失败请求带来的延迟与下游压力**,它只保证"最终给业务一个结果"。要"立刻降级",应该用 `force:`(但要自己实现动态开关,否则一直是强降级)。 2. **`force` 与动态配置配合才是完整方案**:生产中常见做法是把 `mock=force:return xxx` 通过配置中心动态下发,实现"一键降级/一键恢复"。**这依赖配置中心的动态推送能力,且行为与版本相关,需结合版本确认。** 3. **Mock 兜底值要想清楚语义**:返回 `null`、返回 `0`、返回空集合,对业务意味着什么?**"降级返回一个看起来正常但实际错误的值"比直接报错更危险**(比如库存扣减降级返回成功,实际没扣)。降级方案必须业务侧评审。 ### Q:并发数与连接数控制怎么配?`actives`、`executes`、`accepts`、`connections` 分别是什么? A:结论先行——四个参数分属两端:**`actives` 是 Consumer 侧"每个方法的最大并发调用数",`executes` 是 Provider 侧"每个方法的最大并发执行数",`accepts` 是 Provider 侧"最大可接受连接数",`connections` 是 Consumer 侧"对每个 Provider 的最大连接数"**。它们共同构成 Dubbo 原生的"客户端限流 + 服务端限流"能力。 | 参数 | 生效侧 | 作用 | 默认值 | | --- | --- | --- | --- | | `actives` | Consumer | 每方法最大并发调用数(超出则等待/失败) | 0(不限,需结合版本确认) | | `executes` | Provider | 每方法最大并发执行数(超出则拒绝) | 0(不限,需结合版本确认) | | `accepts` | Provider | 最大可接受连接数 | 0(不限,需结合版本确认) | | `connections` | Consumer | 每 Provider 最大连接数 | 0(共享连接,需结合版本确认) | ```xml <!-- 解决什么问题:给关键接口做双向并发保护,避免被打挂 --> <!-- executes="200":服务端每方法最多 200 并发;accepts="1000":服务端最多接受 1000 个连接 --> <dubbo:service interface="com.example.StockService" ref="stockServiceImpl" executes="200" accepts="1000"/> <!-- actives="50":消费端每方法最多 50 并发调用 --> <dubbo:reference id="stockService" interface="com.example.StockService" actives="50"/> ``` **边界与坑**: - **`actives` 与 `executes` 是"兜底阀门",不是精细限流**。它们按方法粒度计数,无法做"按用户/按接口重要性"的差异化限流。精细限流应该用 Sentinel 之类的专门组件。 - **超出限制时的行为不同**:`actives` 超出后通常表现为"等待/失败",`executes` 超出后通常表现为"拒绝并抛异常"。**具体行为与异常类型需结合版本确认**,生产上要保证这个异常能被上位逻辑正确处理。 - **连接数与线程数要一起算账**:`accepts` 调大意味着服务端要维护更多连接,每个连接都占用文件描述符与内存;**盲目调大容易触发"连接数上去了但业务线程不够"**,瓶颈只是换了个位置。 ### Q:超时机制怎么理解?优先级和"超时传递"是什么? A:结论先行——Dubbo 的超时默认是 **1000 毫秒**(需结合版本确认),配置优先级遵循两条规则:**① 精确优先:方法级 > 接口级 > 全局;② 消费者优先:同级别时 Consumer 的配置覆盖 Provider 的配置**。此外,Consumer 的 `timeout` 会**随请求传递到 Provider**,Provider 用它来判断"这次调用是否已经可以被放弃"。 优先级从高到低: ```text ① Consumer 方法级 timeout ② Consumer 接口级 timeout ③ Provider 方法级 timeout ④ Provider 接口级 timeout ⑤ 全局默认(1000ms 量级,需结合版本确认) ``` 「超时传递」要理解成两件事: 1. **Consumer 端超时**:等待响应超过 `timeout` 就抛 `TimeoutException`。**注意:超时只是"我不等了",请求可能已经在 Provider 上执行了(甚至执行完了)** ——这就是为什么"超时 + 重试 + 非幂等"会重复执行。 2. **Provider 端超时感知**:Provider 通过请求附件拿到 Consumer 的 `timeout`,当方法执行时间超过该值时,会**打印告警日志**(形如"方法执行超时"),但**通常不会中断业务线程**(线程中断语义在业务里不可靠)。**具体是否中断、日志形态需结合版本确认。** ```xml <!-- 解决什么问题:给慢接口放宽超时,给快接口收紧超时 --> <dubbo:reference id="reportService" interface="com.example.ReportService" timeout="10000"> <dubbo:method name="exportReport" timeout="30000"/> <!-- 导出很慢 --> <dubbo:method name="getStatus" timeout="500"/> <!-- 状态查询要快 --> </dubbo:reference> ``` **实践原则(重要)**: - **上层超时 > 下层超时**:如果 A 调 B、B 调 C,A 的超时必须大于"B 自己的处理时间 + B 调 C 的超时 + 网络开销",否则会出现"A 已经等超时抛错,B 还在慢慢处理并最终成功"的诡异现象。 - **超时不要配得过小**:超时过小会把正常抖动放大成失败,还会触发重试放大下游压力。**先看 P99 耗时,再给合理余量。** - **超时是最重要的治理参数之一**:没有超时,线程会被长尾请求占住,最终线程池打满、连接被断(见通信篇)。**"所有外部调用都必须有超时"是铁律。** ## 小结 - **选址流水线**:Directory(全量)→ Router(过滤)→ LoadBalance(选一台)→ Cluster(调用与容错)→ Mock(降级)。排查"找不到服务/流量不对"时按这条链逐段看。 - **负载均衡**:`random`(默认,加权随机)、`roundrobin`(加权平滑轮询)、`leastactive`(最少活跃,瞬时负载)、`consistenthash`(参数固定路由,注意节点变更导致落点迁移)、`shortestresponse`(历史响应时间,版本相关)。**权重来自 URL 的 `weight` 参数,默认 100(需结合版本确认)。** - **集群容错**:`failover`(默认)、`failfast`、`failsafe`、`failback`、`forking`、`broadcast`、`available`。**`failover` 的 `retries` 默认 2(共 3 次调用),非幂等写操作必须改 `failfast` 或 `retries=0`,并优先用业务唯一键做幂等。** - **路由**:条件路由语法是"消费者条件 => 提供者条件",**"提供者条件为空"表示禁用这些 Provider**;标签路由是灰度主力,注意 `force` 语义与 `RpcContext` 附件的清理。 - **降级**:Mock 在"重试全部失败后"才触发,只能保证最终有结果,不能减少下游压力;`force:` 配合配置中心才能做"一键降级",**降级兜底值必须业务评审**。 - **流控与时间**:`actives`(消费端每方法并发)、`executes`(服务端每方法并发)、`accepts`(最大连接数)、`connections`(每 Provider 连接数)四件套是兜底阀门;超时默认 1000ms 量级,**优先级"方法级 > 接口级 > 全局、Consumer > Provider",并会传递给 Provider**;**上层超时必须大于下层超时之和**。 ## 思考题 1. 你的订单服务配置是 `cluster=failover`(默认)、`retries=2`。某次 Provider 抖动,用户反馈"下了 3 个订单"。请给出至少两种修复方案,并说明各自的代价。 2. 为什么 `leastactive` 能起到"给慢节点减负"的效果,而 `random` 不能?如果慢节点长期空闲,`leastactive` 还能保护它吗? 3. 一致性哈希的落点会随节点上下线变化。如果业务用 `consistenthash` 来做"同一用户的本地缓存命中",扩缩容时会出现什么问题?如何兜底? 4. 标签路由中"找不到对应 tag 的 Provider 时降级到全量"这个行为,在灰度发布中会带来什么风险?你会怎么设置? 5. 你配了 `mock="fail:return null"` 且 `retries=2`,一次调用最终降级返回 `null`。这次调用实际向 Provider 发了几个请求?如果希望"降级时不要再打下游",应该怎么配?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入