【Sentinel】降级源码：插槽DegradeSlot与断路器的实现

短命女 2023-10-15 16:18 110阅读 0赞

#### 文章目录 ####

*  1、实现原理
 *  2、DegradeSlot类
 *  3、CircuitBreaker
 *  4、触发断路器

## 1、实现原理 ##

Sentinel的降级是基于状态机来实现的：

![在这里插入图片描述][ff4889ee5bc94b5b9863f3f3ad60f321.png]

## 2、DegradeSlot类 ##

熔断降级的逻辑在DegradeSlot类中实现，核心API：

@Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, 
                      int count, boolean prioritized, Object... args) throws Throwable {
        
        // 熔断降级规则判断
        performChecking(context, resourceWrapper);
    	// 继续下一个slot
        fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }

继续进入`performChecking`方法：

void performChecking(Context context, ResourceWrapper r) throws BlockException {
        
        // 获取当前资源上的所有的断路器 CircuitBreaker
        List<CircuitBreaker> circuitBreakers = DegradeRuleManager.getCircuitBreakers(r.getName());
        if (circuitBreakers == null || circuitBreakers.isEmpty()) {
        
            return;
        }
        for (CircuitBreaker cb : circuitBreakers) {
        
            // 遍历断路器，逐个判断
            if (!cb.tryPass(context)) {
        
                throw new DegradeException(cb.getRule().getLimitApp(), cb.getRule());
            }
        }
    }

## 3、CircuitBreaker ##

进入断路器类CircuitBreaker的tryPass方法中：

@Override
    public boolean tryPass(Context context) {
        
        // 判断状态机状态
        if (currentState.get() == State.CLOSED) {
        
            // 如果是closed状态，直接放行
            return true;
        }
        if (currentState.get() == State.OPEN) {
        
            // 如果是OPEN状态，断路器打开
            // 继续判断OPEN时间窗是否结束，如果是则把状态从OPEN切换到 HALF_OPEN，返回true
            return retryTimeoutArrived() && fromOpenToHalfOpen(context);
        }
        // OPEN状态，并且时间窗未到，返回false
        return false;
    }

有关时间窗的判断在`retryTimeoutArrived()`方法：

protected boolean retryTimeoutArrived() {
        
        // 当前时间 大于 下一次 HalfOpen的重试时间
        return TimeUtil.currentTimeMillis() >= nextRetryTimestamp;
    }

OPEN到HALF\_OPEN切换在`fromOpenToHalfOpen(context)`方法：

protected boolean fromOpenToHalfOpen(Context context) {
        
        // 基于CAS修改状态，从 OPEN到 HALF_OPEN
        if (currentState.compareAndSet(State.OPEN, State.HALF_OPEN)) {
        
            // 状态变更的事件通知
            notifyObservers(State.OPEN, State.HALF_OPEN, null);
            // 得到当前资源
            Entry entry = context.getCurEntry();
            // 给资源设置监听器，在资源Entry销毁时（资源业务执行完毕时）触发
            entry.whenTerminate(new BiConsumer<Context, Entry>() {
        
                @Override
                public void accept(Context context, Entry entry) {
        
                    // 判断 资源业务是否异常
                    if (entry.getBlockError() != null) {
        
                        // 如果异常，则再次进入OPEN状态
                        currentState.compareAndSet(State.HALF_OPEN, State.OPEN);
                        notifyObservers(State.HALF_OPEN, State.OPEN, 1.0d);
                    }
                }
            });
            return true;
        }
        return false;
    }

到此，出现了从OPEN到HALF\_OPEN、从HALF\_OPEN到OPEN的变化，但是还有几个没有：

*  从CLOSED到OPEN
 *  从HALF\_OPEN到CLOSED

## 4、触发断路器 ##

请求经过所有插槽 后，一定会执行exit方法，而在DegradeSlot的exit方法中：

![在这里插入图片描述][81896039bd4547a393ab190b43b0d80f.png]  
会调用CircuitBreaker的onRequestComplete方法。而CircuitBreaker有两个实现：

![在这里插入图片描述][f343bb2434754eb2b1292e750e4d5251.png]  
这里以异常比例熔断为例来看，进入`ExceptionCircuitBreaker`的`onRequestComplete`方法：

@Override
    public void onRequestComplete(Context context) {
        
        // 获取资源 Entry
        Entry entry = context.getCurEntry();
        if (entry == null) {
        
            return;
        }
        // 尝试获取资源中的异常
        Throwable error = entry.getError();
        // 获取计数器，同样采用了滑动窗口来计数
        SimpleErrorCounter counter = stat.currentWindow().value();
        if (error != null) {
        
            // 如果出现异常，则 error计数器 +1
            counter.getErrorCount().add(1);
        }
        // 不管是否出现异常，total计数器 +1
        counter.getTotalCount().add(1);
    	// 判断异常比例是否超出阈值
        handleStateChangeWhenThresholdExceeded(error);
    }

来看阈值判断的方法：

private void handleStateChangeWhenThresholdExceeded(Throwable error) {
        
        // 如果当前已经是OPEN状态，不做处理
        if (currentState.get() == State.OPEN) {
        
            return;
        }
    	// 如果已经是 HALF_OPEN 状态，判断是否需求切换状态
        if (currentState.get() == State.HALF_OPEN) {
        
            if (error == null) {
        
                // 没有异常，则从 HALF_OPEN 到 CLOSED
                fromHalfOpenToClose();
            } else {
        
                // 有一次，再次进入OPEN
                fromHalfOpenToOpen(1.0d);
            }
            return;
        }
    	// 说明当前是CLOSE状态，需要判断是否触发阈值
        List<SimpleErrorCounter> counters = stat.values();
        long errCount = 0;
        long totalCount = 0;
        // 累加计算 异常请求数量、总请求数量
        for (SimpleErrorCounter counter : counters) {
        
            errCount += counter.errorCount.sum();
            totalCount += counter.totalCount.sum();
        }
        // 如果总请求数量未达到阈值，什么都不做
        if (totalCount < minRequestAmount) {
        
            return;
        }
        double curCount = errCount;
        if (strategy == DEGRADE_GRADE_EXCEPTION_RATIO) {
        
            // 计算请求的异常比例
            curCount = errCount * 1.0d / totalCount;
        }
        // 如果比例超过阈值，切换到 OPEN
        if (curCount > threshold) {
        
            transformToOpen(curCount);
        }
    }

[ff4889ee5bc94b5b9863f3f3ad60f321.png]: https://img-blog.csdnimg.cn/ff4889ee5bc94b5b9863f3f3ad60f321.png
[81896039bd4547a393ab190b43b0d80f.png]: https://img-blog.csdnimg.cn/81896039bd4547a393ab190b43b0d80f.png
[f343bb2434754eb2b1292e750e4d5251.png]: https://img-blog.csdnimg.cn/f343bb2434754eb2b1292e750e4d5251.png