Sentinel限流熔断机制实战

1、核心概念

1.1、流量控制

流量控制是为了防止系统被过多的请求压垮，确保资源合理分配并保持服务的可用性，比如对请求数量的限制。

流量控制的 3 个主要优势：

防止过载：当瞬间涌入的请求量超出系统处理能力时，会导致资源枯竭，如 CPU和内存耗尽。流量控制通过限制系统能处理的请求数，确保不会发生过载。
避免雪崩效应：高负载下某个服务崩溃可能引发其他依赖服务的崩溃，形成连锁反应。流量控制可以有效预防这种连锁故障，避免系统雪崩。
优化用户体验：即便部分请求被拒绝或延迟处理，流量控制也能确保大部分用户的请求能够正常响应，避免全局响应时间过长的情况。

常见的实现流量控制方法有 2 种：

限流：通过固定窗口、令牌桶或漏桶等算法限制单位时间内的请求数量。
排队：当请求量超出处理能力时，部分请求进入等待队列，防止立即超载。

1.2、熔断机制

熔断机制的目的是避免当下游服务发生异常时，整个系统继续耗费资源重复发起失败请求，从而防止连锁故障。

工作机制：

监控服务健康状态：系统会实时监控服务的调用情况，例如请求成功率、响应时间等，判断服务的健康状况。
进入熔断状态：当某个服务的错误率达到设定阈值（如响应时间过长或出错率过高）时，系统会激活熔断器，暂时停止对该服务的调用，避免消耗不必要的资源和让错误进一步扩散。
快速失败：在熔断状态下，系统不会再等待超时，而是直接返回失败响应，减少系统资源占用，并避免因长时间等待导致用户体验的恶化。（也可以降级处理）
熔断恢复机制：熔断并非永久状态。在一段时间后，熔断器会进入半开状态，允许少量请求测试服务的健康情况。如果恢复正常，熔断器将关闭，恢复正常服务调用；如果仍有问题，则继续保持熔断。

在这里插入图片描述

1.3、降级策略

降级的目的是在某个服务的响应能力下降、或该服务不可用时，提供简化版的功能或返回默认值作为兜底，保持系统的部分功能可用，确保用户体验的连续性，避免系统频繁报错。

降级可以是手‏动配置，也可以根据系统负؜载自动触发。系统可能由于多种原因（如高负载、外部‌依赖不可用等）触发降级，‏返回简化的响应或默认值。

降级机制的好处：

优雅地处理故障：在降级状态下，系统不会直接返回错误信息，而是提供一个替代方案。例如，某个数据查询服务不可用时，系统可以返回缓存数据，确保用户看到的是有效信息，而非错误页面。
降低服务压力：降级有助于减轻系统对非核心服务的依赖，确保核心功能的稳定运行。例如，当推荐系统或广告服务出现故障时，降级可以减少对这些服务的调用，保护系统的整体稳定性。

1.4、熔断和降级的区别

具体来说：

熔断是当服务健康状况恶化时，通过切断调用避免系统资源浪费或服务间故障扩散。
降级是在系统压力过大或某个服务不可用时，通过提供简化的替代方案，保持系统的可用性和用户体验。

2、需求分析

2.1、对单个接口整体限流

目的：控制对‏耗时较长的、经常访问的接؜口的请求频率，防止过多请求导致系过载

限流规则：

策略：整个接口每秒钟不超过 10 次请求
阻塞操作：提示“系统压力过大，请耐心等待”

熔断规则：

熔断条件：如果接口异常率超过 10%，或者慢调用（响应时长 > 3 秒）的比例大于 20%，触发 60 秒熔断。
熔断操作：直接返回本地数据（缓存或空数据）

2.2、对单个 IP 访问单个接口限流

限流规则：

策略：每个 IP 地址每分钟允许查看题目列表的次数不能超过 60 次。
阻塞操作：提示“访问过于频繁，请稍后再试”

熔断规则：

熔断条件：如果接口异常率超过 10%，或者慢调用（响应时长 > 3 秒）的比例大于 20%，触发 60 秒熔断。
熔断操作：直接返回本地数据（缓存或空数据）

3、Sentinel 介绍

Sentinel是阿里巴巴开源的限流、熔断、降级组件，旨在为分布式系统提供可靠的保护机制。它设计用于解决高并发流量下的稳定性问题，并且支持与 Dubbo、Spring Cloud 等多种框架集成。

详细内容可查看 -> 官方文档

它的功能：

限流：支持基于 QPS、并发数量等条件的限流，支持滑动窗口、预热、漏桶等算法。
熔断降级：支持失败率、慢调用比例等指标触发熔断，并提供自动恢复机制。
热点参数限流：可以基于特定的参数进行限流，如限制特定用户 ID 的请求频率。
系统负载保护：可以根据系统的实际负载（如 CPU、内存）动态调整流量。
丰富的规则配置：通过配置中心或控制台动态调整限流和熔断规则。

优势：功能‏丰富、提供控制台、؜更新较频繁、社区活跃、文档清晰，能够‌快速入门上手。

3.1、使用方式

使用 Sentinel 来进行资源保护，主要分为几个步骤:

定义资源
定义规则
检验规则是否生效

3.2、架构设计

在 Sentinel 里面，所有的资源都对应一个资源名称以及一个 Entry。Entry 可以通过对主流框架的适配自动创建，也可以通过注解的方式或调用 API 显式创建；每一个 Entry 创建的时候，同时也会创建一系列功能插槽（slot chain）。这些插槽有不同的职责，例如:

3.2.1、NodeSelectorSlot

NodeSelectorSlot 的本质作用：Sentinel 是通过一条一条资源“链路”来判断是否限流/降级的，而它就是用来维护这些资源链路的结构树。

具体干这几件事：

1、把资源“挂”到调用上下文树上
比如你访问 nodeA，它就会：

看你当前上下文是哪个入口（entrance1）
在 entrance1 节点下面查：有没有挂过 nodeA
没有就新建一个 DefaultNode(nodeA)，挂上去！

2、同一个资源，但不同入口，树结构是独立的！

ContextUtil.enter("entrance1", "appA");
SphU.entry("nodeA"); // 第一次
ContextUtil.exit();

ContextUtil.enter("entrance2", "appA");
SphU.entry("nodeA"); // 第二次
ContextUtil.exit();

这相当于你从两个不同入口玩了同一个关卡，Sentinel 会建立两条路径记录：

machine-root
    ├── EntranceNode(entrance1)
    │       └── DefaultNode(nodeA)
    └── EntranceNode(entrance2)
            └── DefaultNode(nodeA)

为什么这么设计？
因为在真实业务中：

你可能有多个入口（比如首页、搜索页都能访问同一个资源）
你想控制每条链路的 QPS（比如“从搜索页过来的 QPS 限制更严格”）

所以 Sentinel 就必须要分得清：

“你是从哪儿来的，然后才访问的这个资源”

3.2.2、ClusterBuilderSlot

ClusterBuilderSlot 则用于存储资源的统计信息以及调用者信息，例如该资源的 RT, QPS, thread count 等等，这些信息将用作为多维度限流，降级的依据；

ClusterBuilderSlot 的作用
1、调用方级别限流！

比如限制 “微信小程序” 每秒最多访问 100 次，其他 origin 不受影响。

2、监控更细粒度！

哪个来源调用最多？
哪个来源的调用最慢、最容易出错？

比如：是不是 Web 前端的调用出异常多，是不是他们传参老有问题？

配合热点参数限流、来源限流做更精细的控制。

3.3.3、StatisticSlot

StatisticSlot 是 Sentinel 的核心功能插槽之一，用于统计实时的调用数据。

clusterNode：资源唯一标识的 ClusterNode 的 runtime 统计
origin：根据来自不同调用者的统计信息
defaultnode: 根据上下文条目名称和资源 ID 的 runtime 统计入口的统计

Sentinel 底层采用高性能的滑动窗口数据结构 LeapArray 来统计实时的秒级指标数据，可以很好地支撑写多于读的高并发场景。

3.3.4、LeapArray底层原理

LeapArray 底层是一个固定长度的环形数组，每个元素是一个带有时间戳的窗口格子 WindowWrap。
它支持在高并发场景下以时间为索引安全读写，保证统计的是“最近一段时间”的窗口数据，用于 Sentinel 的实时监控与限流、降级判断。

结构总览：

public class LeapArray<T> {
    protected final int sampleCount; // 窗口格子数，比如10
    protected final int intervalInMs; // 窗口总时长，比如1000ms（1s）

    private final WindowWrap<T>[] array; // 固定长度数组，环形复用
}

每个窗口格子是这样一个类：

public class WindowWrap<T> {
    private final long windowStart; // 窗口开始时间
    private final long windowLength; // 每个格子的长度（interval / sampleCount）
    private final T value; // 存放统计信息的对象，比如 MetricBucket
}

它是怎么定位时间属于哪个窗口的？

比如：

总窗口时间是 1000ms，格子数是 10

每个格子负责 100ms

现在时间是 10:00:01.450（即 1450ms）

① 算出这个时间属于哪个格子：

int idx = (timestamp / windowLength) % sampleCount;
// 1450 / 100 = 14 -> 14 % 10 = 4，落在索引为4的格子

② 再判断这个格子的起始时间是不是还有效：

//当前时间戳 ➜ 除以窗口长度 ➜ 计算出当前时间该落在哪个格子 ➜ 比较该格子的起始时间 
//➜ 如果不同 ➜ 就滑窗、清理、重建！
window.windowStart == timestamp - (timestamp % windowLength)

如果有效：直接返回当前格子

如果无效（已经过期了）：用 CAS 创建一个新的 WindowWrap（复用原来的槽位）

3.3.4.1、它是怎么滑动更新的？

核心点：每次请求到来时，才会“懒更新”窗口格子

流程如下：

1、当前时间戳算出对应窗口索引（如上）

2、取出格子对象，检查是否是当前时间的窗口

是：直接用
否：CAS 替换为新窗口 + 清空旧统计值（滑动来了）

3、更新格子里的统计数据

它并不需要定时器或后台线程维护窗口，而是靠访问触发滑动，非常节省资源。

3.3.4.2、并发怎么处理？

多线程访问时可能并发写同一个窗口：

用的是 AtomicReferenceArray + Compare-And-Swap (CAS)
每个格子内部统计信息用 LongAdder 等并发友好结构

3.3.4.3、总结：

LeapArray 是一个时间轮+懒更新+CAS构建的滑动窗口数组，专为高并发下限流降级而生。

3.3.5、FlowSlot

这个 slot 主要根据预设的资源的统计信息，按照固定的次序，依次生效。如果一个资源对应两条或者多条流控规则，则会根据如下次序依次检验，直到全部通过或者有一个规则生效为止:

指定应用生效的规则，即针对调用方限流的；
调用方为 other 的规则；
调用方为 default 的规则。

3.3.6、DegradeSlot

这个 slot 主要针对资源的平均响应时间（RT）以及异常比率，来决定资源是否在接下来的时间被自动熔断掉。
在这里插入图片描述

4、代码实战

4.1、查看题库列表接口限流熔断

 /**
     * 分页获取题库列表（封装类）
     *
     * @param questionBankQueryRequest
     * @param request
     * @return
     */
    @PostMapping("/list/page/vo")
    @SentinelResource(value = "listQuestionBankVOByPage",
            blockHandler = "handleBlockException",
            fallback = "handleFallback")
    public BaseResponse<Page<QuestionBankVO>> listQuestionBankVOByPage(@RequestBody QuestionBankQueryRequest questionBankQueryRequest,
                                                               HttpServletRequest request) {
        long current = questionBankQueryRequest.getCurrent();
        long size = questionBankQueryRequest.getPageSize();
        // 限制爬虫
        ThrowUtils.throwIf(size > 200, ErrorCode.PARAMS_ERROR);
        // 查询数据库
        Page<QuestionBank> questionBankPage = questionBankService.page(new Page<>(current, size),
                questionBankService.getQueryWrapper(questionBankQueryRequest));
        // 获取封装类
        return ResultUtils.success(questionBankService.getQuestionBankVOPage(questionBankPage, request));
    }

熔断降级操作，处理异常 / 熔断场景下的兜底逻辑，避免用户看到系统崩溃。

 /**
     * listQuestionBankVOByPage 降级操作：直接返回本地数据
     */
    public BaseResponse<Page<QuestionBankVO>> handleFallback(@RequestBody QuestionBankQueryRequest questionBankQueryRequest,
                                                             HttpServletRequest request, Throwable ex) {
        // 可以返回本地数据或空数据
        return ResultUtils.success(null);
    }

限流操作

/**
     * listQuestionBankVOByPage 流控操作
     * 限流：提示“系统压力过大，请耐心等待”
     * 熔断：执行降级操作
     */
    public BaseResponse<Page<QuestionBankVO>> handleBlockException(@RequestBody QuestionBankQueryRequest questionBankQueryRequest,
                                                                   HttpServletRequest request, BlockException ex) {
        // 降级操作
        if (ex instanceof DegradeException) {
            return handleFallback(questionBankQueryRequest, request, ex);
        }
        // 限流操作
        return ResultUtils.error(ErrorCode.SYSTEM_ERROR, "系统压力过大，请耐心等待");
    }

小Tips💡：为什么需要专门写降级操作判断？

// 降级操作
        if (ex instanceof DegradeException) {
            return handleFallback(questionBankQueryRequest, request, ex);
        }

Sentinel 中“熔断触发”其实本质上也是一种“被限流”行为，会先走 blockHandler，而不是直接走 fallback。

具体来说

情况	触发逻辑	进入哪个方法？
QPS 超限	Sentinel 流控规则	`blockHandler()`
异常率 > 50% 熔断开启	Sentinel 熔断规则	也进入 `blockHandler()`！
方法内空指针等异常	Java 抛异常	`fallback()`

这时候你在 blockHandler() 里接收到的是 BlockException，它可能是：

FlowException（QPS 控制）
DegradeException（熔断控制）
ParamFlowException（热点参数）
AuthorityException（授权规则）
SystemBlockException（系统保护）

你得根据 ex instanceof DegradeException 去区分熔断的 case。

总结：虽然 Sentinel 有 fallback 专门处理异常 / 熔断，但在触发熔断时默认走的是 blockHandler，你必须自己判断 ex 类型来决定要不要转交给 fallback 处理。也可以理解为：只有业务‏异常（比如请求参数错误、或؜者数据库操作失败等问题），才会算到熔断条件中，限流熔‌断本身的异常 BlockE‏xception 是不计算的

4.2、单 IP 查看题目列表限流熔断

对于这个需求，需要对每个用户进一步精细化限流，而不是整体接口限流，可以采用 热点参数限流机制，允许根据参数控制限流触发条件，例如：将 IP 地址作为热点参数。
在这里插入图片描述
代码如下：

/**
     * 分页获取题目列表（封装类） - 限流版
     *
     * @param questionQueryRequest
     * @param request
     * @return
     */
    @PostMapping("/list/page/vo/sentinel")
    public BaseResponse<Page<QuestionVO>> listQuestionVOByPageSentinel(@RequestBody QuestionQueryRequest questionQueryRequest,
                                                               HttpServletRequest request) {
        long current = questionQueryRequest.getCurrent();
        long size = questionQueryRequest.getPageSize();
        // 限制爬虫
        ThrowUtils.throwIf(size > 20, ErrorCode.PARAMS_ERROR);
        // 基于 IP 限流
        String remoteAddr = request.getRemoteAddr();
        Entry entry = null;
        try  {
            entry = SphU.entry("listQuestionVOByPage", EntryType.IN, 1, remoteAddr);
            // 被保护的业务逻辑
            // 查询数据库
            Page<Question> questionPage = questionService.listQuestionByPage(questionQueryRequest);
            // 获取封装类
            return ResultUtils.success(questionService.getQuestionVOPage(questionPage, request));
        } catch (Throwable t) {
            // 自定义业务异常
            if (!BlockException.isBlockException(t)) {
                Tracer.trace(t);
                return ResultUtils.error(ErrorCode.SYSTEM_ERROR, "系统异常");
            }
            // 资源访问阻止，被限流或被降级
            if (t instanceof DegradeException) {
                return handleFallback(questionQueryRequest, request, t);
            }
            // 限流操作
            return ResultUtils.error(ErrorCode.SYSTEM_ERROR, "访问过于频繁，请稍后再试");
        } finally {
            if (entry != null) {
                entry.exit(1, remoteAddr);
            }
        }

    }


/**
     * listQuestionVOByPageSentinel 降级操作：直接返回本地数据
     */
    public BaseResponse<Page<QuestionVO>> handleFallback(@RequestBody QuestionQueryRequest questionQueryRequest,
                                                             HttpServletRequest request, Throwable ex) {
        // 可以返回本地数据或空数据
        return ResultUtils.success(null);
    }

String remoteAddr = request.getRemoteAddr() 参数 remoteAddr 的作用是获取用户 IP，作为限流参数维度，防止一个 IP 乱刷。

entry = SphU.entry("listQuestionVOByPage", EntryType.IN, 1, remoteAddr) 作用是将 listQuestionVOByPage 作为资源注册到 Sentinel 的上下文中，开始对该资源进行限流、熔断、热点参数等规则的监控与统计。

异常处理判断逻辑：

情况	处理方式
不是 Sentinel 异常（业务异常、系统异常）	打点上报（`Tracer.trace(t)`），提示“系统异常”
是 Sentinel 熔断异常（`DegradeException`）	走自定义的降级处理逻辑：`handleFallback`
是 Sentinel 限流异常（`FlowException` 等）	返回：“访问过于频繁，请稍后再试”

重点💡

1、若 entry 的时候传入了热点参数，那么 exit 的时候也一定要带上对应的参数（exit(count, args)），否则可能会有统计错误。

2、SphU.entry(xxx) 需要与 entry.exit() 方法成对出现，匹配调用，否则会导致调用链记录异常，抛出 ErrorEntryFreeException 异常。

3、注意 Sentinel 的降级仅针对业务异常，对 Sentinel 限流降级本身的异常 BlockException 不生效。为了统计异常比例或异常数，需要手动通过 Tracer.trace(ex) 记录业务异常。

4.3、定义规则

新建 sentinel 包并定义一个单独的 Manager 作为 Bean，利用 @PostConstruct 注解，在 Bean 加载后创建规则。

@Component
public class SentinelRulesManager {
    @PostConstruct
    public void initRules() throws Exception {
        initFlowRules();
        initDegradeRules();
    }

    // 限流规则
    public void initFlowRules() {
        // 单 IP 查看题目列表限流规则
        ParamFlowRule rule = new ParamFlowRule("listQuestionVOByPage")
                .setParamIdx(0) // 对第 0 个参数限流，即 IP 地址
                .setCount(60) // 每分钟最多 60 次
                .setDurationInSec(60); // 规则的统计周期为 60 秒
        ParamFlowRuleManager.loadRules(Collections.singletonList(rule));
    }

    // 降级规则
    public void initDegradeRules() {
        // 单 IP 查看题目列表熔断规则
        DegradeRule slowCallRule = new DegradeRule("listQuestionVOByPage")
                .setGrade(CircuitBreakerStrategy.SLOW_REQUEST_RATIO.getType())
                .setCount(0.2) // 慢调用比例大于 20%
                .setTimeWindow(60) // 熔断持续时间 60 秒
                .setStatIntervalMs(30 * 1000) // 统计时长 30 秒
                .setMinRequestAmount(10) // 最小请求数
                .setSlowRatioThreshold(3); // 响应时间超过 3 秒

        DegradeRule errorRateRule = new DegradeRule("listQuestionVOByPage")
                .setGrade(CircuitBreakerStrategy.ERROR_RATIO.getType())
                .setCount(0.1) // 异常率大于 10%
                .setTimeWindow(60) // 熔断持续时间 60 秒
                .setStatIntervalMs(30 * 1000) // 统计时长 30 秒
                .setMinRequestAmount(10); // 最小请求数

        // 加载规则
        DegradeRuleManager.loadRules(Arrays.asList(slowCallRule, errorRateRule));
    }
}

本地化配置，让 Sentinel 的限流和降级规则支持本地文件持久化（可读可写）

/**
 * 持久化配置为本地文件
 */
public void listenRules() throws Exception {
    //获取项目根目录并创建 sentinel/ 文件夹
    String rootPath = System.getProperty("user.dir");
    File sentinelDir = new File(rootPath, "sentinel");
    if (!FileUtil.exist(sentinelDir)) {
        FileUtil.mkdir(sentinelDir);
    }
    
    // 设置规则文件路径
    String flowRulePath = new File(sentinelDir, "FlowRule.json").getAbsolutePath();
    String degradeRulePath = new File(sentinelDir, "DegradeRule.json").getAbsolutePath();

    // 初始化 限流规则读取器（拉模式）
    ReadableDataSource<String, List<FlowRule>> flowRuleDataSource = new FileRefreshableDataSource<>(flowRulePath, flowRuleListParser);
    FlowRuleManager.register2Property(flowRuleDataSource.getProperty());
	//注册 限流规则写入器
    WritableDataSource<List<FlowRule>> flowWds = new FileWritableDataSource<>(flowRulePath, this::encodeJson);
    WritableDataSourceRegistry.registerFlowDataSource(flowWds);

    // 降级规则读取器
    FileRefreshableDataSource<List<DegradeRule>> degradeRuleDataSource
            = new FileRefreshableDataSource<>(
            degradeRulePath, degradeRuleListParser);
    DegradeRuleManager.register2Property(degradeRuleDataSource.getProperty());
    WritableDataSource<List<DegradeRule>> degradeWds = new FileWritableDataSource<>(degradeRulePath, this::encodeJson);
    // Register to writable data source registry so that rules can be updated to file
    WritableDataSourceRegistry.registerDegradeDataSource(degradeWds);
}

//JSON字符串 -> 规则对象
private Converter<String, List<FlowRule>> flowRuleListParser = source -> JSON.parseObject(source,
        new TypeReference<List<FlowRule>>() {
        });
private Converter<String, List<DegradeRule>> degradeRuleListParser = source -> JSON.parseObject(source,
        new TypeReference<List<DegradeRule>>() {
        });

// 规则对象 -> JSON字符串
private <T> String encodeJson(T t) {
    return JSON.toJSONString(t);
}

注意：在初始化时加入 listenRules()方法

 @PostConstruct
    public void initRules() throws Exception {
        initFlowRules();
        initDegradeRules();
        listenRules();
    }

5、总结

Sentinel 的规则配置 + 接口中的限流/熔断操作的联动协同

5.1、规则配置部分（限流 & 熔断）

①在内存中加载规则（程序启动时）

如对 listQuestionVOByPage 添加：

限流：每个 IP 每分钟访问不超 60 次
熔断：慢调用比例超 20%，触发熔断；异常率超 10%，也触发熔断

②文件持久化监听

调用 listenRules() 做两件事：监听本地文件变化，自动刷新配置

将规则写回文件（支持动态修改）

5.2、接口限流/熔断的具体操作（怎么用规则）

①注解方式（简洁明了）

具体来说：

应规则名就是 value 指定的 “listQuestionBankVOByPage”：

如果被限流了 ➜ 走 handleBlockException()
如果被熔断了 ➜ 也会走 handleBlockException()，但你可以判断异常类型 DegradeException
如果业务异常了（比如系统异常）➜ 走 handleFallback()

②编程方式（可扩展性强）

entry = SphU.entry("listQuestionVOByPage", EntryType.IN, 1, remoteAddr);

参数 remoteAddr 作为限流 key（这是为了实现 ParamFlowRule）
try-catch 中写核心业务逻辑
catch 中判断是否是限流/熔断异常：

对于对单个接口整体限流我们使用 @SentinelResource 注解方式 做限流操作，这时注解会监控所有参数。

对于单个IP查看题目列表限流熔断用 编程式 做限流操作，是因为我们只需要对 用户IP 这一个参数监控，不需要对传入的所有参数做监控。