Sentinel使用示例、源码解析、滑动时间窗口算法等详解

目录

一、基本使用

（1）限流方式一：捕获异常的方式定义资源

1. pom文件引入

2. 代码示例准备

3. 运行代码

 （2）限流方式二注解方式：

1. 需要引入支持注解的jar包：

2. 注解方式代码：

3. 运行代码

（3）熔断降级

二、源码解析

1. 整体看源码链路

SentinelResourceAspect

(1). CtSph.lookProcessChain() 核心方法！

(2).  chain.entry 整个链条的调用

2. StatisticSlot.entry

3. FlowSlot.entry

4. DegradeSlot.entry

三、限流算法滑动时间窗口

1. StatisticSlot.entry

1）rollingCounterInSecond

2）StatisticNode.addPass()

2. ArrayMetric.addPass()

3. 自己实现滑动时间窗口算法

四、漏桶算法

五、令牌桶算法

 六、限流算法对比

1. 计数器 VS 滑动窗口

2. 漏桶算法 VS 令牌桶算法

---

一、基本使用

Sentinel 是面向分布式服务架构的高可用流量防护组件，主要以流量为切入点，从限流、流量整形、熔断降级、系统负载保护、热点防护等多个维度来帮助开发者保障微服务的稳定性。

下面示例是SpringBoot结合Sentinel，使用上比较简单。

（1）限流方式一：捕获异常的方式定义资源

1. pom文件引入

    
        org.springframework.boot
        spring-boot-starter-parent
        2.2.6.RELEASE
    

    
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
        
        
            com.alibaba.cloud
            spring-cloud-starter-alibaba-sentinel
            2.2.5.RELEASE
        

        
            org.projectlombok
            lombok
            1.18.6
        
    

2. 代码示例准备

// 项目启动类
@SpringBootApplication
public class SentinelApplication {
    public static void main(String[] args) {
        SpringApplication.run(SentinelApplication.class, args);
    }
}

// service层
@Service
public class OrderQueryService {
    public String queryOrderInfo(String orderId) {
        System.out.println("获取订单信息:" + orderId);
        return "return OrderInfo :" + orderId;
    }
}

// controller层
@Slf4j
@RestController
public class OrderCreateController {

    @Autowired
    private OrderQueryService orderQueryService;

    /**
     * 最原始方法--需要捕获异常
     * @param orderId
     * @return
     */
    @RequestMapping("/getOrder")
    @ResponseBody
    public String queryOrder1(@RequestParam("orderId") String orderId) {
        Entry entry = null;
        try {
            // 传入资源
            entry = SphU.entry(SentinelConfigs.KEY);
            return orderQueryService.queryOrderInfo(orderId);
        } catch (BlockException e) {
            // 接口被限流的时候, 会进入到这里
            log.warn("---queryOrder1接口被限流了---, exception: ", e);
            return "接口限流, 返回空";
        } finally {
            if (entry != null) {
                entry.exit();
            }
        }
    }
}

sentinel规则设置：

@Component
public class SentinelConfigs {
    public static final String KEY = "flowSentinelKey";

    @Bean
    public void initFlowQpsRule() {
        List rules = new ArrayList();
        FlowRule rule1 = new FlowRule();
        rule1.setResource(KEY);
        // QPS控制在2以内
        rule1.setCount(2);
        // QPS限流
        rule1.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule1.setLimitApp("default");
        rules.add(rule1);
        FlowRuleManager.loadRules(rules);
    }
}

3. 运行代码

当qps>2时，就会触发限流，如下：

 （2）限流方式二：注解方式：

上面是最原始的方式实现限流，但是对代码侵入性太高，我们推荐使用注解方式！

1. 需要引入支持注解的jar包：

        
            com.alibaba.csp
            sentinel-annotation-aspectj
            1.8.0
        

/**
 * Sentinel切面类配置
 */
@Configuration
public class SentinelAspectConfiguration {

    @Bean
    public SentinelResourceAspect getSentinelResource() {
        return new SentinelResourceAspect();
    }
}

2. 注解方式代码：

    @SentinelResource(value = "getOrderInfo",
            blockHandler = "flowQpsException",
            fallback = "queryOrder2FallBack")
    public String queryOrder2(String orderId) {
        // 模拟接口运行时抛出代码异常
        if ("0".equals(orderId)) {
            throw new RuntimeException();
        }
        System.out.println("获取订单信息:" + orderId);
        return "return OrderInfo :" + orderId;
    }

    /**
     * qps异常，被限流
     * 注意: 方法参数、返回值要与原函数保持一致
     *
     * @param orderId
     * @param e
     * @return
     */
    public String flowQpsException(String orderId, BlockException e) {
        e.printStackTrace();
        return "flowQpsException for queryOrder22: " + orderId;
    }

    /**
     * 运行时异常的fallback方式
     * 注意: 方法参数、返回值要与原函数保持一致
     *
     * @param orderId
     * @param a
     * @return
     */
    public String queryOrder2FallBack(String orderId, Throwable a) {
        return "fallback queryOrder2: " + orderId;
    }

controller方法测试：

    /**
     * 限流方式二：注解方式定义
     *
     * @param orderId
     * @return
     */
    @RequestMapping("/query/order2")
    @ResponseBody
    public String queryOrder3(@RequestParam("orderId") String orderId) {
        return orderQueryService.queryOrder2(orderId);
    }

3. 运行代码

模拟运行时异常，执行fallback方法

请求：​​​​​​http://localhost:8080//query/order2?orderId=0

 模拟限流：

请求：http://localhost:8080//query/order2?orderId=1223

正常执行了限流操作。 

（3）熔断降级

Sentinel 提供以下几种熔断策略：

• 慢调用比例 (SLOW_REQUEST_RATIO)：选择以慢调用比例作为阈值，需要设置允许的慢调用 RT（即最大的响应时间），请求的响应时间大于该值则统计为慢调用。当单位统计时长（statIntervalMs）内请求数目大于设置的最小请求数目，并且慢调用的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求响应时间小于设置的慢调用 RT 则结束熔断，若大于设置的慢调用 RT 则会再次被熔断。
• 异常比例 (ERROR_RATIO)：当单位统计时长（statIntervalMs）内请求数目大于设置的最小请求数目，并且异常的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。异常比率的阈值范围是 [0.0, 1.0]，代表 0% - 100%。
• 异常数 (ERROR_COUNT)：当单位统计时长内的异常数目超过阈值之后会自动进行熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。

直接上代码：

@Slf4j
@RestController
public class DegradeController {
    @Autowired
    private DegradeService degradeService;

    @RequestMapping("/query/info/v1")
    public String queryInfo(@RequestParam("spuId") String spuId) {
        String res = degradeService.queryInfo(spuId);
        return res;
    }
}

 降级这里有三种设置方式，这里只写一个例子：设置异常比例。

@Configuration
public class DegradeConfigs {

    /**
     * Sentinel切面类配置
     * @return
     */
    @Bean
    public SentinelResourceAspect getSentinelResource() {
        return new SentinelResourceAspect();
    }

    /**
     * DEGRADE_GRADE_EXCEPTION_RATIO
     * 将比例设置成0.1将全部通过, exception_ratio = 异常/通过量
     * 当资源的每秒异常总数占通过量的比值超过阈值（DegradeRule 中的 count）之后，资源进入降级状态
     */
    @PostConstruct
    public void initDegradeRule() {
        List rules = new ArrayList<>();
        DegradeRule rule = new DegradeRule();
        rule.setResource("queryInfo");
        
        rule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO);
        // 错误比例设置为0.1
        rule.setCount(0.1);

        // 设置时间窗口：10s
        rule.setTimeWindow(10);
        rules.add(rule);
        DegradeRuleManager.loadRules(rules);
    }
}

@Slf4j
@Service
public class DegradeService {
    private static final String KEY = "queryInfo";

    @SentinelResource(value = KEY,
            blockHandler = "blockHandlerMethod",
            fallback = "queryInfoFallback")
    public String queryInfo(String spuId) {

        // 模拟调用服务出现异常
        if ("0".equals(spuId)) {
            throw new RuntimeException();
        }
        return "query goodsinfo success, " + spuId;
    }

    public String blockHandlerMethod(String spuId, BlockException e) {
        log.warn("queryGoodsInfo222 blockHandler", e.toString());
        return "已触发限流, blockHandlerMethod res: " + spuId;

    }

    public String queryInfoFallback(String spuId, Throwable e) {
        log.warn("queryGoodsInfo222 fallback", e.toString());
        return "业务异常, return fallback res: " + spuId;
    }
}

测试的时候，可以使用jmeter压一下，我设置的比较简单，使用postman或者网页直接请求都行，多点几次，就能看到降级的执行：

测试请求：http://localhost:8080/query/info/v1?spuId=0 

官方也有降级例子，可以看下：
熔断降级 · alibaba/Sentinel Wiki · GitHub

二、源码解析

说明：

1. 先概括性的看源码的整个调用链路，下面三部分介绍几个常用的重要slot的源码

2. StatisticSlot 用于存储资源的统计信息，例如资源的RT、QPS、thread count等等，这些信息将用作多维度限流，降级的依据(fireEntry用来触发下一个规则的调用)

3. FlowSlot 校验资源流控规则

4. DegradeSlot 校验资源流降级规则

1. 整体看源码链路

SentinelResourceAspect

// 请关注这行代码
entry = SphU.entry(resourceName, resourceType, entryType, pjp.getArgs());

一直点进去，看里面的方法

CtSph.entryWithType

public Entry entryWithType(String name, int resourceType, EntryType entryType, int count, boolean prioritized, Object[] args) throws BlockException {
        // 将资源名称包装成StringResourceWrapper
        StringResourceWrapper resource = new StringResourceWrapper(name, entryType, resourceType);
        return this.entryWithPriority(resource, count, prioritized, args);
    }

CtSph.asyncEntryWithPriorityInternal()

    // 前面的if else边缘逻辑，先忽略
    private AsyncEntry asyncEntryWithPriorityInternal(ResourceWrapper resourceWrapper, int count, boolean prioritized, Object... args) throws BlockException {
        Context context = ContextUtil.getContext();
        if (context instanceof NullContext) {
            return this.asyncEntryWithNoChain(resourceWrapper, context);
        } else {
            if (context == null) {
                context = CtSph.InternalContextUtil.internalEnter("sentinel_default_context");
            }

            if (!Constants.ON) {
                return this.asyncEntryWithNoChain(resourceWrapper, context);
            } else {
                // 核心方法！！！
                ProcessorSlot