Sentinel之熔断降级DegradeSlot

在本篇文章中将讲解有关熔断降级的原理。

熔断降级策略是在DegradeSlot中实现的，会调用entry()方法。

public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count, boolean prioritized, Object... args)
        throws Throwable {
        DegradeRuleManager.checkDegrade(resourceWrapper, context, node, count);
        fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }

下面的逻辑主要是根据当前的资源名从在DegradeRuleManager的map缓存中获取所有有关他的熔断规则。然后遍历规则，依次判断。 如果需要进行熔断，则抛出DegradeException异常。

private static final Map<String, Set<DegradeRule>> degradeRules = new ConcurrentHashMap<>();
public static void checkDegrade(ResourceWrapper resource, Context context, DefaultNode node, int count)
        throws BlockException {

        Set<DegradeRule> rules = degradeRules.get(resource.getName());
        if (rules == null) {
            return;
        }

        for (DegradeRule rule : rules) {
            if (!rule.passCheck(context, node, count)) {
                throw new DegradeException(rule.getLimitApp(), rule);
            }
        }
    }

具体的判断是调用DegradeRule下的passCheck()方法。

先讲解下DegradeRule的有关变量。

public class DegradeRule extends AbstractRule {

    // 大小是虚拟机可用的最大数量
    private static ScheduledExecutorService pool = Executors.newScheduledThreadPool(
        Runtime.getRuntime().availableProcessors(), new NamedThreadFactory("sentinel-degrade-reset-task", true));
    // RT阈值或异常比率阈值计数
    private double count;
    // 发生降级时降级恢复超时（以秒为单位）
    private int timeWindow;
    // 降级策略（0：平均RT，1：异常比率，2：异常计数）。
    private int grade = RuleConstant.DEGRADE_GRADE_RT;
    // 触发RT响应熔断出现的最小连续慢响应请求数量 
    // 默认值为5次
    private int rtSlowRequestAmount = RuleConstant.DEGRADE_DEFAULT_SLOW_REQUEST_AMOUNT;
   // 触发熔断的最小的请求数
    private int minRequestAmount = RuleConstant.DEGRADE_DEFAULT_MIN_REQUEST_AMOUNT;
    
    private AtomicLong passCount = new AtomicLong(0);
    // 是否发生降级
    private final AtomicBoolean cut = new AtomicBoolean(false);

下面开始讲解在一个降级规则DegradeRule怎么判断是否降级的。

public boolean passCheck(Context context, DefaultNode node, int acquireCount, Object... args) {
        // 如果当前正处于降级阶段，则直接返回false
        if (cut.get()) {
            return false;
        }
        // 获取该资源的ClusterNode
        ClusterNode clusterNode = ClusterBuilderSlot.getClusterNode(this.getResource());
        if (clusterNode == null) {
            return true;
        }
        // 如果是根据请求响应时间RT进行判断  
        if (grade == RuleConstant.DEGRADE_GRADE_RT) {
            // 获取该节点的平均响应时间
            double rt = clusterNode.avgRt();
            // 如果当前平均响应时间小于阈值，则可以通过，并重置passcount为0  
            if (rt < this.count) {
                passCount.set(0);
                return true;
            }
            // 执行到这里说明当前的平均响应时间大于阈值了，此时进入了准降级阶段，不会立即进入降级    
            // 如果该状态连续请求次数小于rtSlowRequestAmount，则放行
            if (passCount.incrementAndGet() < rtSlowRequestAmount) {
                return true;
            }
        // 如果根据异常比例进行判断  
        } else if (grade == RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO) {
            // 当前异常数
            double exception = clusterNode.exceptionQps();
            // 当前请求成功数
            double success = clusterNode.successQps();
            // 请求总数
            double total = clusterNode.totalQps();
            // If total amount is less than minRequestAmount, the request will pass.
            if (total < minRequestAmount) {
                return true;
            }

            // 在相同的对齐统计时间窗口中， 
            // "success" (aka. completed count) = exception count + non-exception count (realSuccess)
            double realSuccess = success - exception;
            // 如果真实成功数小于0，并且异常数小于minRequestAmount
            if (realSuccess <= 0 && exception < minRequestAmount) {
                return true;
            }
            // 如果异常比例小于阈值
            if (exception / success < count) {
                return true;
            }
        // 如果根据异常数量
        } else if (grade == RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT) {
            double exception = clusterNode.totalException();
            if (exception < count) {
                return true;
            }
        }
        // 当触发熔断降级时，原子更新为true
        // 并开启一个定时任务，在熔断时间过后，将熔断状态设置为false,并将通过计数重设为0  
        if (cut.compareAndSet(false, true)) {
            ResetTask resetTask = new ResetTask(this);
            pool.schedule(resetTask, timeWindow, TimeUnit.SECONDS);
        }
        return false;
    }

private static final class ResetTask implements Runnable {
        private DegradeRule rule;
        ResetTask(DegradeRule rule) {
            this.rule = rule;
        }

        @Override
        public void run() {
            rule.passCount.set(0);
            rule.cut.set(false);
        }
    }

比起流量控制，熔断降级很简单。

参考文章：

源码分析 Sentinel DegradeSlot 熔断实现原理
熔断降级