1. 限流算法
我们知道，在分布式架构中，当服务请求量过大时，容易对服务器造成不可预知的压力，因此，我们在客户端请求的时候，进行限流，起到一个保护的作用
常见的限流算法有: 计数器限流，滑动窗口限流、漏桶限流、令牌桶限流算法
1.1 计数器限流
计数器算法是限流算法里最简单也是最容易实现的一种算法。比如我们规定，对于A接口来说，我们1分钟的访问次数不能超过100个。那么我们可以这么做：在一开 始的时候，我们可以设置一个计数器counter，每当一个请求过来的时候，counter就加1，如果counter的值大于100并且该请求与第一个请求的间隔时间还在1分钟之内，那么说明请求数过多；如果该请求与第 一个请求的间隔时间大于1分钟，且counter的值还在限流范围内，那么就重 置 counter
具体算法的示意图如下:
假设有一个恶意用户，他在0：59时，瞬间发送了100个请求，并且1：00又瞬间发送了100个请求，这种情况，其实是符合我们上述规则的。因为在0:00-0:59这个区间用户确实没有超过我们设置的100这个最大范围
临界值问题，如下图:
因此，滑动窗口限流就对这个问题进行了改进
1.2 滑动窗口限流
发送和接受方都会维护一个数据帧的序列，这个序列被称作窗口。发送方的窗口大小由接受方确定，目的在于控制发送速度，以免接受方的缓存不够大，而导致溢出，同时控制流量也可以避免网络拥塞。下面图中的4,5,6号数据帧已经被发送出去，但是未收到关联的ACK，7,8,9帧则是等待发送。可以看出发送端的窗口大小为6，这是由接受端告知的。此时如果发送端收到4号ACK，则窗口的左边缘向右收缩，窗口的右边缘则向右扩展，此时窗口就向前“滑动了”，即数据帧10也可以被发送
滑动窗口演示地址:Selective Repeat Protocol (pearsoncmg.com)
1.3 漏桶限流
漏桶算法思路是，不断的往桶里面注水，无论注水的速度是大还是小，水都是按固定的速率往外漏水；如果桶满了，水会溢出；
桶本身具有一个恒定的速率往下漏水，而上方时快时慢的会有水进入桶内。
当桶还未满时，上方的水可以加入。一旦水满，上方的水就无法加入。桶满正是算法中的一个关键的触发条件（即流量异常判断成立的条件）。
在桶满水之后，常见的有两种处理方式为:
- 暂时拦截住上方水的向下流动，等待桶中的一部分水漏走后，再放行上方水。
- 溢出的上方水直接抛弃
特点:
- 漏水的速率是固定的
- 即使存在注水burst(突然注水量变大)的情况，漏水的速度也是固定的
1.4 令牌桶限流
令牌桶算法是网络流量整形（Traffic Shaping）和速率限制（Rate Limiting）中最常使用的一种算法。典型情况下，令牌桶算法用来控制发送到网络上的数据的数目，并允许突发数据的发送。令牌桶是一个存放固定容量令牌（token）的桶，按照固定速率往桶里添加令牌; 令牌桶算法实际上由三部分组成：两个流和一个桶，分别是令牌流、数据流和令牌桶
- 令牌流与令牌桶
系统会以一定的速度生成令牌，并将其放置到令牌桶中，可以将令牌桶想象成一个缓冲区（可以用队列这种数据结构来实现），当缓冲区填满的时候，新生成的令牌会被扔掉。这里有两个变量很重要:第一个是生成令牌的速度，一般称为 rate 。比如，我们设定 rate = 2 ，即每秒钟生成 2 个令牌，也就是每 1/2 秒生成一个令牌；第二个是令牌桶的大小，一般称为 burst 。比如，我们设定 burst = 10 ，即令牌桶最大只能容纳 10 个令牌。
- 数据流
数据流是真正的进入系统的流量，对于http接口来说，如果平均每秒钟会调用2次，则认为速率为 2次/s。
有以下三种情形可能发生
数据流的速率等于令牌流的速率。这种情况下,每个到来的数据包或者请求都能对应一个令牌,然后无延迟地通过队列；
数据流的速率小于令牌流的速率 。通过队列的数据包或者请求只消耗了一部分令牌，剩下的令牌会在令牌桶里积累下来，直到桶被装满。剩下的令牌可以在突发请求的时候消耗掉。数据流的速率大于令牌流的速率 。这意味着桶里的令牌很快就会被耗尽。导致服务中断一段时间，如果数据包或者请求持续到来,将发生丢包或者拒绝响应。
比如前面举得例子，生产令牌得速率和令牌桶得大小分别为rate = 2，burst =10 ,则系统能承受得突发请求速率为10次/s,平均请求速率为2次/s.三种情形中得最后一种情形是这个算法得核心所在，这个算法非常精确，实现非常简单并且对服务器得压力可以忽略不计，因此应用的相当广泛。
特点
- 令牌可以积累:桶中最大的令牌数是b，表示可以积累的最大令牌数
- 允许突发流量:桶中token可以积累到n(0=<n<=b),此时如果有n个突发请求同时到达，这n个请求时可以同时允许处理的。
2.Sentinel实现限流
sentinel是阿里中间件团队开源的，面向分布式服务架构的轻量级高可用流量控制组件，主要以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度来帮助用户保护服务的稳定性。
选择sentinel作为限流组件，有很多理由，其中最有说服力的理由应该是
1. Sentinel承接了多次双十一大促流量的核心场景、包括秒杀、集群流量控制、实时熔断下游不可用服务2. Sentinel提供了实时监控，可以通过控制台看到接入的应用的单台机器的秒级别数据3. Sentinel 的生态支持，可以很简单的接入spring cloud、Dubbo、gRPC4. 提供了SPI的扩展，可以通过SPI来扩展定制自己的限流规则
在Sentinel中，要实现流量控制，有两个核心的因素
- 资源
简单来说，资源是指要被Sent inel保护自来的目标对象，它是 Sentinel 的关键概念。它可以是 Java 应用程序中的任何内容，例如，由应用程序提供的服务，或由应用程序调用的其它应用提供的服务，甚至可以是一段代码。大部分情况下，可以使用方法签名，URL，甚至服务名称作为资源名来标示资源。
- 规则
针对目标资源所设定的流控规则，它是围绕资源的实时状态设定的，可以包括流量控制规则、熔断降级规则以及系统保护规则，所有规则可以动态实时调整。流量控制在网络传输中是一个常用的概念，它用于调整网络包的发送数据。在实际应用中，请求数量往往是随机的且不可控的，而系统的处理能力又有限，所以我们需要根据系统的处理能力对流量进行控制，而Sentinel的核心作用，就是针对目标资源使用对应的规则把随机的请求调整成合适的形状
流量控制通常有以下纬度:
- 资源的调用关系，例如资源的调用链路，资源和资源之间的关系。
- 运行指标，例如QPS、线程池、系统负载等
- 控制的效果，例如直接限流、冷启动、排队等
Sentinel的设计理念是让您自由选择控制的角度，并进行灵活组合，从而达到想要的效果。
3.限流应用实战
3.1 基于Semaphore实现一个线程流量的控制
public class SemaphoreExample {
public static void main(String[] args) {
ExecutorService executorService= Executors.newCachedThreadPool();
Semaphore semaphore=new Semaphore(5); //5个令牌
for (int i = 0; i < 20; i++) {
final int NO=i;
Runnable runnable=new Runnable() {
@Override
public void run() { //表示线程的执行逻辑
try {
semaphore.acquire(); //在执行之前，先获取一个令牌
System.out.println(Thread.currentThread().getName()+":执行业务逻辑:"+NO);
Thread.sleep(new Random().nextInt(1000));
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
System.out.println(Thread.currentThread().getName()+":释放令牌");
semaphore.release(); //释放令牌
}
}
};
executorService.execute(runnable);
}
executorService.shutdown();
}
}
分析: semaphore创建了5个令牌 可以看到有5个线程拿到了令牌，当有一个线程释放令牌后，下一个线程才能够进来继续执行
3.2 基于guava实现的线程限流
public class GuavaExample {
RateLimiter rateLimiter=RateLimiter.create(10); //qps=10 每秒生成10个
public void doRequest(){
if(rateLimiter.tryAcquire()){ //获取一个令牌
System.out.println(Thread.currentThread().getName()+":正常处理");
}else{
System.out.println(Thread.currentThread().getName()+":请求数量过多");
}
}
public static void main(String[] args) throws IOException {
GuavaExample ge=new GuavaExample();
Random random=new Random();
CountDownLatch latch=new CountDownLatch(1);
for (int i=0;i<20;i++){
new Thread(()->{
try {
latch.await(); //让线程先阻塞
Thread.sleep(random.nextInt(1000));
ge.doRequest();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
latch.countDown();
System.in.read();
}
}3.3 基于Sentinel的限流
限流治理
a.引入jar包
<dependency>
<groupId>com.alibaba.csp</groupId>
<artifactId>sentinel-core</artifactId>
<version>1.8.5</version>
</dependency>b. 代码演示:
public class SentinelExample {
//构造块
{
initFlowRules();
}
//静态块
static {
}
//流控控制保护对象 针对doRequest进行限流
private final static String RESROUCE="doRequest";
public static void main(String[] args) {
SentinelExample se=new SentinelExample();
se.doRequest();
}
public void doRequest(){
while(true){
try(Entry entry= SphU.entry(RESROUCE)){//java7，自动释放资源
System.out.println(Thread.currentThread().getName()+":+执行业务逻辑");
}catch (BlockException e){
//如果被限流，就会抛出BlockedException
e.printStackTrace();
}
}
}
private void initFlowRules(){
FlowRule rule=new FlowRule(); //限流的规则
rule.setCount(5); // 每秒访问5个请求
rule.setGrade(RuleConstant.FLOW_GRADE_QPS); //针对QPS限流
rule.setResource(RESROUCE); //被保护的资源
List<FlowRule> rules=new ArrayList<>();
rules.add(rule);
FlowRuleManager.loadRules(rules); //让Sentinel加载限流规则
}
}分析: sentinel的使用主要围绕连个方向，定义什么样的规则，要限流或者说要保护的对象，基于这两点，initFlowRules方法就是定义规则和要保护的对象并且交由sentinel加载。采用while(true)不断的去请求资源。来模拟限流。
4.Springboot集成sentinel
a.引入jar包
<dependency>
<groupId>com.alibaba.csp</groupId>
<artifactId>sentinel-annotation-aspectj</artifactId>
<version>1.8.5</version>
</dependency>b.集成spring注入sentinel Bean 这是因为sentinel中不像nacos和dubbo中有着spring-context nacos-spring-context这样的包，sentinel中没有sentinel-spring-context这样的包，但是都是基于AOP实现的，因此可以采用Bean注入的方式注入，让@SentinelResource注解生效
@Configuration
public class SentinelConfigration {
@Bean
public SentinelResourceAspect sentinelResourceAspect(){
return new SentinelResourceAspect();
}
}c.sentinel规则的初始化
public class FlowRuleInitFunc implements InitFunc {
@Override
public void init() throws Exception {
List<FlowRule> rules=new ArrayList<>();
FlowRule rule1=new FlowRule(); //限流的规则
rule1.setCount(2);
rule1.setGrade(RuleConstant.FLOW_GRADE_QPS); //针对QPS限流
rule1.setResource(SentinelMethodConstant.SAYMETHOD_NAME); //被保护的资源
FlowRule rule2=new FlowRule(); //限流的规则
rule2.setCount(2);
rule2.setGrade(RuleConstant.FLOW_GRADE_QPS); //针对QPS限流
rule2.setResource(SentinelMethodConstant.TEST_FALLBACK); //被保护的资源
rules.add(rule1);
rules.add(rule2);
FlowRuleManager.loadRules(rules); //让Sentinel加载限流规则
}
}sentinel中提供了初始化的SPI，只要实现InitFunc，在静态资源里面配置好，则启动项目的时候就会自动加载该规则
com.zsc.sentinel.example.springbootsentinelexample.config.FlowRuleInitFuncd.对接口方法级别的限流使用
@Service
public class HelloService {
Logger logger= LoggerFactory.getLogger(HelloService.class);
// value 必填 针对哪个资源做流量控制
// blockHandler 表示的是出现block exception时的处理方法
// blockHandlerClass 表示的是出现block exception时的处理类
@SentinelResource(value = SentinelMethodConstant.SAYMETHOD_NAME,
blockHandlerClass = SayMethodException.class,
blockHandler = "handleException"
)
public void say(){
System.out.println("Hello, Sentinel");
}
// fallback 降级
@SentinelResource(value = SentinelMethodConstant.TEST_FALLBACK,
fallback = "helloFallback")
public String testFallback(){
return "Hello, Fallback Test";
}
public String helloFallback(){
logger.info("触发了Fallback方法");
return "我是Fallback的返回结果";
}
}
常量类与异常处理类
public class SentinelMethodConstant {
public final static String SAYMETHOD_NAME="say";
public final static String TEST_FALLBACK="testFallback";
}
public class SayMethodException {
public static void handleException(BlockException e){
e.printStackTrace();
System.out.println("Occur Exception: "+e.getClass().getCanonicalName());
}
}
4.1 sentinel-dashboard的使用
java -Dserver.port=9999 -Dcsp.sentinel.dashboard.server=localhost:9999 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.8.7.jarsentinel的可视化看板
https://github.com/alibaba/Sentinel/在release版本中找到jar包
在cmd中执行命令
java -Dserver.port=9999 -Dcsp.sentinel.dashboard.server=localhost:9999 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.8.7.jar
在浏览器直接打开localhost:9999 输入账号密码 sentinel可进入
5. dubbo集成sentinel
a.引入jar包
<dependency>
<groupId>com.alibaba.csp</groupId>
<artifactId>sentinel-apache-dubbo-adapter</artifactId>
<version>1.8.5</version>
</dependency>b.写规则，与springboot集成一致,只是资源换成接口级别的了
public class DubboFuleRuleInit implements InitFunc {
@Override
public void init() throws Exception {
List<FlowRule> rules=new ArrayList<>();
FlowRule rule1=new FlowRule(); //限流的规则
rule1.setCount(2);
rule1.setGrade(RuleConstant.FLOW_GRADE_QPS); //针对QPS限流
rule1.setResource("org.zsc.normal.user.ISentinelService"); //被保护的资源
rules.add(rule1);
FlowRuleManager.loadRules(rules); //让Sentinel加载限流规则
}
}c.接口正常实现
@DubboService(cluster = "failfast",timeout = 1000)
public class SentinelService implements ISentinelService {
Logger logger= LoggerFactory.getLogger(SentinelService.class);
@Override
public String testSentinel() {
logger.info("begin SentinelService.testSentinel Method");
return "执行Sentinel测试方法，测试限流的功能";
}
}
d.那么dubbo是怎么控制该接口限流的呢 在dubbo里面有个fillter会去对接口名进行限流
6.总结
sentinel除了本身功能的丰富性，还可以集成不同的组件实现流量的控制，同时还能够针对不同维度，不同的指标来控制，并且它还能通过dashboard进行整体流量的管理和监控，这样对我们的整个维护来说会更加友好。核心的两个功能是限流和熔断，本篇只是介绍了限流的使用，后续介绍熔断。限流核心的两个东西是规则和资源，就是说我针对这个资源要通过什么样的规则来实现这个资源的保护。所以，在sentinel中要强化的两个点就是flowrule和resource,resource可以是我们的应用、接口、方法等。
