Sentinel学习圣经：从入门到精通Sentinel，最全详解(40+图文全面总结)

丰富的线上&线下活动，深入探索云世界

做任务，得社区积分和周边

最真实的开发者用云体验

让每位学生受益于普惠算力

让创作激发创新

资深技术专家手把手带教

遇见技术追梦人

技术交流，直击现场

海量开发者使用工具、手册，免费下载

极速、全面、稳定、安全的开源镜像

开发手册、白皮书、案例集等实战精华

为开发者定制的Chrome浏览器插件

在40岁老架构师尼恩的读者交流群(50+)中，最近有小伙伴拿到了一线互联网企业如得物、阿里、滴滴、极兔、有赞、希音、百度、网易、美团的面试资格，并且拿了很多大厂offer。

比如小伙伴在面试蚂蚁的时候，就遇到以下面试题：

Sentinel熔断降级，是如何实现的？

小伙伴由于之前没有系统的去梳理和总结，所以支支吾吾的说了几句，面试官不满意，面试挂了。

所以，尼恩给大家做一下系统化、体系化的梳理，联合社群小伙伴，来一个Sentinel学习圣经：从入门到精通Sentinel。

特别说明，本文属于穿透SpringCloud工业级底座工程(一共包括15大学习圣经)的其中之一，并且，此系列15大学习圣经底座正在录制视频，帮助大家一举成为技术高手。

15大圣经，使得大家内力猛增，可以充分展示一下大家雄厚的“技术肌肉”，让面试官爱到“不能自已、口水直流”，然后实现”offer直提”。

其中，专题3为：注册发现治理架构：Nacos学习圣经，具体如下：

其中，专题5为RPC治理架构Dubb3.0，具体如下：

本文，就是Sentinel学习圣经。稍后会录制视频。录完之后，Sentinel学习圣经正式版本会有更新，最新版本找尼恩获取。

在40岁老架构师尼恩的读者交流群(50+)中，最近有小伙伴拿到了一线互联网企业如阿里、滴滴、极兔、有赞、希音、百度、网易、美团的面试资格，遇到很多很重要的面试题：

问题1：Sentinel高可用熔断降级，是如何实现的？

在这里，借助《Sentinel学习圣经》尼恩给大家做一下系统化、体系化的Sentinel梳理，使得大家内力猛增，展示一下雄厚的“技术肌肉、技术实力”，让面试官爱到“不能自已、口水直流”，然后实现”offer直提，offer自由”。

首先给面试官来一个总体的介绍：

在微服务架构中，Sentinel作为一种流量控制、熔断降级和服务降级的解决方案，得到了广泛的应用。

Sentinel是一个开源的流量控制和熔断降级库，用于保护分布式系统免受大量请求的影响。

然后，尼恩建议大家，从以下的几个维度去全面介绍Sentinel：

一：熔断机制

二：降级机制

三：高可用性机制

Sentinel的高可用性主要通过以下方式来实现：

a.多节点部署：将Sentinel配置为多节点部署，确保即使一个节点发生故障，其他节点仍然能够继续工作。

b.持久化配置：Sentinel支持将配置信息持久化到外部存储，如Nacos、Redis等。这样，即使Sentinel节点重启，它可以加载之前的配置信息。

c.集群流控规则：Sentinel支持集群流控规则，多个节点可以共享流量控制规则，以协同工作来保护系统。

d.实时监控：Sentinel提供了实时监控和仪表板，可以查看系统的流量控制和熔断降级情况，帮助及时发现问题并采取措施。

四：自适应控制

Sentinel具有自适应控制的功能，它可以根据系统的实际情况自动调整流量控制和熔断降级策略，以适应不同的负载和流量模式。

总的来说，Sentinel的高可用性熔断降级机制是通过多节点部署、持久化配置、实时监控、自适应控制等多种手段来实现的。

这使得Sentinel能够在分布式系统中保护关键资源免受异常流量的影响，并保持系统的稳定性和可用性。

那么，Sentinel是如何实现这些功能的呢？在说说Sentinel的基本组件。

Sentinel主要包括以下几个部分：资源（Resource）、规则（Rule）、上下文（Context）和插槽（Slot）。

在Sentinel的运行过程中，主要分为以下几个核心步骤：

通过以上分析，我们可以看出，Sentinel的核心思想是通过规则来管理和控制资源。这种设计使得Sentinel具有很强的可扩展性和灵活性。我们可以根据业务需求，定制各种复杂的规则。

回到源码层面，在Sentinel源码，包括以下二大架构：

尼恩说明：两大架构的源码，简单说说就可以了，具体可以参见《Sentinel学习圣经》最新版本。

总指挥，Sentinel是一种非常强大的流量控制、熔断降级和服务降级的解决方案。已经成为了替代Hystrix的主要高可用组件。

以上的内容，如果大家能对答如流，如数家珍，基本上面试官会被你震惊到、吸引到。

最终，让面试官爱到“不能自已、口水直流”。offer，也就来了。

在刷题过程中，如果有啥问题，大家可以来找40岁老架构师尼恩交流。

另外，如果没有面试机会，可以找尼恩来改简历、做帮扶。

Sentinel是一个系统性的高可用保障工具，提供了限流、降级、熔断等一系列的能力，基于这些能力做了语意化概念抽象，这些概念对于理解实现机制特别有帮助，所以这里也复述一下。

流量控制有以下几个角度:

Sentinel的设计理念是让您自由选择控制的角度，并进行灵活组合，从而达到想要的效果。

它考虑了请求的历史分布，更适用于应对突发流量和周期性负载的情况。

我们知道，Sentinel可以用来帮助我们实现流量控制、服务降级、服务熔断，而这些功能的实现都离不开接口被调用的实时指标数据，本文便是关于Sentinel是如何实现指标数据统计的。

上图中的右上角就是滑动窗口的示意图，是StatisticSlot的具体实现。

StatisticSlot是Sentinel的核心功能插槽之一，用于统计实时的调用数据。

Sentinel是基于滑动窗口实现的实时指标数据收集统计，底层采用高性能的滑动窗口数据结构LeapArray来统计实时的秒级指标数据，可以很好地支撑写多于读的高并发场景。

publicclassArrayMetricimplementsMetric{privatefinalLeapArraydata;publicArrayMetric(intsampleCount,intintervalInMs,booleanenableOccupy){if(enableOccupy){this.data=newOccupiableBucketLeapArray(sampleCount,intervalInMs);}else{this.data=newBucketLeapArray(sampleCount,intervalInMs);}}LeapArray源码LeapArray用来承载滑动窗口，即成员变量array，

array类型为AtomicReferenceArray>，保证创建窗口的原子性（CAS）。

这些指标数据包括请求总数、成功总数、异常总数、总耗时、最小耗时、最大耗时等，

这里没有用AtomicLong，而是用LongAdder统计，LongAdder保证了数据修改的原子性，又采用分段模式，性能比AtomicLong表现更好。

publicenumMetricEvent{PASS,BLOCK,EXCEPTION,SUCCESS,RT,OCCUPIED_PASS}当需要获取Bucket记录总的成功请求数或者异常总数、总的请求处理耗时，可根据事件类型(MetricEvent)从Bucket的LongAdder数组中获取对应的LongAdder，并调用sum方法获取总数。

publiclongget(MetricEventevent){returncounters[event.ordinal()].sum();}当需要Bucket记录一个成功请求或者一个异常请求、处理请求的耗时，可根据事件类型（MetricEvent）从LongAdder数组中获取对应的LongAdder，并调用其add方法。

如果我们希望能够知道某个接口的统计数据：如每秒处理成功请求数（成功QPS）、每秒处理失败请求数（失败QPS），以及处理每个成功请求的平均耗时（avgRT），

注意这里我们只需要控制Bucket统计一秒钟的指标数据即可，但如何才能确保Bucket存储的就是精确到1秒内的数据呢？

由于只需要保存最近一分钟的数据。

内存资源是有限的，而这个数组可以循环使用，并且永远只保存最近1分钟的数据，这样可以避免频繁的创建Bucket，减少内存资源的占用。

那如何定位Bucket呢？

calculateTimeIdx方法中，取余数就是实现循环利用数组。

MetricBucket定义一个LongAdder[]类型的成员变量counter数组来进行窗口内数据的统计。

JDK1.8时，java.util.concurrent.atomic包中提供了一个新的原子类：LongAdder。

根据Oracle官方文档的介绍，LongAdder在高并发的场景下会比它的前辈————AtomicLong具有更好的性能，代价是消耗更多的内存空间：

我们知道，AtomicLong中有个内部变量value保存着实际的long值，所有的操作都是针对该变量进行。也就是说，高并发环境下，value变量其实是一个热点，也就是N个线程竞争一个热点。

LongAdder的基本思路就是分散热点，将value值分散到一个数组中，不同线程会命中到数组的不同槽中，各个线程只对自己槽中的那个值进行CAS操作，这样热点就被分散了，冲突的概率就小很多。如果要获取真正的long值，只要将各个槽中的变量值累加返回。

这种做法有没有似曾相识的感觉？没错，ConcurrentHashMap中的“分段锁”其实就是类似的思路。

尼恩强烈建议：Sentinel最好是和Hystrix对比学习

先看看老牌的hystrix

hystrix作为老牌SpringCloud微服务保护的组件，很多项目仍然在使用，

另外，底层原理都是想通的，大家可以和sentinel对比学习

sentinel是SpringCloud阿里巴巴的微服务保护组件，

所以，在学习的时候，sentinel最好与hystrix对比学习，

在微服务架构系统中通常会有多个服务，在服务调用中如果出现基础服务故障，可能会导致级联故障，即一个服务不可用，可能导致所有调用它或间接调用它的服务都不可用，进而造成整个系统不可用的情况，这种现象也被称为服务雪崩效应。

服务雪崩效应是一种因“服务提供者不可用”（原因）导致“服务调用者不可用”（结果），并将不可用逐渐放大的现象。

服务雪崩效应示意如图所示，A为服务提供者，B为A的服务调用者，C为B的服务调用者。

当服务A因为某些原因导致不可用时，会引起服务B的不可用，并将不可用放大到服务C进而导致整个系统瘫痪，这样就形成了服务雪崩效应。

出现服务雪崩效应的原因如下：

如何解决服务器雪崩的方法有以下这些：

Sentinel为我们提供了多种的解决服务雪崩的方法：如超时机制、限流机制、熔断机制、降级机制等等，后面会为大家进行介绍

2012年，Sentinel诞生于阿里巴巴，其主要目标是流量控制。2013-2017年，Sentinel迅速发展，并成为阿里巴巴所有微服务的基本组成部分。它已在6000多个应用程序中使用，涵盖了几乎所有核心电子商务场景。2018年，Sentinel演变为一个开源项目。2020年，SentinelGolang发布。

Sentinel的官方使用手册

对于sentinel的介绍，我们这里先引入官方的说法

分布式系统的流量防卫兵随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

然后来看看它的特性

丰富的应用场景：Sentinel承接了阿里巴巴近10年的双十一大促流量的核心场景，例如秒杀（即突发流量控制在系统容量可以承受的范围）、消息削峰填谷、集群流量控制、实时熔断下游不可用应用等。

完备的实时监控：Sentinel同时提供实时的监控功能。您可以在控制台中看到接入应用的单台机器秒级数据，甚至500台以下规模的集群的汇总运行情况。

广泛的开源生态：Sentinel提供开箱即用的与其它开源框架/库的整合模块，例如与SpringCloud、Dubbo、gRPC的整合。您只需要引入相应的依赖并进行简单的配置即可快速地接入Sentinel。

完善的SPI扩展点：Sentinel提供简单易用、完善的SPI扩展接口。您可以通过实现扩展接口来快速地定制逻辑。例如定制规则管理、适配动态数据源等。

Sentinel的生态圈

Sentinel很多的特性和Hystrix有很多类似的功能。以下是Sentinel和Hystrix的对比。

Sentinel官方提供了详细的由Hystrix迁移到Sentinel的方法

①资源：

资源是Sentinel的关键概念。它可以是Java应用程序中的任何内容，例如由应用程序提供的服务或者是服务里的方法，甚至可以是一段代码。Sentinel定义资源的方式有下面几种：适配主流框架自动定义资源、通过SphU手动定义资源、通过SphO手动定义资源、注解方式定义资源。这个稍后会有使用方法教程。

其中注解方式定义资源@SentinelResource参数介绍如下：

②规则：围绕资源而设定的规则。

您可以从官方网站中下载最新版本的控制台jar包，下载地址如下：

普通进程

java-server-Xms64m-Xmx256m-Dserver.port=8849-Dcsp.sentinel.dashboard.server=localhost:8849-Dproject.name=sentinel-dashboard-jar/work/sentinel-dashboard-1.8.6.jarjava-server-Xms64m-Xmx256m-Dserver.port=8849-Dcsp.sentinel.dashboard.server=localhost:8849-Dproject.name=sentinel-dashboard-jarsentinel-dashboard-1.8.6.jar守护进程

nohupjava-server-Xms64m-Xmx256m-Dserver.port=8849-Dcsp.sentinel.dashboard.server=localhost:8849-Dproject.name=sentinel-dashboard-jar/work/sentinel-dashboard-1.8.6.jar2>&1&或者/usr/bin/su-root-c"nohupjava-server-Xms64m-Xmx256m-Dserver.port=8849-Dcsp.sentinel.dashboard.server=localhost:8849-Dproject.name=sentinel-dashboard-jar/work/sentinel-dashboard-1.8.6.jar2>&1&"开机启动：启动命令可以加入到启动的rc.local配置文件，之后做到开机启动

启动Sentinel控制台需要JDK版本为1.8及以上版本，

使用如下命令启动控制台：

其中-Dserver.port=8849用于指定Sentinel控制台端口为8849。

启动日志如下

打开浏览器即可展示Sentinel的管理控制台

默认情况下Sentinel会在客户端首次调用的时候进行初始化，开始向控制台发送心跳包。

也可以配置sentinel.eager=true,取消Sentinel控制台懒加载。

控制台启动后，客户端需要按照以下步骤接入到控制台。

父工程引入alibaba实现的SpringCloud

org.springframework.cloudspring-cloud-dependenciesGreenwich.RELEASEpomimportcom.alibaba.cloudspring-cloud-alibaba-dependencies2.1.0.RELEASEpomimport子工程中引入sentinel

com.alibaba.cloudspring-cloud-starter-alibaba-sentinel配置启动参数在工程的application.yml中添加Sentinel控制台配置信息

spring:cloud:sentinel:transport:dashboard:192.168.180.137:8849#sentinel控制台的请求地址这里的spring.cloud.sentinel.transport.dashboard配置控制台的请求路径。

Sentinel可以简单的分为Sentinel核心库和Dashboard。核心库不依赖Dashboard，但是结合Dashboard可以取得最好的效果。使用Sentinel来进行熔断保护，主要分为几个步骤:

Sentinel的所有规则都可以在内存态中动态地查询及修改，修改之后立即生效.先把可能需要保护的资源定义好，之后再配置规则。

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

如果您的应用使用了Maven，则在pom.xml文件中加入以下代码即可：

资源是Sentinel中的核心概念之一。最常用的资源是我们代码中的Java方法。当然，您也可以更灵活的定义你的资源，例如，把需要控制流量的代码用SentinelAPISphU.entry("HelloWorld")和entry.exit()包围起来即可。在下面的例子中，我们将System.out.println("helloworld");作为资源（被保护的逻辑），用API包装起来。参考代码如下:

publicstaticvoidmain(String[]args){//配置规则.initFlowRules();while(true){//1.5.0版本开始可以直接利用try-with-resources特性try(Entryentry=SphU.entry("HelloWorld")){//被保护的逻辑System.out.println("helloworld");}catch(BlockExceptionex){//处理被流控的逻辑System.out.println("blocked!");}}}完成以上两步后，代码端的改造就完成了。

@SentinelResource("HelloWorld")publicvoidhelloWorld(){//资源中的逻辑System.out.println("helloworld");}这样，helloWorld()方法就成了我们的一个资源。注意注解支持模块需要配合SpringAOP或者AspectJ一起使用。

接下来，通过流控规则来指定允许该资源通过的请求次数，例如下面的代码定义了资源HelloWorld每秒最多只能通过20个请求。

Demo运行之后，我们可以在日志~/logs/csp/${appName}-metrics.log.xxx里看到下面的输出:

|--timestamp-|------datetime----|--resource-|p|block|s|e|rt1529998904000|2018-06-2615:41:44|helloworld|20|0|20|0|01529998905000|2018-06-2615:41:45|helloworld|20|5579|20|0|7281529998906000|2018-06-2615:41:46|helloworld|20|15698|20|0|01529998907000|2018-06-2615:41:47|helloworld|20|19262|20|0|01529998908000|2018-06-2615:41:48|helloworld|20|19502|20|0|01529998909000|2018-06-2615:41:49|helloworld|20|18386|20|0|0其中p代表通过的请求,block代表被阻止的请求,s代表成功执行完成的请求个数,e代表用户自定义的异常,rt代表平均响应时长。

可以看到，这个程序每秒稳定输出"helloworld"20次，和规则中预先设定的阈值是一样的。

客户端需要引入Transport模块来与Sentinel控制台进行通信。您可以通过pom.xml引入JAR包:

资源是Sentinel的关键概念。

它可以是Java应用程序中的任何内容，例如，由应用程序提供的服务，或由应用程序调用的其它应用提供的服务，RPC接口方法，甚至可以是一段代码。

只要通过SentinelAPI定义的代码，就是资源，能够被Sentinel保护起来。

大部分情况下，可以使用方法签名，URL，甚至服务名称作为资源名来标示资源。

把需要控制流量的代码用Sentinel的关键代码SphU.entry("资源名")和entry.exit()包围起来即可。

实例代码：

Entryentry=null;try{//定义一个sentinel保护的资源，名称为test-sentinel-apientry=SphU.entry(resourceName);//模拟执行被保护的业务逻辑耗时Thread.sleep(100);returna;}catch(BlockExceptione){//如果被保护的资源被限流或者降级了，就会抛出BlockExceptionlog.warn("资源被限流或降级了",e);return"资源被限流或降级了";}catch(InterruptedExceptione){return"发生InterruptedException";}finally{if(entry!=null){entry.exit();}ContextUtil.exit();}}在下面的例子中，用try-with-resources来定义资源。参考代码如下:

publicstaticvoidmain(String[]args){//配置规则.initFlowRules();while(true){//1.5.0版本开始可以直接利用try-with-resources特性try(Entryentry=SphU.entry("HelloWorld")){//被保护的逻辑System.out.println("helloworld");}catch(BlockExceptionex){//处理被流控的逻辑System.out.println("blocked!");}}}资源注解@SentinelResource也可以使用Sentinel提供的注解@SentinelResource来定义资源，实例如下:

@SentinelResource("HelloWorld")publicvoidhelloWorld(){//资源中的逻辑System.out.println("helloworld");}@SentinelResource注解注意：注解方式埋点不支持private方法。

@SentinelResource用于定义资源，并提供可选的异常处理和fallback配置项。

@SentinelResource注解包含以下属性：

blockHandler对应处理BlockException的函数名称，可选项。blockHandler函数访问范围需要是public，返回类型需要与原方法相匹配，参数类型需要和原方法相匹配并且最后加一个额外的参数，类型为BlockException。blockHandler函数默认需要和原方法在同一个类中。若希望使用其他类的函数，则可以指定blockHandlerClass为对应的类的Class对象，注意对应的函数必需为static函数，否则无法解析。

规则主要有流控规则、熔断降级规则、系统规则、权限规则、热点参数规则等：

一段硬编码的方式定义流量控制规则如下：

privatevoidinitSystemRule(){Listrules=newArrayList<>();SystemRulerule=newSystemRule();rule.setHighestSystemLoad(10);rules.add(rule);SystemRuleManager.loadRules(rules);}加载规则：

由于调用关系的复杂性，如果调用链路中的某个资源不稳定，最终会导致请求发生堆积。

熔断机模型：

当下游的服务因为某种原因突然变得不可用或响应过慢，上游服务为了保证自己整体服务的可用性，不再继续调用目标服务，直接返回，快速释放资源。如果目标服务情况好转则恢复调用。熔断器模型

熔断器模型的状态机有3个状态。

熔断降级规则包含下面几个重要的属性：

我们通常用以下几种降级策略：

异常比率的阈值范围是[0.0,1.0]，代表0%-100%。

可以通过调用DegradeRuleManager.loadRules()方法来用硬编码的方式定义流量控制规则。

异常数(DEGRADE_GRADE_EXCEPTION_COUNT)熔断：

@PostConstructpublicvoidinitSentinelRule(){//熔断规则：5s内调用接口出现异常次数超过5的时候,进行熔断ListdegradeRules=newArrayList<>();DegradeRulerule=newDegradeRule();rule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT);//熔断规则rule.setResource("queryGoodsInfo");rule.setCount(5);rule.setTimeWindow(5);degradeRules.add(rule);DegradeRuleManager.loadRules(degradeRules);}具体源码，请参见疯狂创客圈crazy-springcloud源码工程

参数

Hystrix常用的线程池隔离会造成线程上下切换的overhead比较大；

Hystrix使用的信号量隔离对某个资源调用的并发数进行控制，效果不错，但是无法对慢调用进行自动降级；

Sentinel通过并发线程数的流量控制提供信号量隔离的功能；

此外，Sentinel支持的熔断降级维度更多，可对多种指标进行流控、熔断，且提供了实时监控和控制面板，功能更为强大。

流量控制(FlowControl)，原理是监控应用流量的QPS或并发线程数等指标，当达到指定阈值时对流量进行控制，避免系统被瞬时的流量高峰冲垮，保障应用高可用性。

通过流控规则来指定允许该资源通过的请求次数，例如下面的代码定义了资源HelloWorld每秒最多只能通过20个请求。

参考的规则定义如下：

privatestaticvoidinitFlowRules(){Listrules=newArrayList<>();FlowRulerule=newFlowRule();rule.setResource("HelloWorld");rule.setGrade(RuleConstant.FLOW_GRADE_QPS);//SetlimitQPSto20.rule.setCount(20);rules.add(rule);FlowRuleManager.loadRules(rules);}一条限流规则主要由下面几个因素组成，我们可以组合这些元素来实现不同的限流效果：

资源名：唯一名称，默认请求路径

阈值类型/单机阈值：

是否集群：是否为集群

配置

频繁刷新请求，1秒访问2次请求，正常，超过设置的阈值，将报默认的错误。

再次的1秒访问2次请求，访问正常。超过2次，访问异常

调用关系包括调用方、被调用方；一个方法又可能会调用其它方法，形成一个调用链路的层次关系。Sentinel通过NodeSelectorSlot建立不同资源间的调用的关系，并且通过ClusterBuilderSlot记录每个资源的实时统计信息。

当两个资源之间具有资源争抢或者依赖关系的时候，这两个资源便具有了关联。

比如对数据库同一个字段的读操作和写操作存在争抢，读的速度过高会影响写得速度，写的速度过高会影响读的速度。如果放任读写操作争抢资源，则争抢本身带来的开销会降低整体的吞吐量。可使用关联限流来避免具有关联关系的资源之间过度的争抢.

举例来说，read_db和write_db这两个资源分别代表数据库读写，我们可以给read_db设置限流规则来达到写优先的目的。具体的方法：

设置`strategy`为`RuleConstant.STRATEGY_RELATE`设置`refResource`为`write_db`。这样当写库操作过于频繁时，读数据的请求会被限流。还有一个例子，电商的下订单和支付两个操作，需要优先保障支付，可以根据支付接口的流量阈值，来对订单接口进行限制，从而保护支付的目的。

添加2个请求

选择QPS，单机阈值为1，选择关联，关联资源为/test_ref，这里用Jmeter模拟高并发，请求/test_ref。

在大批量线程高并发访问/test_ref，导致/test失效了

链路类型的关联也类似，就不再演示了。多个请求调用同一微服务。

场景1：JVM刚启动场景需要预热，具体的原因，去阅读下面的博客

如秒杀系统在开启瞬间，会有很多流量上来，很可能把系统打死，预热方式就是为了保护系统，可慢慢的把流量放进来，慢慢的把阈值增长到设置的阈值。

WarmUp（冷启动，预热）模式就是为了实现这个保护系统目的的。

默认coldFactor为3，即请求QPS从threshold/3开始，经预热时长逐渐升至设定的QPS阈值。

@SentinelResource(value="testWarmUP",blockHandler="exceptionHandlerOfWarmUp")@GetMapping("/testWarmUP")publicStringtestWarmUP(){log.info(Thread.currentThread().getName()+"\t"+"...test1");return"-------hellobaby，iamtestWarmUP";}代码预热规则案例：阈值为10qps，预热时长设置为5s；

FlowRulewarmUPRule=newFlowRule();warmUPRule.setResource("testWarmUP");warmUPRule.setCount(10);warmUPRule.setGrade(RuleConstant.FLOW_GRADE_QPS);warmUPRule.setLimitApp("default");warmUPRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP);warmUPRule.setWarmUpPeriodSec(5);1）默认冷加载因子codeFactor为3，即请求QPS从（threshold/3）开始，经过多少预热时长才逐渐升至设定的QPS阈值；

系统初始化阈值为10/3约等于3，即阈值刚开始为3；然后过了5s后，阈值才慢慢升到10；

就是5s前阈值是3，5s后阈值为10；

3）testWarmUP刚开始每秒访问4次，就会报错，超过了10/3=3，5s后每秒访问1~10次都正常；

先在单机阈值10/3，3的时候，预热10秒后，慢慢将阈值升至20。

通常冷启动的过程系统允许通过的QPS曲线如下图所示：

这种方式主要用于处理间隔性突发的流量，例如消息队列。

想象一下这样的场景，在某一秒有大量的请求到来，而接下来的几秒则处于空闲状态，我们希望系统能够在接下来的空闲期间逐渐处理这些请求，而不是在第一秒直接拒绝多余的请求。

某瞬时来了大流量的请求,而如果此时要处理所有请求，很可能会导致系统负载过高，影响稳定性。但其实可能后面几秒之内都没有消息投递，若直接把多余的消息丢掉则没有充分利用系统处理消息的能力。

模拟2个用户同时并发的访问资源，发出100个请求,

何为热点？

热点即经常访问的数据。很多时候我们希望统计某个热点数据中访问频次最高的TopK数据，并对其访问进行限制。比如：

热点参数规则（ParamFlowRule）类似于流量控制规则（FlowRule）：

@GetMapping("/byHotKey")@SentinelResource(value="byHotKey",blockHandler="userAccessError")publicStringtest4(@RequestParam(value="userId",required=false)StringuserId,@RequestParam(value="goodId",required=false)intgoodId){log.info(Thread.currentThread().getName()+"\t"+"...byHotKey");return"-----------byHotKey：UserId";}限流规则代码：可以通过ParamFlowRuleManager的loadRules方法更新热点参数规则，下面是官方实例：

ParamFlowRulerule=newParamFlowRule(resourceName).setParamIdx(0).setCount(5);//针对int类型的参数PARAM_B，单独设置限流QPS阈值为10，而不是全局的阈值5.ParamFlowItemitem=newParamFlowItem().setObject(String.valueOf(PARAM_B)).setClassType(int.class.getName()).setCount(10);rule.setParamFlowItemList(Collections.singletonList(item));ParamFlowRuleManager.loadRules(Collections.singletonList(rule));具体的限流代码如下：

在开始之前，我们先了解一下系统保护的目的：

长期以来，系统保护的思路是根据硬指标，即系统的负载(load1)来做系统过载保护。当系统负载高于某个阈值，就禁止或者减少流量的进入；当load开始好转，则恢复流量的进入。这个思路给我们带来了不可避免的两个问题：

系统保护的目标是在系统不被拖垮的情况下，提高系统的吞吐率，而不是load一定要到低于某个阈值。如果我们还是按照固有的思维，超过特定的load就禁止流量进入，系统load恢复就放开流量，这样做的结果是无论我们怎么调参数，调比例，都是按照果来调节因，都无法取得良好的效果。

系统规则支持以下的模式：

系统保护规则是从应用级别的入口流量进行控制，从单台机器的load、CPU使用率、平均RT、入口QPS和并发线程数等几个维度监控应用指标，让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。

系统保护规则是应用整体维度的，而不是资源维度的，并且仅对入口流量生效。入口流量指的是进入应用的流量（EntryType.IN），比如Web服务或Dubbo服务端接收的请求，都属于入口流量。

系统规则的参数说明:

硬编码的方式定义流量控制规则如下：

调用方信息通过ContextUtil.enter(resourceName,origin)方法中的origin参数传入。也可以在spring容器中注册RequestOriginParser

Sentinel可以简单的分为Sentinel核心库和Dashboard。

核心库不依赖Dashboard，可以通过代码手段定义资源。

我们说的资源，可以是任何东西，服务，服务里的方法，甚至是一段代码。

使用Sentinel来进行资源保护，主要分为几个步骤:

先把可能需要保护的资源定义好（埋点），之后再配置规则。

对于主流的框架，我们提供适配，只需要按照适配中的说明配置，Sentinel就会默认定义提供的服务，方法等为资源。

为了减少开发的复杂程度，我们对大部分的主流框架，例如WebServlet、Dubbo、SpringCloud、gRPC、SpringWebFlux、Reactor等都做了适配。您只需要引入对应的依赖即可方便地整合Sentinel。

SphU包含了try-catch风格的API。用这种方式，当资源发生了限流之后会抛出BlockException。这个时候可以捕捉异常，进行限流之后的逻辑处理。示例代码如下:

//1.5.0版本开始可以利用try-with-resources特性（使用有限制）//资源名可使用任意有业务语义的字符串，比如方法名、接口名或其它可唯一标识的字符串。try(Entryentry=SphU.entry("resourceName")){//被保护的业务逻辑//dosomethinghere...}catch(BlockExceptionex){//资源访问阻止，被限流或被降级//在此处进行相应的处理操作}特别地，若entry的时候传入了热点参数，那么exit的时候也一定要带上对应的参数（exit(count,args)），否则可能会有统计错误。这个时候不能使用try-with-resources的方式。

另外通过Tracer.trace(ex)来统计异常信息时，由于try-with-resources语法中catch调用顺序的问题，会导致无法正确统计异常数，因此统计异常信息时也不能在try-with-resources的catch块中调用Tracer.trace(ex)。

手动exit示例：

Entryentry=null;//务必保证finally会被执行try{//资源名可使用任意有业务语义的字符串，注意数目不能太多（超过1K），超出几千请作为参数传入而不要直接作为资源名//EntryType代表流量类型（inbound/outbound），其中系统规则只对IN类型的埋点生效entry=SphU.entry("自定义资源名");//被保护的业务逻辑//dosomething...}catch(BlockExceptionex){//资源访问阻止，被限流或被降级//进行相应的处理操作}catch(Exceptionex){//若需要配置降级规则，需要通过这种方式记录业务异常Tracer.traceEntry(ex,entry);}finally{//务必保证exit，务必保证每个entry与exit配对if(entry!=null){entry.exit();}}热点参数埋点示例：

Entryentry=null;try{//若需要配置例外项，则传入的参数只支持基本类型。//EntryType代表流量类型，其中系统规则只对IN类型的埋点生效//count大多数情况都填1，代表统计为一次调用。entry=SphU.entry(resourceName,EntryType.IN,1,paramA,paramB);//Yourlogichere.}catch(BlockExceptionex){//Handlerequestrejection.}finally{//注意：exit的时候也一定要带上对应的参数，否则可能会有统计错误。if(entry!=null){entry.exit(1,paramA,paramB);}}SphU.entry()的参数描述：

注意：SphU.entry(xxx)需要与entry.exit()方法成对出现，匹配调用，否则会导致调用链记录异常，抛出ErrorEntryFreeException异常。常见的错误：

SphO提供if-else风格的API。用这种方式，当资源发生了限流之后会返回false，这个时候可以根据返回值，进行限流之后的逻辑处理。示例代码如下:

//资源名可使用任意有业务语义的字符串if(SphO.entry("自定义资源名")){//务必保证finally会被执行try{/***被保护的业务逻辑*/}finally{SphO.exit();}}else{//资源访问阻止，被限流或被降级//进行相应的处理操作}注意：SphO.entry(xxx)需要与SphO.exit()方法成对出现，匹配调用，位置正确，否则会导致调用链记录异常，抛出ErrorEntryFreeException`异常。

Sentinel支持通过@SentinelResource注解定义资源并配置blockHandler和fallback函数来进行限流之后的处理。示例：

Sentinel支持异步调用链路的统计。在异步调用中，需要通过SphU.asyncEntry(xxx)方法定义资源，并通常需要在异步的回调函数中调用exit方法。以下是一个简单的示例：

try{AsyncEntryentry=SphU.asyncEntry(resourceName);//异步调用.doAsync(userId,result->{try{//在此处处理异步调用的结果.}finally{//在回调结束后exit.entry.exit();}});}catch(BlockExceptionex){//Requestblocked.//Handletheexception(e.g.retryorfallback).}SphU.asyncEntry(xxx)不会影响当前（调用线程）的Context，因此以下两个entry在调用链上是平级关系（处于同一层），而不是嵌套关系：

//调用链类似于：//-parent//---asyncResource//---syncResourceasyncEntry=SphU.asyncEntry(asyncResource);entry=SphU.entry(normalResource);若在异步回调中需要嵌套其它的资源调用（无论是entry还是asyncEntry），只需要借助Sentinel提供的上下文切换功能，在对应的地方通过ContextUtil.runOnContext(context,f)进行Context变换，将对应资源调用处的Context切换为生成的异步Context，即可维持正确的调用链路关系。示例如下：

publicvoidhandleResult(Stringresult){Entryentry=null;try{entry=SphU.entry("handleResultForAsync");//Handleyourresulthere.}catch(BlockExceptionex){//Blockedfortheresulthandler.}finally{if(entry!=null){entry.exit();}}}publicvoidsomeAsync(){try{AsyncEntryentry=SphU.asyncEntry(resourceName);//Asynchronousinvocation.doAsync(userId,result->{//在异步回调中进行上下文变换，通过AsyncEntry的getAsyncContext方法获取异步ContextContextUtil.runOnContext(entry.getAsyncContext(),()->{try{//此处嵌套正常的资源调用.handleResult(result);}finally{entry.exit();}});});}catch(BlockExceptionex){//Requestblocked.//Handletheexception(e.g.retryorfallback).}}此时的调用链就类似于：

Sentinel实现限流、隔离、降级、熔断等功能，本质要做的就是两件事情：

这里的资源就是希望被Sentinel保护的业务，例如项目中定义的controller方法就是默认被Sentinel保护的资源。

实现上述功能的核心骨架是一个叫做ProcessorSlotChain的类。这个类基于责任链模式来设计，将不同的功能（限流、降级、系统保护）封装为一个个的Slot，请求进入后逐个执行即可。

责任链中的Slot也分为两大类：

Sentinel中的簇点链路是由一个个的Node组成的，Node是一个接口，包括下面的实现：

所有的节点都可以记录对资源的访问统计数据，所以都是StatisticNode的子类。

按照作用分为两类Node：

DefaultNode记录的是资源在当前链路中的访问数据，用来实现基于链路模式的限流规则。ClusterNode记录的是资源在所有链路中的访问数据，实现默认模式、关联模式的限流规则。

例如：我们在一个SpringMVC项目中，有两个业务：

创建的链路图如下：

Sentinel中核心对象的关系如下图：

默认情况下，Sentinel会将controller中的方法作为被保护资源，那么问题来了，我们该如何将自己的一段代码标记为一个Sentinel的资源呢？

//资源名可使用任意有业务语义的字符串，比如方法名、接口名或其它可唯一标识的字符串。try(Entryentry=SphU.entry("resourceName")){//被保护的业务逻辑//dosomethinghere...}catch(BlockExceptionex){//资源访问阻止，被限流或被降级//在此处进行相应的处理操作}8.3.1.自定义资源例如，我们在order-service服务中，将OrderService的queryOrderById()方法标记为一个资源。

1）首先在order-service中引入sentinel依赖

com.alibaba.cloudspring-cloud-starter-alibaba-sentinel2）然后配置Sentinel地址

spring:cloud:sentinel:transport:dashboard:localhost:8089#这里我的sentinel用了8089的端口3）修改OrderService类的queryOrderById方法

代码这样来实现：

publicOrderqueryOrderById(LongorderId){//创建Entry，标记资源，资源名为resource1try(Entryentry=SphU.entry("resource1")){//1.查询订单，这里是假数据Orderorder=Order.build(101L,4999L,"小米MIX4",1,1L,null);//2.查询用户，基于Feign的远程调用Useruser=userClient.findById(order.getUserId());//3.设置order.setUser(user);//4.返回returnorder;}catch(BlockExceptione){log.error("被限流或降级",e);returnnull;}}4）访问

然后打开sentinel控制台，查看簇点链路：

在之前学习Sentinel的时候，我们知道可以通过给方法添加@SentinelResource注解的形式来标记资源。

这个是怎么实现的呢？

来看下我们引入的Sentinel依赖包：

我们来看下SentinelAutoConfiguration这个类：

我们发现簇点链路中除了controller方法、service方法两个资源外，还多了一个默认的入口节点：

sentinel_spring_web_context，是一个EntranceNode类型的节点

这个节点是在初始化Context的时候由Sentinel帮我们创建的。

那么，什么是Context呢？

对应的API如下：

我们先看SentinelWebAutoConfiguration这个类：

这个类实现了WebMvcConfigurer，我们知道这个是SpringMVC自定义配置用到的类，可以配置HandlerInterceptor：

可以看到这里配置了一个SentinelWebInterceptor的拦截器。

发现它继承了AbstractSentinelInterceptor这个类。

HandlerInterceptor拦截器会拦截一切进入controller的方法，执行preHandle前置拦截方法，而Context的初始化就是在这里完成的。

我们来看看这个类的preHandle实现：

我们进入该方法：

publicstaticContextenter(Stringname,Stringorigin){if(Constants.CONTEXT_DEFAULT_NAME.equals(name)){thrownewContextNameDefineException("The"+Constants.CONTEXT_DEFAULT_NAME+"can'tbepermittodefined!");}returntrueEnter(name,origin);}进入trueEnter方法：

首先，回到一切的入口，AbstractSentinelInterceptor类的preHandle方法：

还有，SentinelResourceAspect的环绕增强方法：

可以看到，任何一个资源必定要执行SphU.entry()这个方法:

publicstaticEntryentry(Stringname,intresourceType,EntryTypetrafficType,Object[]args)throwsBlockException{returnEnv.sph.entryWithType(name,resourceType,trafficType,1,args);}继续进入Env.sph.entryWithType(name,resourceType,trafficType,1,args);：

@OverridepublicEntryentryWithType(Stringname,intresourceType,EntryTypeentryType,intcount,booleanprioritized,Object[]args)throwsBlockException{//将资源名称等基本信息封装为一个StringResourceWrapper对象StringResourceWrapperresource=newStringResourceWrapper(name,entryType,resourceType);//继续returnentryWithPriority(resource,count,prioritized,args);}进入entryWithPriority方法：

privateEntryentryWithPriority(ResourceWrapperresourceWrapper,intcount,booleanprioritized,Object...args)throwsBlockException{//获取ContextContextcontext=ContextUtil.getContext();if(context==null){//Usingdefaultcontext.context=InternalContextUtil.internalEnter(Constants.CONTEXT_DEFAULT_NAME);}、//获取Slot执行链，同一个资源，会创建一个执行链，放入缓存ProcessorSlot