sentinel流量控制和熔断降级执行流程之源码分析

前言：

　sentinel是阿里针对服务流量控制、熔断降级的框架，如何使用官方都有很详细的文档，下载它的源码包里面对各大主流框都做了适配按理，本系列文章目的主要通过源码分析sentinel流量控制和熔断降级的流程

提前准备好sentinel控制台如有下载源码启动sentinel dashboard模块

本文演示的项目通过引入spring-cloud-starter-alibaba-sentinel包来实现接入sentinel功能

入门案例

下面举一个最简单的案例埋点来引出流控入口

public String getOrderInfo(String orderNo) {
　　　　 ContextUtil.enter("getOrderInfo", "application-a");
        Entry entry = null;
        try {
            // name:资源名 EntryType 流量类型为入口还是出口，系统规则只针对入口流量， batchCount:当前请求流量, args:参数
            entry = SphU.entry("getOrderInfo", EntryType.IN, 1, orderNo);
            getUserInfo();
        } catch (BlockException e) {
            e.printStackTrace();
        } finally {
            entry.exit();
        }
        return "orderInfo = " + orderNo;
    }

    public String getUserInfo() {
        Entry entry = null;
        try {
            entry = SphU.entry("getUserInfo", EntryType.OUT, 1);
        } catch (BlockException e) {
            e.printStackTrace();
        } finally {
            entry.exit();
        }
        return "userInfo";
    }

public static Entry entry(String name, EntryType trafficType, int batchCount, Object... args) throws BlockException

也可以通过注解的方式引入,执行方法时SentinelResourceAspect会做拦截进行流控处理，当然什么都不配也是可以的，因为引入spring-cloud-starter-alibaba-sentinel包spring mvc和spring webflux做了适配，自动会对每一个请求做埋点

@GetMapping("getOrderInfo")
@SentinelResource(value = "/getOrderInfo", entryType = EntryType.IN)
public String getOrderInfo(@RequestParam("orderNo") String orderNo) {
    return "orderInfo = " + orderNo;
}

ContextUtil.enter(“getOrderInfo”, “application-a”) 来表示调用链的入口，可以暂时理解为上下文，一般不做声明后面会默认创建

第一个参数为context-name,区分不同的调用链入口,默认常量值sentinel_default_context，

第二参数为调用来源，这个参数可以细分从不同应用来源发出的请求，授权规则白名单和黑名单会根据该参数做限制，

然后通过SphU.entry（）埋点进入，下面说下这个方法几个参数的含义

name:当前资源名
trafficType:流量类型分别为入口流量和出口流量。入口流量和出口流量执行过程都是差不多，只是入口流量会多了一个系统规则拦截，像是上面案例从订单服务调用getUserInfo，getUserInfo是去调用用户服务，它的流量方式是出去的，压力都在用户服务那边，不用考虑当前服务器的压力，所以标为出口流量
batchCount：当前流量数量，一般默认为1
args：参数，后面做热点参数规则时用到

BlockException：当某一规则不通过时会抛出对应异常

SphU.entry(xxx) 需要与 entry.exit() 方法成对出现，匹配调用，如有嵌套像上面，需先退出getUserInfo的entry在退出getOrderInfo的entry

打开打控制台，此时应该是空白的，sentinel控制台是懒加载模式，需要调用一下相关资源接口就可以看到

可以看到sentinel规则配置主要有流控规则，降级规则，热点规则，系统规则，授权规则，先简单介绍下规则作用，其它配置也很简单一目了然，后面通过结合源码来深入分析

流控规则：针对资源流量控制
热点规则：针对资源的热点参数做流量控制
降级规则：针对资源的调度情况来做降级处理
系统规则：针对当前服务做全局流量控制
授权规则：对访问资源的特定应用做授权处理

我们随着SphU.entry（）入口来走进源码

SphU.entry(xxx)执行过程源码分析

流控规则执行前的准备

public static Entry entry(String name, EntryType trafficType, int batchCount, Object... args)
    throws BlockException {
    return Env.sph.entry(name, trafficType, batchCount, args);
}

public Entry entry(String name, EntryType type, int count, Object... args) throws BlockException {
    // 将资源名称和流量类型进行包装
    StringResourceWrapper resource = new StringResourceWrapper(name, type);
    return entry(resource, count, args);
}

private Entry entryWithPriority(ResourceWrapper resourceWrapper, int count, boolean prioritized, Object... args)
    throws BlockException {
    // 这里返回当前线程持有的context
    Context context = ContextUtil.getContext();
    if (context instanceof NullContext) {
        return new CtEntry(resourceWrapper, null, context);
    }
    if (context == null) {
        // 为空创建一个默认
        context = InternalContextUtil.internalEnter(Constants.CONTEXT_DEFAULT_NAME);
    }

    // 全局开关 不进行规则检查
    if (!Constants.ON) {
        return new CtEntry(resourceWrapper, null, context);
    }
    // 添加一个规则检查调用链
    ProcessorSlot<Object> chain = lookProcessChain(resourceWrapper);
    // 创建一个流量入口,将context curEntry进行指定
    Entry e = new CtEntry(resourceWrapper, chain, context);
    try {
        // 开始规则检查
        chain.entry(context, resourceWrapper, null, count, prioritized, args);
    } catch (BlockException e1) {
        // 发生流控异常进行退出
        e.exit(count, args);
        // 将异常向上抛
        throw e1;
    } catch (Throwable e1) {
        // This should not happen, unless there are errors existing in Sentinel internal.
        RecordLog.info("Sentinel unexpected exception", e1);
    }
    return e;
}

可以看到准备过程主要做了五件事

将资源名称和流量类型进行包装
从当前线程得到context，如果之前没有创建context，则这里会创建一个context-name为sentinel_default_name、original为””的context
添加一个规则检查调用链，根据我们配置的规则一层一层进行检查，只要在某一个规则未通过就提前结束抛出该规则对应的异常
创建一个流量入口entry，它用来保存本次调用的信息，将context的curEntry进行指定
开始执行规则检查调用链

context创建过程

来看下context的创建过程，因为里面还涉及到一个非常重要的类Node，它的作用是统计资源的调用信息，如QPS、rt等信息

protected static Context trueEnter(String name, String origin) {
    // 从当前线程上下文中拿
    Context context = contextHolder.get();
    if (context == null) {
        Map<String, DefaultNode> localCacheNameMap = contextNameNodeMap;
        // 获取context-name对应的DefaultNode
        DefaultNode node = localCacheNameMap.get(name);
        if (node == null) {
            // 限制2000，也就是最多申明2000不同名称的上下文
            if (localCacheNameMap.size() > Constants.MAX_CONTEXT_NAME_SIZE) {
                setNullContext();
                return NULL_CONTEXT;
            } else {
                LOCK.lock();
                try {
                    // 防止并发，再次检查
                    node = contextNameNodeMap.get(name);
                    if (node == null) {
                        if (contextNameNodeMap.size() > Constants.MAX_CONTEXT_NAME_SIZE) {
                            setNullContext();
                            return NULL_CONTEXT;
                        } else {
                            // 创建EntranceNode
                            node = new EntranceNode(new StringResourceWrapper(name, EntryType.IN), null);
                            // Add entrance node.
                            Constants.ROOT.addChild(node);

                            Map<String, DefaultNode> newMap = new HashMap<>(contextNameNodeMap.size() + 1);
                            newMap.putAll(contextNameNodeMap);
                            newMap.put(name, node);
                            contextNameNodeMap = newMap;
                        }
                    }
                } finally {
                    LOCK.unlock();
                }
            }
        }
        context = new Context(node, name);
        context.setOrigin(origin);
        contextHolder.set(context);
    }

    return context;
}

Node之间的树形结构

在创建context会先创建DefaultNode 实际是它的父类EntranceNode，context可以相同context-name反复申明创建，但是DefaultNode同一context-name只会创建一次，DefaultNode包含了一个链路所有的资源，每一个资源对应一个ClusterNode，ClusterNode再根据来源细分为StatisticNode，它们之间的关系就是一个树形结构如下：

EntranceNode：根据context-name来创建，就算同一个context-name多次创建context，entranceNode也只会创建一次, 用来统计该链路上所有的资源信息

DefaultNode：根据context-name + resource-name创建，用来统计某链路上的资源信息

ClusterNode：根据resource-name来创建，用来统计资源信息

StatisticsNode：根据origin-name+resource-name来创建，针对请求来源统计该来源的资源信息，上面几个node都是它的子类，基于它的数据做汇总

读者一定要搞清楚这几个node之间的关系和作用，下面重点来看StatisticsNode，它用来完成信息统计以供后续的限流规则使用，它只统计了两个维度数据，qps和线程数

Node中滑动窗口实现

线程数统计很简单，通过LongAdder来完成，比较简单不过叙述，qps采用滑动窗口算法完成，但它跟普通的滑动窗口算法不太一样，它的数据结构是固定，可以重复利用减少了内存消耗，可以看到默认创建了两个时间维度的窗口，分别以秒（细分为2个子窗口 500ms为间隔）和分钟(细分为60个子窗口 1s为间隔)

ArrayMetric 的内部是一个 LeapArray，分钟维度使用由子类 BucketLeapArray 实现，秒维度由OccpiableBucketLeapArray实现，我们先来看BucketLeapArray ，OccpiableBucketLeapArray会在后面具体使用到时候再进行额外讲解

BucketLeapArray比较简单，内部就实现了LeapArray两个钩子方法，newEmptyBucket创建空桶, MetricBuket它窗口用来统计数据的类，里面是一个数组LongAdder 依次存放qps、rt等信息

resetWindoTo 重置窗口数据,再跟到LeapArray类中

public abstract class LeapArray<T> {

    // 每个窗口长度（占用时间)
    protected int windowLengthInMs;
    // 滑动窗口的个数
    protected int sampleCount;
    // 全部窗口的总间隔时间 （毫秒)
    protected int intervalInMs;
    // 全部窗口的总间隔时间 （秒)
    private double intervalInSecond;
    // 存储窗口的数组，length = sampleCount
    protected final AtomicReferenceArray<WindowWrap<T>> array;
    

    public WindowWrap<T> currentWindow(long timeMillis) {
        if (timeMillis < 0) {
            return null;
        }
        // 根据时间计算索引
        int idx = calculateTimeIdx(timeMillis);
        // 根据时间计算窗口开始时间
        long windowStart = calculateWindowStart(timeMillis);

        /*
         * 从array中获取窗口
         *
         * (1) array中不存在，创建一个窗口 并cas加入其中
         * (2) array中窗口开始的时间=当前当前窗口开始时间，说明当前窗口刚不久已经创建过
         * (3) array中窗口开始的时间<当前获取的时间，表示old窗口已过期，重置窗口数据并返回
         */
        while (true) {
            WindowWrap<T> old = array.get(idx);
            if (old == null) {
                WindowWrap<T> window = new WindowWrap<T>(windowLengthInMs, windowStart, newEmptyBucket(timeMillis));
                if (array.compareAndSet(idx, null, window)) {
                    return window;
                } else {
                    Thread.yield();
                }
            } else if (windowStart == old.windowStart()) {
                return old;
            } else if (windowStart > old.windowStart()) {
                if (updateLock.tryLock()) {
                    try {
                        return resetWindowTo(old, windowStart);
                    } finally {
                        updateLock.unlock();
                    }
                } else {
                    Thread.yield();
                }
            } else if (windowStart < old.windowStart()) {
                // Should not go through here, as the provided time is already behind.
                return new WindowWrap<T>(windowLengthInMs, windowStart, newEmptyBucket(timeMillis));
            }
        }
    }
    
    // 获取窗口数据
    public T getWindowValue(long timeMillis) {
        if (timeMillis < 0) {
            return null;
        }
        // 根据时间计算索引
        int idx = calculateTimeIdx(timeMillis);

        WindowWrap<T> bucket = array.get(idx);

        if (bucket == null || !bucket.isTimeInWindow(timeMillis)) {
            return null;
        }

        return bucket.value();
    }


}

LeapArray主要两个方法，currentWindow(long timeMillis)，根据当前时间获取当前窗口，getWindowValue(long timeMillis)，根据当前时间获取当前窗口的值

这里跟一般的滑动窗口算法不太一样，一般的滑动窗口算法窗口的大小不是固定可以实时扩容，但这里它的大小在初始化就决定好了，当第一分钟中的60个窗口已经全部被创建，后续时间进来获取窗口会不断进行覆盖

sentinel规则调用链

我们再回到Sphu.entry()方法中来，里面还有个sentinel规则调用链的构建，针对当前资源的调度信息进行规则校验

ProcessorSlot<Object> chain = this.lookProcessChain(resourceWrapper);