sentinel源码分析第十篇一核心流程一ProcessorSlotChain.entry及ProcessorSlot链执行

已于 2022-02-17 00:12:50 修改
阅读量479 收藏 1
点赞数
分类专栏： sentinel源码分析 文章标签： sentinel
于 2022-02-16 22:50:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35529969/article/details/122966468
版权

文章目录

原理图

官网的Slot链顺序存在问题,此处slot执行顺序同实际顺序

在这里插入图片描述

源码分析一入口CtSph.entryWithPriority

  • 通过DefaultProcessorSlotChain调用责任链
  • 所有的责任链工作完毕,发生限流则抛出异常
  • 未限流返回Entry栈链表
注意: 同一个资源在不同ContextName的上下文中,DefaultNode不同;
注意: 每一个资源只有一个ClusterNode 但可以有多个DefaultNode

try {
    每个ProcessorSlot 的entry()方法负责真正的业务处理部分
    NodeSelectorSlot 负责收集资源的路径，并将这些资源的调用路径，以树状结构存储起来，用于根据调用路径来限流降级
    ClusterBuilderSlot 则用于存储资源的统计信息以及调用者信息，例如该资源的 RT, QPS, thread count 等等，这些信息将用作为多维度限流，降级的依据；
    StatistcSlot 则用于记录，统计不同纬度的 runtime 信息；
    FlowSlot 则用于根据预设的限流规则，以及前面 slot 统计的状态，来进行限流；
    AuthorizationSlot 则根据黑白名单，来做黑白名单控制；
    DegradeSlot 则通过统计信息，以及预设的规则，来做熔断降级；
    SystemSlot 则通过系统的状态，例如 load1 等，来控制总的入口流量；
     
    chain.entry(context, resourceWrapper, null, count, prioritized, args);
} catch (BlockException e1) {
    限流了，往上抛，这里exit了，而外界finally需要判空再exit
    e.exit(count, args);
    throw e1;
} catch (Throwable e1) {
    防御性编程  用来处理异常
    RecordLog.info("Sentinel unexpected exception", e1);
}

源码分析一NodeSelectorSlot

  • 负责构建限流链路
  • DefaultNode根据context.getName构建,也就是同一个资源可以对应多个DefaultNode
  • 构建下图关系
    -在这里插入图片描述
public class NodeSelectorSlot extends AbstractLinkedProcessorSlot<Object> {
    private volatile Map<String, DefaultNode> map = new HashMap<String, DefaultNode>(10);
    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, Object obj, int count, boolean prioritized, Object... args)
        throws Throwable {
        根据「上下文」的名称获取DefaultNode
        多线程环境下，每个线程都会创建一个context，但是一个contextName可能用于多个线程上下文
        DefaultNode node = map.get(context.getName());
        if (node == null) {
            synchronized (this) {
                node = map.get(context.getName());
                if (node == null) {
                    如果当前「上下文」中没有该节点，则创建一个DefaultNode节点
                    node = new DefaultNode(resourceWrapper, null);
                    HashMap<String, DefaultNode> cacheMap = new HashMap<String, DefaultNode>(map.size());
                    cacheMap.putAll(map);
                    cacheMap.put(context.getName(), node);
                    map = cacheMap;
                    将当前node作为「上下文」的最后一个节点的子节点添加进去
                    如果context的curEntry.parent.curNode为null，则添加到entranceNode中去
                    否则添加到context的curEntry.parent.curNode中去
                    ((DefaultNode) context.getLastNode()).addChild(node);
                }

            }
        }
        context.setCurNode(node);
        fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }
}

源码分析一ClusterBuilderSlot

  • 构建存储限流统计数据的clusterNode
  • 将clusterNode设置到限流链路当前的DefaultNode
  • 针对origin构建额外的StatisticNode
@SpiOrder(-9000)
public class ClusterBuilderSlot extends AbstractLinkedProcessorSlot<DefaultNode> {

    private static volatile Map<ResourceWrapper, ClusterNode> clusterNodeMap = new HashMap<>();
    private static final Object lock = new Object();
    private volatile ClusterNode clusterNode = null;

    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
                      boolean prioritized, Object... args)
        throws Throwable {
        if (clusterNode == null) {
            synchronized (lock) {
                if (clusterNode == null) {
                    根据资源名构建clusterNode 也就是说一个资源一定对应且只能对应一个ClusterNode
                    clusterNode = new ClusterNode(resourceWrapper.getName(), resourceWrapper.getResourceType());
                    HashMap<ResourceWrapper, ClusterNode> newMap = new HashMap<>(Math.max(clusterNodeMap.size(), 16));
                    newMap.putAll(clusterNodeMap);
                    newMap.put(node.getId(), clusterNode);
                    clusterNodeMap = newMap;
                }
            }
        }
        node.setClusterNode(clusterNode);

        如果context设置了Origin,则为origin创建单独的统计节点StatisticNode
        Origin一般用于区分环境,或者应用名,ip等,具体维度不定,比如区分不同的应用,则构建applicationname1,applicationname2作为Origin
        if (!"".equals(context.getOrigin())) {
            Node originNode = node.getClusterNode().getOrCreateOriginNode(context.getOrigin());
            context.getCurEntry().setOriginNode(originNode);
        }

        fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }
 
}

源码分析一StatisticSlot

  • 先调用下游限流节点
  • 如果未被限流则执行数据统计计算工作
功能概述
负责资源限流数据的构建
线程: entry时增加线程数,exit 减少线程数,【不同于hystrix,其并没有通过线程池进行隔离,而是通过数值统计当前被使用的线程数,上下文切换更少】
qps: 只负责增加,通过样本窗口大小进行限流处理,exit无需减少

@SpiOrder(-7000)
实时统计的处理槽 
资源ID对应clusternode的统计
OriginNode对应的statisticsNode统计
EntryType.IN入站类型的额外统计
所有entranceNode的统计
public class StatisticSlot extends AbstractLinkedProcessorSlot<DefaultNode> {

    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
                      boolean prioritized, Object... args) throws Throwable {
        try {
            【限流 降级 系统  授权等】规则检测 通过后正式统计
            检测完毕进行统计
            fireEntry(context, resourceWrapper, node, count, prioritized, args);

            通过DefaultNode为clusterNode增加线程数
            node.increaseThreadNum();
            增加qps count一般是1
            node.addPassRequest(count);

            if (context.getCurEntry().getOriginNode() != null) {
                设置origin则处理StatisticNode
                context.getCurEntry().getOriginNode().increaseThreadNum();
                context.getCurEntry().getOriginNode().addPassRequest(count);
            }

            if (resourceWrapper.getEntryType() == EntryType.IN) {
                全局统计添加节点添加线程数 qps
                Constants.ENTRY_NODE.increaseThreadNum();
                Constants.ENTRY_NODE.addPassRequest(count);
            }

            通过限流后则执行回调
            for (ProcessorSlotEntryCallback<DefaultNode> handler : StatisticSlotCallbackRegistry.getEntryCallbacks()) {
                handler.onPass(context, resourceWrapper, node, count, args);
            }
        } catch (PriorityWaitException ex) {
            node.increaseThreadNum();
            ...... 删除其他代码
            处理回调事件
            for (ProcessorSlotEntryCallback<DefaultNode> handler : StatisticSlotCallbackRegistry.getEntryCallbacks()) {
                handler.onPass(context, resourceWrapper, node, count, args);
            }
        } catch (BlockException e) {
            发生限流设置错误
            context.getCurEntry().setBlockError(e);
            被限流依旧添加qps
            node.increaseBlockQps(count);
            if (context.getCurEntry().getOriginNode() != null) {
                context.getCurEntry().getOriginNode().increaseBlockQps(count);
            }

            if (resourceWrapper.getEntryType() == EntryType.IN) {
                处理统计数据BlockQps
                Constants.ENTRY_NODE.increaseBlockQps(count);
            }

            处理回调
            for (ProcessorSlotEntryCallback<DefaultNode> handler : StatisticSlotCallbackRegistry.getEntryCallbacks()) {
                handler.onBlocked(e, context, resourceWrapper, node, count, args);
            }
            throw e;
        } catch (Throwable e) {
            context.getCurEntry().setError(e);
            throw e;
        }
    }

    @Override
    public void exit(Context context, ResourceWrapper resourceWrapper, int count, Object... args) {
        Node node = context.getCurNode();
        if (context.getCurEntry().getBlockError() == null) {
            step-1 计算rt响应时长
            long completeStatTime = TimeUtil.currentTimeMillis();
            context.getCurEntry().setCompleteTimestamp(completeStatTime);
            long rt = completeStatTime - context.getCurEntry().getCreateTimestamp();
            Throwable error = context.getCurEntry().getError();

            step-2 减少线程数 处理一些数据统计工作
            recordCompleteFor(node, count, rt, error);
            recordCompleteFor(context.getCurEntry().getOriginNode(), count, rt, error);
            if (resourceWrapper.getEntryType() == EntryType.IN) {
                recordCompleteFor(Constants.ENTRY_NODE, count, rt, error);
            }
        }

        step-3 处理回调
        Collection<ProcessorSlotExitCallback> exitCallbacks = StatisticSlotCallbackRegistry.getExitCallbacks();
        for (ProcessorSlotExitCallback handler : exitCallbacks) {
            handler.onExit(context, resourceWrapper, count, args);
        }

        fireExit(context, resourceWrapper, count);
    }

    private void recordCompleteFor(Node node, int batchCount, long rt, Throwable error) {
        if (node == null) {
            return;
        }
        node.addRtAndSuccess(rt, batchCount);
        减少线程数
        node.decreaseThreadNum();

        if (error != null && !(error instanceof BlockException)) {
            node.increaseExceptionQps(batchCount);
        }
    }
}

源码分析一SystemSlot

-通过SystemRuleManager检查系统限流

@SpiOrder(-5000)
public class SystemSlot extends AbstractLinkedProcessorSlot<DefaultNode> {
    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
                      boolean prioritized, Object... args) throws Throwable {
        检查系统规则是否触发限流 触发抛出异常
        SystemRuleManager.checkSystem(resourceWrapper);
        触发参数流控槽ParamFlowSlot执行
        fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }
}

系统规则

检查维度
qps限流
线程数限流
基于平均rt 限流
系统负载过高并且线程数超过1,并且线程数超过平均qps
cpu使用率过高
public static void checkSystem(ResourceWrapper resourceWrapper) throws BlockException {
    if (resourceWrapper == null) {
        return;
    }
   
    if (!checkSystemStatus.get()) {
        return;
    }

     
    if (resourceWrapper.getEntryType() != EntryType.IN) {
        return;
    }

    qps限流
    double currentQps = Constants.ENTRY_NODE == null ? 0.0 : Constants.ENTRY_NODE.successQps();
    if (currentQps > qps) {
        throw new SystemBlockException(resourceWrapper.getName(), "qps");
    }

    线程数限流
    int currentThread = Constants.ENTRY_NODE == null ? 0 : Constants.ENTRY_NODE.curThreadNum();
    if (currentThread > maxThread) {
        throw new SystemBlockException(resourceWrapper.getName(), "thread");
    }
    基于平均rt 限流
    double rt = Constants.ENTRY_NODE == null ? 0 : Constants.ENTRY_NODE.avgRt();
    if (rt > maxRt) {
        throw new SystemBlockException(resourceWrapper.getName(), "rt");
    }

    BBR 算法.
    系统负载过高
    if (highestSystemLoadIsSet && getCurrentSystemAvgLoad() > highestSystemLoad) {
        线程数超过1,并且线程数超过平均qps
        if (!checkBbr(currentThread)) {
            throw new SystemBlockException(resourceWrapper.getName(), "load");
        }
    }

    cpu使用率过高
    if (highestCpuUsageIsSet && getCurrentCpuUsage() > highestCpuUsage) {
        throw new SystemBlockException(resourceWrapper.getName(), "cpu");
    }
}

源码分析一ParamFlowSlot

public class ParamFlowSlot extends AbstractLinkedProcessorSlot<DefaultNode> {

    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
                      boolean prioritized, Object... args) throws Throwable {
                      热点参数规则管理器中不存在参数规则 不进行限流检查
        if (!ParamFlowRuleManager.hasRules(resourceWrapper.getName())) {
            fireEntry(context, resourceWrapper, node, count, prioritized, args);
            return;
        }
        检查限流
        checkFlow(resourceWrapper, count, args);
        fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }
}

参数限流检查checkFlow

  • 根据资源名获取资源对应的限流规则
  • 初始化参数Metric限流统计数据容器
  • 如果检测不通过则抛出限流异常
  • 具体的检测算法参见下一篇文章
void checkFlow(ResourceWrapper resourceWrapper, int count, Object... args) throws BlockException {
    if (args == null) {
        return;
    }
    if (!ParamFlowRuleManager.hasRules(resourceWrapper.getName())) {
        return;
    }
    // 根据资源名获取资源对应的限流规则
    List<ParamFlowRule> rules = ParamFlowRuleManager.getRulesOfResource(resourceWrapper.getName());

    for (ParamFlowRule rule : rules) {
        applyRealParamIdx(rule, args.length);

        // 初始化参数Metric限流统计数据容器
        ParameterMetricStorage.initParamMetricsFor(resourceWrapper, rule);
        如果检测不通过则抛出限流异常
        if (!ParamFlowChecker.passCheck(resourceWrapper, rule, count, args)) {
            String triggeredParam = "";
            if (args.length > rule.getParamIdx()) {
                Object value = args[rule.getParamIdx()];
                triggeredParam = String.valueOf(value);
            }
            throw new ParamFlowException(resourceWrapper.getName(), triggeredParam, rule);
        }
    }
}

源码分析一FlowSlot

  • 获取资源对应的规则
  • 通过规则检测器检测是否发生限流
  • 具体限流算法参见下一篇
@SpiOrder(-2000)
public class FlowSlot extends AbstractLinkedProcessorSlot<DefaultNode> {

    private final FlowRuleChecker checker;

    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
                      boolean prioritized, Object... args) throws Throwable {
         检查是否发生流控
        checkFlow(resourceWrapper, context, node, count, prioritized);
         流控之后触发降级
        fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }

    void checkFlow(ResourceWrapper resource, Context context, DefaultNode node, int count, boolean prioritized)
        throws BlockException {
        规则检测器检查是否发生限流
        checker.checkFlow(ruleProvider, resource, context, node, count, prioritized);
    }

   
}

源码分析一DegradeSlot

  • 获取所有的熔断器规则
  • 检测是否发生熔断
  • 发生熔断则报错
  • 具体算法参见下一篇
@SpiOrder(-1000)
public class DegradeSlot extends AbstractLinkedProcessorSlot<DefaultNode> {
    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
                      boolean prioritized, Object... args) throws Throwable {
        熔断检查
        performChecking(context, resourceWrapper);
        结尾节点无下一个节点,结束责任链工作
        fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }

    void performChecking(Context context, ResourceWrapper r) throws BlockException {
        获取熔断器规则
        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());
            }
        }
    }
}

总结

  • 概述了所有处理器槽的工作
  • 其中日志槽和授权槽相对简答,没有分析源码,一个负责日志,一个负责黑白名单拦截
  • 参数流控和资源流控以及熔断具体算法实现参见下一篇,包含了集群模式和单机模式的处理
  • 整个责任链先处理簇点链路以及统计数据节点的构成,随后触发限流规则检查,最后在StatisticSlot处完成数据统计
岁月人
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
源码解读一 ：ProcessorSlot责任链
kuangzhanshatian的专栏
02-01 128
源码解读一 ：ProcessorSlot责任链 文章目录源码解读一 ：ProcessorSlot责任链概述代码实现初始化 ProcessorSlotChain获取 SlotChainBuilderDefaultSlotChainBuilder 构建 ProcessorSlotChain 实例DefaultProcessorSlotChain 内部逻辑使用 ProcessorSlotChain总结 概述 在总体设计章节中，我们知道 Sentinel 是通过不同的 ProcessorSlot 实现不同的功能，并
6. ProcessorSlotChain-sentinel中的责任链模式
八荒六合唯我独尊
09-17 452
Sentinel 的整体工具流程就是使用责任链模式将所有的 ProcessorSlot 按照一定的顺序串成一个单向链表。实现将 ProcessorSlot 串成一个单向链表的是 ProcessorSlotChain，这个 ProcessorSlotChain 是由 SlotChainBuilder 构造的。 SlotChainProvider public final class SlotChainProvider { private static volatile SlotChainBui
Sentinel源码解析-ProcessorSlot具体
ZXMSH的博客
02-12 589
判断上一次请求重试的时间距离当前时间有没有过重试间隔这里首先把熔断器状态成OPEN变更HALF_OPEN如果请求发生异常，则会把状态再从HALF_OPEN变成OPEN状态注：这里我们只看到了断路器状态从HALF_OPEN变成OPEN，和从OPEN变成HALF_OPEN,那么从CLOSE状态变成OPEN状态和从HALF_OEPN状态变成CLOSE状态我们还没看到，我们后续看下方法。
spring cloud alibaba 学习（十六）Sentinel功能插槽ProcessorSlot
码易的博客
02-18 551
目录前言一、ProcessorSlotChain 初始化二、ProcessorSlotChain 使用三、ProcessorSlot 实现类1、NodeSelectorSlot2、ClusterBuilderSlot3、LogSlot4、AuthoritySlot5、SystemSlot 前言 sentinel 可以对资源也就是接口配置一些规则，各种规则检查的功能都继承ProcessorSlot，sentinel 会将不同的 ProcessorSlot 组装为一个责任链，当请求来的时候，会对资源的规..
16. 自定义 ProcessorSlot 实现开关降级
八荒六合唯我独尊
09-19 371
开关降级在我们公司的电商项目中是每个微服务都必须支持的一项功能，主要用于活动期间、每日流量高峰期间、主播带货期间关闭一些无关紧要功能，降低数据库的压力。 开关降级实现起来很简单，例如，我们可以使用 Spring AOP 或者动态代理模式拦截目标方法的执行，在方法执行之前，先根据 key 从 Redis 读取 value，如果 value 是 true，则不执行目标方法，直接响应服务降级。这种方式付出的性能损耗就只有一次 redis 的 get 操作，如果不想每个请求都读 Redis 缓存，也可以通过动态配
《一起学sentinel》二、初探sentinel的Slot
M4Y
09-22 879
《一起学sentinel》二、初探sentinel的Slot slot概述 在 Sentinel 里面，所有的资源都对应一个资源名称（resourceName），每次资源调用都会创建一个 Entry 对象。Entry 可以通过对主流框架的适配自动创建，也可以通过注解的方式或调用 SphU API 显式创建。Entry 创建的时候，同时也会创建一系列功能插槽（slot chain），这些插槽有不同的职责，例如: NodeSelectorSlot 负责收集资源的路径，并将这些资源的调用路径，以树状结构存储起来
sentinel学习(3）——源码阅读----NodeSelectorSlot.entry()(完)
weixin_41150739的博客
02-14 203
1:这个slot的作用是什么？ public void entry(Context context, ResourceWrapper resourceWrapper, Object obj, int count, boolean prioritized, Object... args) throws Throwable { DefaultNode node = map.get(context.getName()); if (node == n
Sentinel流量控制和熔断降级执行流程与源码分析.docx
11-12
Sentinel 流量控制和熔断降级执行流程与源码分析 Sentinel 是阿里巴巴开源的流量控制和熔断降级框架，旨在帮助开发者更好地控制和管理服务流量。Sentinel 通过对流量的控制和熔断降级来保护服务免受过载和崩溃的...
Sentinel核心源码解析+视频+源码+资料.txt
08-11
Sentinel核心源码解析+视频+源码+资料.txt
Sentinel 规则持久化源码分析.jpg
05-12
Sentinel 规则持久化源码分析
最新Sentinel-1.7.2版本jar包与源码，sentinel-dashboard-1.7.2.jar
12-27
包含下列4个文件 sentinel-dashboard-1.7.2.jar sentinel-envoy-rls-token-server-1.7.2.jar Sentinel-1.7.2.tar.gz Sentinel-1.7.2.zip
Sentinel核心源码解析[视频课程].txt打包整理.zip
03-06
Sentinel核心源码解析[视频课程].txt打包整理.zip
Sentinel工作主流程——插槽Slot
qq_24281575的博客
06-24 387
在 Sentinel 里面，所有的资源都对应一个资源名称(resourceName)，每次资源调用都会创建一个 Entry 对象。Entry 可以通过对主流框架的适配自动创建，也可以通过注解的方式或调用 SphU API 显式创建。Entry 创建的时候，同时也会创建一系列功能插槽(slot chain)，这些插槽有不同的职责，例如: NodeSelectorSlot 负责收集资源的路径，并将...
Sentinel源码剖析之核心组件作用和介绍
白鸽
11-02 480
Sentinel 是分布式系统的防御系统。以流量为切入点，通过动态设置的流量控制、服务熔断降级、系统负载保护等多个维度保护服务的稳定性，通过服务降级增强服务被拒后用户的体验。官网：https://github.com/alibaba/Sentinel/wiki/
Spring - Sentinel 原理 全解析
迦南的专栏
02-02 2275
系列文章 Sentinel 原理-调用链Sentinel 原理-滑动窗口Sentinel 原理-实体类Sentinel 实战-限流篇Sentinel 实战-控制台篇Sentinel 实战-规则持久化Sentinel 实战-集群限流篇 Sentinel 系列教程，现已上传到 github 和 gitee 中： GitHub：https://github.com/all4you/sentinel-tutorial Gitee：https://gitee.com/all_4_you/sentinel-tu
ProcessSlot构建流程分析
weixin_51918722的博客
02-03 912
首先初始化Builder，负责管控责任链整体，Sentinel要求Builder只能存在一个，而且是外部系统优先原则，因此，我们可以自己编写一个以接口为名称的SPI文件来替代默认的 DefaultSlotChainBuilder。然后通过Builder初始化完整的责任链，这里仍然是通过SPI机制进行初始化，因此也可以额外扩展，比如外部系统自定义一个Slot且插入到完整责任链当中，这里值得注意的是责任链是有顺序的，如果顺序没指定正确，则可能造成意想不到的效果。顺序可以通过@Spi注解的order属性。
sentinel架构底层原理剖析详解
zhenghuishengq的博客
08-28 1458
sentinel底层原理详解
Spring Cloud Alibaba（三）Sentinel限流实现原理
傅红雪的专栏
03-15 929
之前我们学习过限流比较主流的三种算法：漏桶，令牌桶，滑动窗口。而Sentinel采用的是最后一种，滑动窗口来实现限流的。 通过对Sentinel基础Api的使用，我们可用发现，从我们定义好限流规则以后，在我们需要进行业务处理之前，都需要调用一下 SphU.entry(resource)，具体代码如下： public static void main(String[] args) { initFlowRules(); //初始化一个规则 while(true){
哨兵机制（Redis Sentinel）常见面试题
最新发布
m0_60469045的博客
06-11 1052
哨兵机制（Redis Sentinel）是redis主从集群中实现主从库自动切换的关键机制。它通过监控、选主和通知三个任务来实现主从库的自动切换。在监控任务中，哨兵周期性地检测主从库的在线状态，判断主库是否处于下线状态。哨兵采用多实例组成的集群模式进行部署，以避免单个哨兵误判主库下线的情况。
SphU.entry
09-18
SphU.entry()是Sentinel的入口方法之一，用于标记资源的进入。在Sentinel中，资源可以是方法名或接口。具体而言，SphU.entry()会将资源封装为一个StringResourceWrapper对象，并调用Env.sph.entry()方法进行进一步...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值