流控神器-Sentinel-工作原理

最新推荐文章于 2024-08-22 10:58:17 发布
最新推荐文章于 2024-08-22 10:58:17 发布
阅读量566 收藏 1
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kwame211/article/details/86612634
版权

Sentinel 是面向分布式服务架构的轻量级流量控制框架，主要以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度来帮助您保护服务的稳定性。
 

1. Sentinel资源&规则
我们说的资源，可以是任何东西，服务，服务里的方法，甚至是一段代码。使用 Sentinel 来进行资源保护，主要分为两个步骤:

定义资源
定义规则
先把可能需要保护的资源定义好，之后再配置规则。也可以理解为，只要有了资源，我们就可以在任何时候灵活地定义各种流量控制规则。在编码的时候，只需要考虑这个代码是否需要保护，如果需要保护，就将之定义为一个资源。

2. Demo分析
以QPS流控为分析样例

定义规则

private static void initFlowQpsRule() {
    //可以看出规则是个链表，那么意味着可以一个资源对应多个规则
    List<FlowRule> rules = new ArrayList<FlowRule>();
    FlowRule rule1 = new FlowRule();
    //规则设置资源名字
    rule1.setResource("abc");
    //设置现在qps为20
    rule1.setCount(20);
    //设置流控的规则的以QPS为准，还有以线程为准
    rule1.setGrade(RuleConstant.FLOW_GRADE_QPS);
    //根据调用方进行流量控制，默认就是全部生效
    rule1.setLimitApp("default");
    rules.add(rule1);
    //添加进流控规则管理中
    FlowRuleManager.loadRules(rules);
}
定义资源

Entry entry = null;
try {
    entry = SphU.entry(”abc“);
    //意味着通过
} catch (BlockException e1) {
    //意味着限流了
} catch (Exception e2) {
    // 业务异常
} finally {
    //确保这里一定要执行
    if (entry != null) {
        entry.exit();
    }
}


可以看到这个限制了只能20个pass，其他block

Debug分析
entry = SphU.entry(”abc“);
SphU.entry

public static Entry entry(String name) throws BlockException {
 
    return Env.sph.entry(name, EntryType.OUT, 1, OBJECTS0);
 
}
这里是sph.entry实际上是CtSph.entry方法

CtSph.entry

public Entry entry(String name, EntryType type, int count, Object... args) throws BlockException {
 
    StringResourceWrapper resource = new StringResourceWrapper(name, type);
 
    return entry(resource, count, args);
 
}
这里根据name和type创建个StringResourceWrapper，name是我们传递进去的abc，type是EntryType.OUT表示出站流量Outbound traffic

CtSph.entry

public Entry entry(ResourceWrapper resourceWrapper, int count, Object... args) throws BlockException {
 
    return entryWithPriority(resourceWrapper, count, false, args);
 
}
CtSph.entryWithPriority

private Entry entryWithPriority(ResourceWrapper resourceWrapper, int count, boolean prioritized, Object... args)
 
    throws BlockException {
 
    Context context = ContextUtil.getContext();
 
    if (context instanceof NullContext) {
 
        //进入这里代表Context超过阈值，这里只初始化entry，没有规则检验
 
        return new CtEntry(resourceWrapper, null, context);
 
    }
 
 
 
    if (context == null) {
 
        //使用默认的context
 
        context = MyContextUtil.myEnter(Constants.CONTEXT_DEFAULT_NAME, "", resourceWrapper.getType());
 
    }
 
 
 
    // 全局开关是不是关闭了，不然也不会进行规则检查
 
    if (!Constants.ON) {
 
        return new CtEntry(resourceWrapper, null, context);
 
    }
 
    //这里生成一个链表，责任链的体现
 
    ProcessorSlot<Object> chain = lookProcessChain(resourceWrapper);
 
 
 
    //在生成chain的里面有个判断，如果chainMap.size大于一个值就返回null，也不进行规则检测
 
    if (chain == null) {
 
        return new CtEntry(resourceWrapper, null, context);
 
    }
 
    //下面这里才真正开始，生成个entry
 
    Entry e = new CtEntry(resourceWrapper, chain, context);
 
    try {
 
        //开始检验规则
 
        chain.entry(context, resourceWrapper, null, count, prioritized, args);
 
    } catch (BlockException e1) {
 
        //限流了，往上抛，这里exit了，而外界finally需要判空再exit
 
        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);
 
    }
 
    //正常pass情况
 
    return e;
 
}
 
这里分为几个步骤

做一些检查，全局开关，是不是超过Context阈值，entry数量是不是超过阈值等等，符合就返回个CtEntry不做后面的规则检查
根据resourceWrapper生成个slot责任链
如果抛出BlockException，entry就是exit然后抛给上层异常，让上层感知到block了，限流了
正常通过那就返回entry，上层就知道没有被限流
 

CtSph. lookProcessChain

//这里是线程不安全的Map，而且加了volatile
 
private static volatile Map<ResourceWrapper, ProcessorSlotChain> chainMap
 
    = new HashMap<ResourceWrapper, ProcessorSlotChain>();
 
 
 
 
 
ProcessorSlot<Object> lookProcessChain(ResourceWrapper resourceWrapper) {
 
    //先从缓存中获取，看能不能获取到
 
    ProcessorSlotChain chain = chainMap.get(resourceWrapper);
 
    //这里做了double check 单例，所以HashMap没有线程不安全，加volatile是为了让其他线程立刻看到
 
    if (chain == null) {
 
        synchronized (LOCK) {
 
            chain = chainMap.get(resourceWrapper);
 
            if (chain == null) {
 
                //chainMap大小大于一个值，也就是entry数量大小限制了，一个chain对应一个entry
 
                if (chainMap.size() >= Constants.MAX_SLOT_CHAIN_SIZE) {
 
                    return null;
 
                }
 
                //新建Chain
 
                chain = SlotChainProvider.newSlotChain();
 
                //这里是逻辑是，新建一个Map大小是oldMap+1
 
                Map<ResourceWrapper, ProcessorSlotChain> newMap = new HashMap<ResourceWrapper, ProcessorSlotChain>(
 
                    chainMap.size() + 1);
 
                //然后先整体放入oldMap，再放新建的chain
 
                newMap.putAll(chainMap);
 
                newMap.put(resourceWrapper, chain);
 
                //替换
 
                chainMap = newMap;
 
                //这里的逻辑，应该是避免频繁的扩容！因为Constants.MAX_SLOT_CHAIN_SIZE默认6000，扩容一次的消耗太大
 
            }
 
        }
 
    }
 
    return chain;
 
}
SlotChainProvider.newSlotChain

public static ProcessorSlotChain newSlotChain() {
 
    if (builder != null) {
 
        return builder.build();
 
    }
 
 
 
    resolveSlotChainBuilder();
 
 
 
    if (builder == null) {
 
        RecordLog.warn("[SlotChainProvider] Wrong state when resolving slot chain builder, using default");
 
        builder = new DefaultSlotChainBuilder();
 
    }
 
    return builder.build();
 
}
这里是SPI扩展点，如果自己扩展，那么builder就是自己的，不走DefaultSlotChainBuilder，先不关注SPI，关注默认的DefaultSlotChainBuilder

DefaultSlotChainBuilder.build

public ProcessorSlotChain build() {
 
    ProcessorSlotChain chain = new DefaultProcessorSlotChain();
 
    chain.addLast(new NodeSelectorSlot());
 
    chain.addLast(new ClusterBuilderSlot());
 
    chain.addLast(new LogSlot());
 
    chain.addLast(new StatisticSlot());
 
    chain.addLast(new SystemSlot());
 
    chain.addLast(new AuthoritySlot());
 
    chain.addLast(new FlowSlot());
 
    chain.addLast(new DegradeSlot());
 
 
 
    return chain;
 
}
很明显Chain是一个责任链模式，本质上是个链表，添加很多的slot

然后我们得进入DefaultProcessorSlotChain看看

3. DefaultProcessorSlotChain
3.1. 初始化


在这里层次图中，以Slot结尾的是Chain中的元素，也就是一个一个的handler，这里叫slot而已，

这里的模式很有意思

在DefaultProcessorSlotChain中有两个元素first和end两个引用，类型是AbstractLinkedProcessorSlot，实际上指向是那些AbstractLinkedProcessorSlot的子类，FlowSlot之类

AbstractLinkedProcessorSlot<?> first = new AbstractLinkedProcessorSlot<Object>() {
 
 
 
    @Override
 
    public void entry(Context context, ResourceWrapper resourceWrapper, Object t, int count, boolean prioritized, Object... args)
 
        throws Throwable {
 
        super.fireEntry(context, resourceWrapper, t, count, prioritized, args);
 
    }
 
 
 
    @Override
 
    public void exit(Context context, ResourceWrapper resourceWrapper, int count, Object... args) {
 
        super.fireExit(context, resourceWrapper, count, args);
 
    }
 
 
 
};
 
AbstractLinkedProcessorSlot<?> end = first;


刚刚开始的情况，frist和end都指向一个匿名内部类

 添加Slot


最后分析的结果和debug的结果相同

SlotChain的entry方法
下面开始看一个entry走过的流程

CtSph.entryWithPriority

chain.entry(context, resourceWrapper, null, count, prioritized, args);
这里进入的是DefaultProcessorSlotChain的entry方法

public void entry(Context context, ResourceWrapper resourceWrapper, Object t, int count, boolean prioritized, Object... args)
 
    throws Throwable {
 
    first.transformEntry(context, resourceWrapper, t, count, prioritized, args);
 
}
transformEntry方法在AbstractLinkedProcessorSlot中被定义

void transformEntry(Context context, ResourceWrapper resourceWrapper, Object o, int count, boolean prioritized, Object... args)
 
    throws Throwable {
 
    T t = (T)o;
 
    entry(context, resourceWrapper, t, count, prioritized, args);
 
}
 
这里entry方法是AbstractLinkedProcessorSlot$1这个匿名内部类重写的那个方法

@Override
 
public void entry(Context context, ResourceWrapper resourceWrapper, Object t, int count, boolean prioritized, Object... args)
 
    throws Throwable {
 
    super.fireEntry(context, resourceWrapper, t, count, prioritized, args);
 
}
然后又是调用父类方法super.fireEntry

@Override
 
public void fireEntry(Context context, ResourceWrapper resourceWrapper, Object obj, int count, boolean prioritized, Object... args)
 
    throws Throwable {
 
    if (next != null) {
 
        next.transformEntry(context, resourceWrapper, obj, count, prioritized, args);
 
    }
 
}
这里就开始调用下一个slot执行逻辑了

这里需要关注一点

entry方法          各个Slot自己实现

fireEntry方法     AbstractLinkedProcessorSlot定义好了   如果next不为空触发transformEntry方法

transformEntry方法    AbstractLinkedProcessorSlot定义好了  触发自定义的entry方法

到此，Sentinel的工作流程架构就梳理完成

具体的功能是Slot的部分

可以看下Sentinel自带提供了那些Slot

NodeSelectorSlot 负责收集资源的路径，并将这些资源的调用路径，以树状结构存储起来，用于根据调用路径来限流降级；
ClusterBuilderSlot 则用于存储资源的统计信息以及调用者信息，例如该资源的 RT, QPS, thread count 等等，这些信息将用作为多维度限流，降级的依据；
StatisticSlot 则用于记录、统计不同纬度的 runtime 指标监控信息；
FlowSlot 则用于根据预设的限流规则以及前面 slot 统计的状态，来进行流量控制；
AuthoritySlot 则根据配置的黑白名单和调用来源信息，来做黑白名单控制；
DegradeSlot 则通过统计信息以及预设的规则，来做熔断降级；
SystemSlot 则通过系统的状态，例如 load1 等，来控制总的入口流量；
 

DemonHunter211
关注
专栏目录
Sentinel 流控原理
wanger5354的博客
01-16 407
我们在项目中添加 Spring Cloud Sentinel 依赖添加后 spring-cloud-starter-alibaba-sentinel  在 Spring-Boot 启动的过程中回去初始化 spring.factories 中的配置信息，如：SentinelWebAutoConfiguration  、SentinelAutoConfiguration 等配置文件来初始化再讲代码之前我先声明一下我的版本号sentinel 1.8.0 。后续的所有内容均基于该版本进行@Res
Sentinel 核心概念和工作流程详解
weixin_42118323的博客
07-30 817
上一篇文章中，我们对 Sentinel 有了基本认知，知道其是 Alibaba 开源的一个服务稳定性组件，我们从 Sentinel 控制台认识了 Sentinel 的流控、降级、热点、授权规则，本篇我们将从核心概念和工作流程方面继续分析 Sentinel。通过 SentinelResourceAspect 类的源码可以知道 @SentinelResource 注解是一个标记，而 Sentinel 基于 AOP 思想，对被标记的方法做环绕增强，完成资源 Entry 的创建，实现了对资源的保护。
Sentinel系列之工作原理(概念篇)
qq_38377525的博客
02-26 959
Sentinel系列之工作原理(概念篇)
sentinel工作原理及使用
bao2901203013的专栏
11-01 2228
sentinel是一个功能全面的、面向分布式服务架构的轻量级高可用流量控制组件，主要以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度来帮助用户保护服务的稳定性。下面说一下它的工作原理及使用方法 sentinel工作原理 当sentinel作用在调用的接口上时，会将这个接口抽象成一种资源，调用方需要申请这种资源，使用的方法是SphU.entry()，如果能够申请成功，则说明没有被限流，否则会抛出BlockException，表面已经被限流了。 从SphU.entry()方法...
sentinel基础原理
zhaokuner的专栏
12-02 1225
来自杨三超wiki 1、Sentinel是什么 Sentinel 是面向分布式服务架构的轻量级流量控制框架，主要以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度来帮助您保护服务的稳定性。 github：https://github.com/alibaba/Sentinel star：7000+ 2、特点 丰富的应用场景：Sentinel 承接了阿里巴巴近 10 年的双十一大...
流量治理神器-Sentinel 究竟是怎么做到让业务方接入简单？
02-12 243
大家好，我是架构摆渡人，这是流量治理系列的第10篇原创文章，如果有收获，还请分享给更多的朋友。 做业务开发，需要考虑业务的扩展性。做基础框架开发，需要考虑如何让业务方接入，使用简单，尽量不要耦合在业务代码中。 Sentinel里面是如何做到让业务方接入简单，使用方便的呢？这篇文章就来剖析下Sentinel的那些适配是如何实现的。 基本使用 基本使用可以直接用SphU类对资源进行保护，使用方式如下： public static void main(String[] args) { // 配置规则.
限流降级神器-哨兵(sentinel)原理分析
码农研习社
04-06 489
Sentinel 是阿里中间件团队开源的，面向分布式服务架构的轻量级高可用流量控制组件，主要以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度来帮助用户保护服务的稳定性。 大家可能会问：Sentinel 和之前常用的熔断降级库 Netflix Hystrix 有什么异同呢？Sentinel官网有一个对比的文章，这里摘抄一个总结的表格，具体的对比可以点此 链接 查看。 对比内容 Sentinel Hystrix 隔离策略
限流神器Sentinel，不了解一下吗？
JokerKon的博客
07-06 514
随着 Alibaba 的 Java 生态建设，包括 Spring Cloud Alibaba，Rocket，Nacos等多项开源技术的贡献，目前Sentinel 对分布式的各种应用场景都有了良好的支持和适配。
Sentinel Dashboard 中修改规则同步到 Nacos
程序猿DD
05-22 2692
点击蓝色“程序猿DD”关注我哟加个“星标”，不忘签到哦上一篇我们介绍了如何通过改造Sentinel Dashboard来实现修改规则之后自动同步到Apollo。下面通过这...
Sentinel原理
summer_fish的专栏
01-23 1357
Sentinel基于并发线程数流控 采用基于线程数的限流模式后，我们不需要再显式地去进行线程池隔离，Sentinel 会控制访问该资源的线程数，超出的请求直接拒绝，直到堆积的线程处理完成。相当于是以资源为维度, 隔离出了每一种资源对应的不同线程数。 例如，当应用所依赖的下游应用由于某种原因导致服务不稳定、响应延迟增加，对于调用者来说，意味着吞吐量下降和更多的线程数占用，极端情况下甚至导致线程池耗尽。为应对太多线程占用的情况，业内有使用隔离的方案，比如通过不同业务逻辑使用不同线程池来隔离业务自身之间的资源争
sentinel思维导图
11-28
阿里开源项目 sentinel,从流量控制、熔断降级、系统负载保护等多个维度来帮助您保护服务的稳定性。,个人经典总结！！！
sentinel运行原理详解
龚厂长的博客
03-20 7026
本文基于sentinel-1.8.0版本 DegradeSlot：服务降级 AuthoritySlot：黑白名单校验，按照字符串匹配，比较简单 ClusterBuilderSlot：构建ClusterNode对象，该对象为后面统计QPS、线程数、异常、响应时间等使用。 SystemSlot：校验QPS、线程数、系统负载、CPU，按照窗口统计 StatisticSlot：统计处理过的请求数和线程数 FlowSlot：按照自定义的流控规则检查，这个与StatisticSlot相关 NodeSelectorS.
SpringCloud Alibaba系列——Sentinel原理分析
blueheartstone的博客
08-11 1196
java
Sentinel 原理-全解析
热门推荐
lichao920926的博客
04-03 1万+
系列文章 Sentinel 原理-调用链Sentinel 原理-滑动窗口Sentinel 原理-实体类Sentinel 实战-限流篇Sentinel 实战-控制台篇Sentinel 实战-规则持久化Sentinel 实战-集群限流篇 Sentinel 系列教程，现已上传到 github 和 gitee 中： GitHub：https://github.com/all4you/sentinel...
Sentinel底层原理解析（超详细）
qq_22270363的博客
08-27 1673
Sentinel底层原理解析（超详细）
SpringCloud Alibaba系列——15Sentinel原理分析
Eclipse_2019的博客
08-10 354
Sentinel的工作原理。
Sentinel组件详解：使用与原理
最新发布
m0_48038376的博客
08-22 1728
Sentinel提供了完善的SPI（Service Provider Interface）扩展接口，允许用户通过实现扩展接口来快速定制逻辑，如规则管理、适配动态数据源等。如果你的项目需要较高的自定义能力或计划在未来进行大量的扩展和定制，那么Sentinel的扩展性可能更适合你的需求。问题描述：在需要自定义流量控制或熔断降级规则时，发现实现复杂度较高，难以维护。解决方案利用Sentinel提供的扩展点（如自定义Slot）来实现复杂的规则逻辑。将复杂的规则逻辑封装成可复用的组件或库。
redis-sentinel启动命令
06-27
或者指定不同的配置文件路径，如 `redis-server --sentinel /path/to/sentinel-custom.conf` 4. **验证 Sentinel 是否正常工作**: 可以使用 `redis-cli -s <sentinel_ip>:<sentinel_port> sentinels` 来连接到 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值