知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# Sentinel 限流算法与流控规则 > 导读:本文从"阈值明明配了 100 QPS,线上还是被打穿;或者一压测就发现瞬时超发、规则像没生效"这个具体痛点出发,把滑动窗口统计原理(LeapArray 时间窗口)、限流维度(QPS 与并发线程数)、流控模式(直接/关联/链路)、流控效果(快速失败/Warm Up/匀速排队)、它与令牌桶漏桶的关系辨析、规则配置方式、限流后的处理优先级、以及热点参数限流原理逐项讲透,最后给出生产用法与踩坑。适合已经了解 Sentinel 基本概念、准备把限流规则真正落到线上的同学。 ## 一、先建立全局认知 ### Q:Sentinel 是怎么"数"请求的?为什么不能用一个简单计数器? A:结论先行——Sentinel 用的是**按时间分桶的滑动窗口统计**(实现类是 `LeapArray` 及其子类 `BucketLeapArray`),把时间切成一段段定长窗口,每段独立计数,判断时把**最近若干个窗口**的数字加总。简单计数器的问题在于**窗口边界效应**:如果在每个自然秒开始时清零,那么"第 1 秒最后 1ms 打满 100 次 + 第 2 秒最初 1ms 再打满 100 次",会在 2ms 内放行 200 次,瞬时压力翻倍。 先看两种统计方式的差别: ```text 简单固定窗口(每秒清零): 时间 → 0ms ................ 999ms | 1000ms .............. 1999ms 放行 [ 100 次打满 ] | [ 100 次打满 ] ↑ 999ms 和 1000ms 相邻,2ms 内实际放行 200 次 —— 边界效应 滑动窗口(最近 1 秒 = 最近 2 个 500ms 桶之和): 时间 → [桶0: 0~499ms] [桶1: 500~999ms] [桶2: 1000~1499ms] 在 1000ms 时刻判断时,看的是 桶0 + 桶1 的和,且桶0 会随 1500ms 到来被复用 ``` 关键点: - **"滑动"是相对概念,不是连续滑动**。Sentinel 的窗口起点是按 `当前时间戳 / 窗口长度` 对齐的**定长分桶**,所谓"滑动"指的是"每来一个新窗口就淘汰最老的窗口"——它是**环形复用的滚动窗口**,而不是每毫秒都平移的连续窗口。这点必须认清,否则会误以为它能做到"任意时间点往前推 1 秒"的精确统计。 - **窗口越细,边界效应越小,但内存与竞争越大**。Sentinel 默认把 1 秒切成 2 个 500ms 的桶(`SampleCountProperty.SAMPLE_COUNT = 2`、`IntervalProperty.INTERVAL = 1000`,以你使用的版本源码为准),所以最坏情况下仍存在"跨桶相邻"的瞬时超发,只是幅度被压小。 - **统计分两个时间尺度**:秒级滚动窗口用于限流与熔断判断;分钟级窗口(60 个 1 秒桶)用于汇总类统计。两者都在 `StatisticNode` 里维护。 ### Q:LeapArray 的内部结构是什么样的? A:结论先行——`LeapArray` 维护一个**定长环形数组**,数组长度 = 桶数量,每个槽位是一个 `WindowWrap`(窗口包装),里面放着 `windowStart`(窗口起点时间)、`windowLengthInMs`(窗口长度)和 `value`(该窗口的统计值,通常是 `MetricBucket`)。定位某个时刻属于哪个槽位,用的是"时间戳整除窗口长度得到时间序号,再对数组长度取模"。  *图:Sentinel LeapArray 滑动窗口结构* ```text LeapArray 结构(sampleCount = 2, intervalInMs = 1000, windowLengthInMs = 500) array[0] = WindowWrap{ windowStart = 0, windowLengthInMs = 500, value = MetricBucket } array[1] = WindowWrap{ windowStart = 500, windowLengthInMs = 500, value = MetricBucket } ↑ 统计"最近 1 秒" = array[0] + array[1] 两个桶相加 时间轴(每个格子 = 一个 500ms 桶,idx 按 timeId % 2 循环): 0ms 500ms 1000ms 1500ms 2000ms ├──────────┼───────────┼───────────┼───────────┤ │ idx0 │ idx1 │ idx0 │ idx1 │ │ 0~499 │ 500~999 │ 1000~1499 │ 1500~1999 │ └──────────┴───────────┴───────────┴───────────┘ ↑ 老数据会被重置:1500ms 到来时,idx0 的窗口被复用为新窗口 定位算法(示意): timeId = timeMillis / windowLengthInMs // 时间被切成编号 idx = timeId % array.length() // 环形复用 windowStart = timeId * windowLengthInMs // 该窗口起点(对齐) ``` `currentWindow` 的核心逻辑(示意,非源码原文): ```java public WindowWrap<T> currentWindow(long timeMillis) { int idx = calculateTimeIdx(timeMillis); // timeId % array.length() long windowStart = calculateWindowStart(timeMillis); // timeId * windowLengthInMs while (true) { WindowWrap<T> old = array.get(idx); if (old == null) { // 1. 槽位为空:CAS 放入一个新窗口 WindowWrap<T> window = new WindowWrap<>(windowLengthInMs, windowStart, newEmptyBucket(timeMillis)); if (array.compareAndSet(idx, null, window)) { return window; } else { Thread.yield(); // 竞争失败让出 CPU,重试 } } else if (windowStart == old.windowStart()) { return old; // 2. 命中当前窗口 } else if (windowStart > old.windowStart()) { if (updateLock.tryLock()) { // 3. 窗口过期:加锁重置(复用槽位) try { return resetWindowTo(old, windowStart); } finally { updateLock.unlock(); } } else { Thread.yield(); } } else { // 4. 请求拿到的是"更早"的时间(时钟回拨等):返回一个临时窗口,不写入数组 return new WindowWrap<>(windowLengthInMs, windowStart, newEmptyBucket(timeMillis)); } } } ``` 关键点与适用边界: - **窗口复用是"重置"而不是"新建"**:`resetWindowTo` 把老 `WindowWrap` 的 `windowStart` 改成新的起点并清空计数,避免高频创建对象。这解释了为什么不能用它做"历史窗口查询"——**老数据会被直接覆盖**。 - **并发控制是 CAS + 自旋 + 一把更新锁**:写统计时会有 `Thread.yield()` 的自旋,桶越细、QPS 越高、线程越多,这个自旋带来的开销越大。所以不是"桶越细越好"。 - **时钟回拨的兜底只是"降级不崩"**:拿到"更早时间"的请求不会被写入数组,统计会短暂失真但不会出现负数或异常。 - 适用边界:这套结构适合"高吞吐 + 近似统计"的场景,**不追求绝对精确**。如果你需要精确的分布式配额,应该用集群流控(token server)或外部计数服务。 ## 二、理解核心机制 ### Q:限流的两个维度——QPS 和并发线程数,到底该选哪个? A:结论先行——**QPS 限流管"进入速率",适合响应快、耗时稳定的资源;并发线程数限流管"同时占用的线程数",适合响应慢、耗时波动大、需要保护线程池的资源**。同一个资源在 RT 升高时,同样 QPS 下并发线程数会成倍上升,这正是线程数维度存在的意义。 对比表: | 维度 | 阈值类型 | 判断依据 | 触发时机 | 适合场景 | 注意点 | |------|---------|---------|---------|---------|-------| | QPS(每秒请求数) | `FLOW_GRADE_QPS` | 滑动窗口内通过的请求数 | 进入资源时 | 响应快、处理时间稳定的接口 | RT 恶化时 QPS 不变但线程占用会飙升 | | 并发线程数 | `FLOW_GRADE_THREAD` | 当前"尚未 exit"的调用数 | 进入资源时 | 慢调用、下游不稳定、需要护住线程池 | 与 RT 强相关,需配合超时避免线程长期挂着 | 选择逻辑(给判断顺序): 1. **资源是"快操作"(毫秒级、无外部依赖)** → 用 QPS。此时并发线程数天然接近 QPS × RT,用线程数意义不大。 2. **资源是"慢操作"(调用第三方、查大表、读写外部存储)** → 优先用并发线程数,因为它能直接约束"有多少线程被这个资源占住"。 3. **资源既有快路径又有慢路径(RT 方差大)** → 线程数更靠得住;纯 QPS 在慢路径上会失效(QPS 没超,但线程已被占满)。 4. **想双保险** → 同一资源可以同时存在 QPS 与线程数两条规则(它们各自独立判断,任一不通过即拦截)。 一个必须提醒的边界:**并发线程数限流只统计"进入资源但还没 exit"的调用**。如果你的调用没有超时控制、下游一挂就挂 30 秒,那么线程数会被长期占满,限流会持续拒绝——这其实是正确的保护行为,但会放大故障范围。所以**并发线程数限流必须配合调用超时一起用**。 ### Q:三种流控模式(直接、关联、链路)分别解决什么问题? A:结论先行——**直接模式**限流资源自身;**关联模式**是"当关联资源(参照物)达到阈值时,限制当前资源";**链路模式**是"只对从指定入口进来的那部分调用限流"。三者解决的是"限谁"的问题,而不是"限多少"的问题。 | 模式 | 常量 | 判定对象 | 参数 | 典型用法 | |------|------|---------|------|---------| | 直接 | `STRATEGY_DIRECT` | 当前资源自己 | 无额外参数 | 对 `/api/query` 直接限 100 QPS | | 关联 | `STRATEGY_RELATE` | 关联资源 `refResource` | 需指定关联资源名 | "支付接口"压力大时,限制"下单接口"(减少写冲突/数据库竞争) | | 链路 | `STRATEGY_CHAIN` | 指定入口资源 `refResource` | 需指定入口资源名 | 资源 `getUser` 被多个入口调用,只限制从 `/api/export` 进来的那一路 | 三个容易搞混的细节: 1. **关联模式的语义方向容易记反**:写规则时你在"当前资源"上配规则,然后填一个"关联资源"。含义是**当关联资源的 QPS 超过阈值时,当前资源被限流**。例如给 `/order/create` 配关联资源 `/pay/callback`,阈值 100:当 `/pay/callback` 的 QPS 超过 100 时,`/order/create` 开始被拒绝。它实现的是"牺牲次要链路、保住关键链路"。 2. **链路模式依赖"入口资源 + Context"**:它靠 `NodeSelectorSlot` 构建的调用树,只汇总"某个入口节点下面的调用"。所以**入口资源名必须真实存在**(Web 场景通常是入口 URL 资源名),且调用发生时 Context 要对得上;如果异步/跨线程丢失了 Context,链路模式的统计就会落到别的链路上。 3. **关联与链路都靠 `refResource` 字段传参照资源名**,控制台上分别显示为"关联资源"与"入口资源",同一份阈值语义不同,配错时现象完全不同(关联模式是"别人忙了限我",链路模式是"只限我这路")。 ### Q:三种流控效果各是什么?和令牌桶、漏桶是什么关系? A:结论先行——**快速失败**是"到点就拒"(计数器+阈值);**Warm Up(预热)**是"慢启动"(借鉴 Guava `SmoothWarmingUp` 的令牌桶预热思想);**匀速排队**是"漏桶式排队"(以阈值为出水速率匀速放行,等待超时才拒绝,等待期间会阻塞调用线程)。三者不是同一族算法,不能简单等同于"令牌桶 vs 漏桶"的二选一。 | 效果 | 常量 | 算法本质 | 是否允许突发 | 是否阻塞调用线程 | 典型场景 | |------|------|---------|-------------|----------------|---------| | 快速失败 | `CONTROL_BEHAVIOR_DEFAULT` | 计数器 + 阈值比较,超阈值直接抛 `FlowException` | 不允许(超出即拒) | 否 | 大部分接口的默认选择 | | Warm Up | `CONTROL_BEHAVIOR_WARM_UP` | 令牌桶预热(冷启动因子 `coldFactor` 默认 3,从阈值/3 逐步升到阈值) | 不允许,但允许"渐进放开" | 否 | 秒杀、缓存预热期、依赖刚启动 | | 匀速排队 | `CONTROL_BEHAVIOR_RATE_LIMITER` | 漏桶思想:按阈值折算的间隔匀速放行 | 削峰填谷,把突发摊平 | **是**(未到放行时刻会等待/睡眠) | 需要削峰的写操作、对下游有严格速率要求 | **与令牌桶/漏桶的辨析**(这一节回答"Sentinel 到底用的什么算法"): - **令牌桶(Token Bucket)**:以恒定速率往桶里放令牌,桶有容量上限、可累积,因此**允许一定程度的突发**(攒下的令牌可以一次性用掉)。Guava `RateLimiter` 是典型实现。 - **漏桶(Leaky Bucket)**:请求先进桶,以**恒定速率出水**,桶满则丢弃。它天然**不允许突发**,把流量削成平滑的直线。 - **Sentinel 的快速失败**:既不是令牌桶也不是漏桶,它是"滚动窗口计数 + 阈值比较"。没有队列、没有令牌、没有发放速率的概念,只有一个"期限内通过数不能超过 count"的约束。**所以它不允许突发,但也不会削峰——超出的部分直接被拒。** - **Sentinel 的匀速排队**:**效果等价于漏桶**(恒速放行 + 有限等待窗口),但**实现上不是维护一个真实队列**,而是维护"上一次放行时间" `latestPassedTime`,按 `1/QPS` 折算每次调用的成本时间,推算出"本次应该在第几毫秒放行";如果算出的等待时间超过 `maxQueueingTimeMs`,直接拒绝,否则**让当前调用线程 `sleep` 到那个时刻**。这带来一个重要后果:**排队等待期间线程是被占用的**,所以匀速排队不能滥用在高并发短请求上。 - **Sentinel 的 Warm Up**:借鉴的是 Guava 的 `SmoothWarmingUp`(带预热的令牌桶),初始放行速率约为 `阈值 / coldFactor`,在预热时长内逐步升到阈值。 一个反直觉但重要的结论:**想"允许突发",Sentinel 的内建效果里没有直接对应项**。如果你要严格意义上的令牌桶突发语义,需要在快速失败的基础上把阈值设成"峰值",或者改用其他组件实现。 ### Q:Warm Up 的冷启动是怎么算的?参数怎么配? A:结论先行——Warm Up 的进入速率从"阈值的 1/coldFactor"开始,在 `warmUpPeriodSec` 这段时间内逐步上升到设定的阈值。`coldFactor`(冷启动因子)默认是 3,即**初始速率约为阈值的 33%**,然后逐步放开。  *图:Warm Up 从 100 QPS 预热到 300 QPS* ```text Warm Up 示意(阈值 = 300 QPS,coldFactor = 3,warmUpPeriodSec = 10) QPS 300 ┤ ┌─────────────── 稳定在 300 │ ╭──────╯ 200 ┤ ╭─────╯ │ ╭────╯ 100 ┤ ╭──────────╯ ← 起点约 = 300 / 3 = 100 │ ╭─────╯ 0 └──┴──────┴──────┴──────┴──────┴──────→ 时间 0 3 6 9 10 (s) ↑ 预热阶段:速率线性/曲线上升,超出的请求会被快速失败 ``` 关键点与边界: - `coldFactor` 必须大于 1,否则构造 `WarmUpController` 时会直接抛 `IllegalArgumentException`。**默认值以你所用版本的 `WarmUpController` 为准,需结合版本确认。** - Warm Up 的"预热"是**对请求放行速率**的预热,不是对缓存/JIT 的预热。它的价值在于:系统刚启动时(JIT 未完成、连接池未预热、本地缓存为空)处理能力本来就更弱,一上来就打满阈值会把刚启动的实例打死。 - **Warm Up 不支持并发线程数维度**,它作用于 QPS 阈值;配在 `FLOW_GRADE_THREAD` 上不生效(或按版本表现为不可用),需结合版本确认。 - 适用边界:Warm Up 适合"长期低峰 + 偶发高峰 + 实例刚启动"的场景(秒杀整点、大促开闸)。如果系统长期稳定在高水位,配 Warm Up 反而会在每次重启后误伤正常流量。 ### Q:匀速排队(漏桶)具体怎么控制放行? A:结论先行——它把"每秒 count 个"折算成"每 `1000/count` 毫秒放行一个",用一个共享的"上次放行时间戳"串起所有请求,请求到了先算自己该排在第几毫秒,超过最大排队时长就拒绝,否则睡到那一刻再放行。 控制逻辑(示意,非源码原文): ```java // 核心思想:latestPassedTime 记录"上一个被放行的请求的计划放行时刻" public boolean canPass(int acquireCount) { long currentTime = now(); long costTime = Math.round(1.0 * acquireCount / count * 1000); // 本次占用多少毫秒 long expectedTime = costTime + latestPassedTime.get(); if (expectedTime <= currentTime) { // 桶"空了",立刻放行,并把上次放行时间推到当前时间 latestPassedTime.set(currentTime); return true; } long waitTime = costTime + latestPassedTime.get() - currentTime; if (waitTime > maxQueueingTimeMs) { return false; // 排队太久,直接拒绝(快速失败) } // 抢占排队位置,再校验一次 long oldTime = latestPassedTime.addAndGet(costTime); waitTime = oldTime - now(); if (waitTime > maxQueueingTimeMs) { latestPassedTime.addAndGet(-costTime); // 抢晚了,回滚 return false; } if (waitTime > 0) { Thread.sleep(waitTime); // ★ 阻塞当前调用线程 } return true; } ``` 关键点与适用边界: - `maxQueueingTimeMs` 是**单次请求允许排队的最长时间**:超过就拒绝,不超过就等待。它的默认值以 `FlowRule` 的默认值为准(历史上为 500ms,**需结合版本确认**)。 - **等待发生在调用线程里**,意味着"排队"会消耗你的线程池容量。高并发 + 长排队 = 线程被大量占用,反而可能把服务拖垮。**匀速排队只适合"阈值本身不高、且希望流量平滑"的场景。** - 排队等待会**拉高 RT**,而 RT 又是熔断"慢调用比例"的输入——配了匀速排队又配了慢调用熔断,可能自己把自己熔断。这是一个非常隐蔽的组合坑。 - 适用边界:匀速排队不适合阈值很大(如每秒上万)的场景,也不适合要求低延迟的读接口。 ## 三、规则配置与限流处理 ### Q:流控规则用代码怎么配?控制台上有哪些字段? A:结论先行——代码方式通过 `FlowRule` + `FlowRuleManager.loadRules(...)`,**注意这只是把规则加载进当前 JVM 的内存**,重启即失效;控制台方式则是在"流控规则"页面按同样字段填写,本质是把规则推给客户端。 ```java import com.alibaba.csp.sentinel.slots.block.RuleConstant; import com.alibaba.csp.sentinel.slots.block.flow.FlowRule; import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager; import java.util.ArrayList; import java.util.List; public class FlowRuleConfig { public static void initRules() { List<FlowRule> rules = new ArrayList<>(); // 规则 1:直接模式 + QPS + 快速失败 FlowRule direct = new FlowRule(); direct.setResource("queryOrder"); direct.setLimitApp("default"); // 默认来源,不区分调用方 direct.setGrade(RuleConstant.FLOW_GRADE_QPS); // QPS 维度 direct.setCount(100); // 单机阈值 100 QPS direct.setStrategy(RuleConstant.STRATEGY_DIRECT); // 直接模式 direct.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT); // 快速失败 rules.add(direct); // 规则 2:关联模式 —— 当 refResource 超阈值时,限流本资源 FlowRule relate = new FlowRule(); relate.setResource("createOrder"); relate.setGrade(RuleConstant.FLOW_GRADE_QPS); relate.setCount(50); relate.setStrategy(RuleConstant.STRATEGY_RELATE); relate.setRefResource("payCallback"); // 关联资源名 rules.add(relate); // 规则 3:匀速排队(漏桶),阈值 20 QPS,最长排队 500ms FlowRule queueing = new FlowRule(); queueing.setResource("writeAuditLog"); queueing.setGrade(RuleConstant.FLOW_GRADE_QPS); queueing.setCount(20); queueing.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER); queueing.setMaxQueueingTimeMs(500); // 超过 500ms 未放行则拒绝 rules.add(queueing); // 规则 4:并发线程数限流 FlowRule threadRule = new FlowRule(); threadRule.setResource("callThirdParty"); threadRule.setGrade(RuleConstant.FLOW_GRADE_THREAD); // 线程数维度 threadRule.setCount(20); // 最多 20 个线程同时在执行 rules.add(threadRule); FlowRuleManager.loadRules(rules); // ★ 仅加载到当前 JVM 内存 } } ``` 控制台"流控规则"页面的字段对应关系: | 控制台字段 | 对应属性 | 可选值/说明 | |-----------|---------|------------| | 资源名 | `resource` | 必须与运行时资源名完全一致 | | 针对来源 | `limitApp` | 默认 `default`(不区分来源),也可填具体应用名或 `other` | | 阈值类型 | `grade` | QPS 或 线程数 | | 单机阈值 | `count` | 单机(每实例)的阈值;集群模式下另有含义 | | 是否集群 | `clusterMode` | 开启后由 token server 统一发令牌,需要额外部署集群限流服务端 | | 流控模式 | `strategy` | 直接 / 关联 / 链路(关联、链路需填参照资源) | | 流控效果 | `controlBehavior` | 快速失败 / Warm Up / 排队等待 | | 关联资源 / 入口资源 | `refResource` | 关联模式填关联资源名;链路模式填入口资源名 | 关键点与适用边界: - `FlowRuleManager.loadRules()` 是**覆盖式**加载(传入的列表就是全量规则),不是追加。增量修改要用 `FlowRuleManager.getRules()` 改完再 load,或直接接入数据源由框架维护。 - 代码加载的规则**存在 JVM 内存里**,应用重启即回到"无规则"状态。生产必须接持久化数据源,**这是所有"规则莫名消失"问题的根源**。 - `setCount(...)` 是 `double` 类型,匀速排队场景下小数阈值(如 0.5)是有意义的(表示每 2 秒放 1 个);但要注意控制台上小数阈值的展示精度问题,**需结合版本确认**。 ### Q:控制台里的"针对来源"(`limitApp`)是干什么的?什么时候该用? A:结论先行——`limitApp` 是**针对"调用来源"设定限流配额**的字段:填 `default` 表示**不区分来源**(所有调用方共享同一阈值);填具体应用名表示**为该来源单独设一档阈值**;填 `other` 表示**兜底约束"除已单独配置之外的其他来源"**。 | `limitApp` 取值 | 含义 | 典型用法 | |----------------|------|---------| | `default`(默认) | 不区分来源,所有来源共享该资源的阈值 | 绝大多数场景 | | 具体应用名(如 `app-order`) | 只为该来源单独设定阈值 | 给某个"重调用方"单独设更严或更宽的阈值 | | `other` | 除已单独配置的来源之外的其他来源 | 兜底约束"陌生调用方",防止被意外刷 | | 多个来源(逗号分隔) | 多个来源共享该规则 | 一组合法调用方共用同一档配额 | 三个实践要点: 1. **来源能不能被识别,取决于你是否提供了来源解析器**(Web 场景为 `RequestOriginParser`)。没有解析器时来源为空,规则可能落到"空来源"这个分支上,表现为规则完全不起作用或全部被拦——两种情况都出现过。 2. **`limitApp` 是"给多少配额",授权规则的 `limitApp` 是"允不允许进来"**。同名字段、不同语义:前者是限流,后者是黑白名单。混用的结果是一个"部分请求被限"、一个"整类来源被拒"。 3. **同一资源上"针对具体来源的规则"与"`default` 规则"同时存在时如何选择**——**需结合版本确认**。稳妥做法是不要在同一个资源上堆叠过多来源规则,来源差异大就拆成不同资源。 适用边界:来源限流适合"少数大调用方 + 多数小调用方"的流量形态,例如给一个批量导出任务单独设很小的阈值,避免它挤占正常用户的配额。如果所有调用方同质,不区分来源反而更简单、更可控。 ### Q:被限流之后,`BlockException` 是怎么一层层抛出来的? A:结论先行——FlowSlot 判断不通过时会抛出 `FlowException`,它是 `BlockException` 的子类;`BlockException` 从 `entry()` 抛出,穿过你的业务代码,要么被你自己 catch,要么被 `@SentinelResource` 的 blockHandler 捕获。**所有"被规则拦下"的异常都统一是这个家族的**(`FlowException`/`DegradeException`/`SystemBlockException`/`AuthorityException`/`ParamFlowException`)。  *图:BlockException 父类与五个子类被谁拦截* ```text 异常家族(都在 com.alibaba.csp.sentinel.slots.block 包下) BlockException(父类) ├── FlowException ← 被 FlowSlot 限流 ├── DegradeException ← 被 DegradeSlot 熔断(OPEN 状态直接拒绝) ├── SystemBlockException ← 被 SystemSlot 系统规则拦截 ├── AuthorityException ← 被 AuthoritySlot 授权规则拦截 └── ParamFlowException ← 被 ParamFlowSlot 热点参数规则拦截 ``` 关键点: - `BlockException` 继承自 `Exception`(受检),所以手写 API 时**必须处理**,不能装作看不见。 - **"熔断"被拒绝时抛的是 `DegradeException`,属于 `BlockException` 家族**——这是理解下一节优先级的关键:熔断的拒绝走的是 blockHandler,而不是"业务异常 fallback"。 - 用 `@SentinelResource` 时,框架会在 `exit()` 时判断异常类型:业务异常计入异常统计(供异常比例/异常数熔断使用),而 `BlockException` 计入 block 计数。 ### Q:blockHandler 和 fallback 到底有什么区别?谁的优先级更高? A:结论先行——它们**处理的是不同来源的异常**,不是简单的"谁覆盖谁":**`blockHandler` 处理 `BlockException`(被规则拦下)**;**`fallback` 处理业务异常(方法真的抛错了)**。配置了 blockHandler 时,被限流/熔断/系统保护拦截一律走 blockHandler,**不会**进入 fallback;两者都没有配时,`BlockException` 会直接抛给上层。 | 维度 | blockHandler | fallback / defaultFallback | |------|--------------|---------------------------| | 处理的异常 | `BlockException` 及其子类(限流、熔断、系统、授权、热点) | 业务异常(`Throwable`/`Exception`,可用 `exceptionsToIgnore` 排除) | | 触发场景 | 规则拦截,方法体**根本没执行** | 方法体已执行并抛异常 | | 方法签名 | 原参数 + 末尾追加 `BlockException` | 原参数(或原参数 + `Throwable`);`defaultFallback` 无参或仅 `Throwable` | | 返回类型 | 必须与原方法一致 | 必须与原方法一致 | | 位置 | 默认与原方法**同一个类**(可写成实例方法),用 `blockHandlerClass` 指定到其他类时该方法必须是 `static` | 默认与原方法**同一个类**(可写成实例方法),用 `fallbackClass` 指定到其他类时该方法必须是 `static` | | 与对方的关系 | 配了 blockHandler,`BlockException` 不再进 fallback | 未配 blockHandler 时,`BlockException` 是否进 fallback **需结合版本确认**(较新版本支持交给 fallback 兜底) | ```java @SentinelResource(value = "getUserProfile", blockHandler = "blocked", // 被限流/熔断 → 走这里 fallback = "fallback") // 业务异常 → 走这里 public User profile(Long uid) { return remoteUserService.get(uid); // 可能抛 RpcException } public User blocked(Long uid, BlockException ex) { // 参数一致 + BlockException return User.guest(); } public User fallback(Long uid, Throwable t) { // 参数一致 + Throwable return User.guest(); } ``` 三个结论性提示: 1. **优先级关系是"分流"而非"覆盖"**:`BlockException` 只走 blockHandler;业务异常只走 fallback。所以"blockHandler 优先级高于 fallback"这个说法,准确表述应该是"**`BlockException` 不会被 fallback 处理**"。 2. **`fallback` 的降级语义更接近"业务兜底"**,而 **blockHandler 的语义是"限流/熔断兜底"**。生产上建议两者都配:用 blockHandler 返回"稍后重试"类的提示,用 fallback 返回"降级数据"。 3. **签名写错会导致兜底静默失效**:最常见的是漏掉末尾的 `BlockException` 参数、把方法写成 `private`、跨类指定却没写 `static`、或返回类型不一致。这种情况下的表现是"兜底没生效,直接抛了 `BlockException`",排查时先看签名。 ### Q:热点参数限流的原理是什么?为什么它"只对 QPS 生效"? A:结论先行——热点参数限流(`ParamFlowRule`)的思路是"**按参数值分别计数**":从方法实参里取出指定的第 `paramIdx` 个参数,用它的值作为 key,为每个不同的值维护独立的滑动窗口,然后对每个值单独做 QPS 限流;未被单独限流的参数值走规则里的全局阈值。它只支持 QPS 维度,因为它的设计目标就是"某个具体参数值(如某个爆款商品 ID)被刷爆",而不是控制并发。  *图:热点参数按参数值分窗口,例外项单独阈值* ```text 热点参数限流(paramIdx = 0,全局阈值 count = 10) 参数值 "SKU_1001" → 自己的窗口 → 10 QPS ┐ 参数值 "SKU_1002" → 自己的窗口 → 10 QPS ├─ 各值独立计数 参数值 "SKU_1003" → 例外项 → 100 QPS ┘ 其他未出现的值 → 走全局阈值 → 10 QPS 实现要点: 1. ParamFlowSlot 从 args 里取 paramIdx 对应的值 2. 用 CacheMap(LRU)缓存"参数值 → 统计窗口",防内存膨胀 3. 命中缓存 → 用该值的窗口判断;未命中 → 用全局阈值判断,并按需新建 4. 超阈值 → 抛 ParamFlowException(BlockException 子类) ``` ```java import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRule; import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRuleManager; ParamFlowRule rule = new ParamFlowRule("querySku"); rule.setParamIdx(0); // 第 0 个参数(即 skuId) rule.setCount(10); // 全局阈值:10 QPS rule.setDurationInSec(1); // 统计窗口时长(秒),需结合版本确认默认值 ParamFlowRuleManager.loadRules(Collections.singletonList(rule)); ``` 关键点与限制: - **必须能拿到实参**:资源入口要用"带参数"的形式。`@SentinelResource` 标注的方法会自动把参数传给 Sentinel;手写 `SphU.entry(resource, entryType, count, args...)` 时要显式传。**如果用普通 `SphU.entry("资源名")`,热点参数限流拿不到参数,规则不会生效。** - **只支持 QPS 维度**(`grade` 无"线程数"选项),且不支持"关联/链路"这类基于调用关系的模式。 - **参数值需要可比较/可哈希**:一般用基本类型、包装类型、字符串;复杂对象需要能被正确区分,否则可能被归成同一个 key。 - **内存保护**:`CacheMap` 是 LRU 的,参数值基数极大时(如每次请求的 traceId)会不断淘汰与新建窗口,既浪费又拿不到有效统计。**不要对"高基数参数"(每次都不一样的值)配热点参数限流**。 - **例外项(paramFlowItem)** 可以为特定参数值单独设阈值——把某些值设成极大阈值,就等于"对这些值摘掉限流"。 - 适用边界:热点参数限流适合"少量热点 + 大量长尾"的流量形态(爆款商品、大 V 用户)。如果参数分布很均匀,用普通 QPS 限流就够了,加热点参数规则只是徒增开销。 ## 四、小结与延伸 ### Q:把这一篇压缩成几句话 A:结论先行——**统计靠滚动窗口,限流靠规则四要素(维度 + 模式 + 效果 + 阈值)**。 - **统计**:`LeapArray` 环形数组 + 定长分桶(默认 1 秒 2 桶),"滑动"是"环形复用"而非连续滑动,存在跨桶边界的瞬时超发。 - **维度**:QPS 管速率(快资源优先),并发线程数管占用(慢资源优先),两者可叠加。 - **模式**:直接(限自己)、关联(别人忙了限我)、链路(只限指定入口进来的)。 - **效果**:快速失败(计数比较,无突发)、Warm Up(令牌桶预热,`coldFactor` 默认 3)、匀速排队(漏桶式排队,**阻塞调用线程**)。 - **兜底**:`BlockException` 家族统一走 blockHandler;业务异常走 fallback;签名不匹配会静默失效。 - **热点参数**:按参数值分桶计数,只支持 QPS,需要能拿到实参,警惕高基数参数。 ## 小结 - Sentinel 用 `LeapArray` 滚动窗口做统计:定长分桶 + 环形复用 + CAS 自旋写入;默认 1 秒 2 个桶,因此仍有边界超发。 - 限流维度选 QPS 还是并发线程数,取决于资源的 RT 稳定性;慢资源应优先用线程数,并必须配合超时。 - 三种流控模式解决"限谁":直接、关联(参照资源忙则限我)、链路(只限指定入口);关联与链路都通过 `refResource` 指定参照资源。 - 三种流控效果不是令牌桶/漏桶的二选一:快速失败是计数比较,Warm Up 借鉴令牌桶预热,匀速排队是漏桶式的"排队 + 睡眠",会阻塞调用线程。 - 规则的代码配置只进内存,重启失效;控制台字段与 `FlowRule` 属性一一对应,改名必须同步。 - 被拦截统统一抛 `BlockException` 子类:`blockHandler` 管它,`fallback` 管业务异常,签名不匹配会导致兜底失效。 - 热点参数限流按参数值独立计数、只支持 QPS,必须能获取实参,且要避免高基数参数。 ## 思考题 1. 如果 Sentinel 的统计窗口只有 1 个(不滑动),在什么流量模式下会明显超发?为什么把 1 秒切成 2 个桶就能缓解? 2. 某接口 QPS 限了 200,但线上大促时线程池被打满、服务还是崩了。为什么 QPS 限流没能护住它?你会改成什么维度的限流? 3. "A 资源关联 B 资源,阈值 100" 这句话里,究竟是 A 被限还是 B 被限?触发条件是什么? 4. 匀速排队会让调用线程 `sleep`。在 5000 QPS、平均 RT 5ms 的接口上配匀速排队,会发生什么?为什么? 5. 一个资源的入参是"每次请求都不同的 UUID",你给它配了热点参数限流。规则会生效吗?统计和内存会有什么问题?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入