高并发场景下的限流策略

什么是限流和降级

在开发高并发系统时，有很多手段来保护系统： 缓存、降级、限流。

当访问量快速增长、服务可能会出现一些问题的时候（响应超时），或者会存在非核心服务影响到核心流程的性能时，仍然需要保证服务的可用性，即便是有损服务。

所以意味着我们在设计服务的时候，需要一些手段或者关键数据进行自动降级，或者配置人工降级的开关。

缓存的目的是提升系统访问速度和增大系统处理的容量，可以说是抗高并发流量的银弹：

降级是当服务出问题或者影响到核心流程的性能则需要暂时屏蔽掉某些功能，等高峰或者问题解决后再打开；而有些场景并不能用缓存和降级来解决，比如秒杀、抢购；写服务（评论，下单）、频繁的复杂查询，因此需要一种手段来限制这些场景的并发/请求量

降级

对于高可用服务的设计，有一个很重要的设计，那就是降级。降级一般有几种实现
手段，自动降级和人工降级
1. 通过配置降级开关，实现对流程的控制
2. 前置化降级开关， 基于 OpenResty+配置中心实现降级
3. 业务降级，在大促的时候，我们会有限保证核心业务的流程可用，也就是下单支付。同时，我们也会对核心的支付流程采取一些异步化的方式来提升吞吐量

限流

限流的目的是防止恶意请求流量、恶意攻击、或者防止流量超过系统峰值
限流是对资源访问做控制的一个组件或者功能，那么控制这块主要有两个功能:
限流策略和熔断策略，对于熔断策略，不同的系统有不同的熔断策略诉求，有得系
统希望直接拒绝服务、有的系统希望排队等待、有的系统希望服务降级。限流服务
这块有两个核心概念:资源和策略
资源:被流量控制的对象，比如接口
策略:限流策略由限流算法和可调节的参数两部份组成
限流的目的是通过对并发访问/请求进行限速或者一个时间窗口内的请求进行限速 来保护系统，一旦达到限制速率则可以拒绝服务(定向到错误页或者告知资源没有 了)、排队或等待(秒杀、下单)、降级(返回兜底数据或默认数据或默认数据，如 商品详情页库存默认有货)

 策略1，漏桶：

桶本身具有一个恒定的速率往下漏水，而上方时快时慢的会有水进入桶内。当桶还
未满时，上方的水可以加入。一旦水满，上方的水就无法加入。桶满正是算法中的
一个关键的触发条件(即流量异常判断成立的条件)。而此条件下如何处理上方流
下来的水，有两种方式
在桶满水之后，常见的两种处理方式为:
  
   1)暂时拦截住上方水的向下流动，等待桶中的一部分水漏走后，再放行上方水。

   2)溢出的上方水直接抛弃。
特点：
   1. 漏水的速率是固定的
   2. 即使存在注水 burst(突然注水量变大)的情况，漏水的速率也是固定的

策略2：令牌桶(能够解决突发流量)

   

       令牌桶算法是网络流量整形(Traffic Shaping)和速率限制(Rate Limiting)中最 常使用的一种算法。典型情况下，令牌桶算法用来控制发送到网络上的数据的数目， 并允许突发数据的发送。
令牌桶是一个存放固定容量令牌(token)的桶，按照固定速率往桶里添加令牌; 令牌桶算法实际上由三部分组成:两个流和一个桶，分别是令牌流、数据流和令牌桶.

限流算法的技术实现：（单机， 分布式）：

单机采用：Guava

Guava 的 RateLimiter 实现
在 Guava 中 RateLimiter 的实现有两种: Bursty 和 WarmUp

Bursty
bursty 是基于 token bucket 的算法实现，比如
RateLimiter rateLimiter=RateLimiter.create(permitPerSecond); //创建一个 bursty
实例
rateLimiter.acquire(); //获取 1 个 permit，当令牌数量不够时会阻塞直到获取为止

WarmingUp
  1. 基于 Leaky bucket 算法实现
  2. QPS 是固定的
  3. 使用于需要预热时间的使用场景
RateLimiter create(double permitsPerSecond, long warmupPeriod, TimeUnit unit)
//创建一个 SmoothWarmingUp 实例;warmupPeriod 是指预热的时间
RateLimiter rateLimiter =RateLimiter.create(permitsPerSecond,warmupPeriod,timeUnit);
rateLimiter.acquire();//获取 1 个 permit;可能会被阻塞止到获取到为止
 

package com.zz.amqp1.token;

import com.google.common.util.concurrent.RateLimiter;
import lombok.Data;

import java.util.concurrent.TimeUnit;

/**
 * Description: guava token策略执行
 * User: zhouzhou
 * Date: 2019-04-14
 * Time: 3:32 PM
 */
@Data
public class GuavaToken {

    private RateLimiter rateLimiter;

    private double tps;

    private double countOfReq;

    public GuavaToken(int tps, int countOfReq) {
        this.tps = tps;
        this.countOfReq = countOfReq;
    }

    /**
     * 初始化定义一个token 桶
     *
     * @return
     */
    public GuavaToken createBucket() {
        rateLimiter = RateLimiter.create(tps);
        return this;
    }

    /**
     * 预热时间 漏桶
     * @return
     */
    public GuavaToken createWarningup(){
        rateLimiter = RateLimiter.create(tps,100, TimeUnit.MILLISECONDS);
        return this;
    }

    private void processRequest() {
        System.out.println("RateLimiter" + rateLimiter.getClass());
        long start = System.currentTimeMillis();
        for (int i = 0; i < countOfReq; i++) {
            // 处理请求中
            rateLimiter.acquire();
        }
        long need = System.currentTimeMillis() - start;
        System.out.println(String.format("请求数量{%s},耗时为{%s},tps 为{%s},实际 tps{%s}",
                countOfReq, need, rateLimiter.getRate(), Math.ceil(countOfReq / (need / 1000.0))));

    }

    public void process(){
        for (int i = 0; i < 5; i++) {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            processRequest();
        }
    }

    public static void main(String[] args) {
        new GuavaToken(50,100).createBucket().process();
        new GuavaToken(50,100).createWarningup().process();

    }
}

运行 main 方法，结果如下：

RateLimiterclass com.google.common.util.concurrent.SmoothRateLimiter$SmoothBursty
请求数量{100.0},耗时为{983},tps 为{50.0},实际 tps{102.0}
RateLimiterclass com.google.common.util.concurrent.SmoothRateLimiter$SmoothBursty
请求数量{100.0},耗时为{982},tps 为{50.0},实际 tps{102.0}
RateLimiterclass com.google.common.util.concurrent.SmoothRateLimiter$SmoothBursty
请求数量{100.0},耗时为{998},tps 为{50.0},实际 tps{101.0}
RateLimiterclass com.google.common.util.concurrent.SmoothRateLimiter$SmoothBursty
请求数量{100.0},耗时为{997},tps 为{50.0},实际 tps{101.0}
RateLimiterclass com.google.common.util.concurrent.SmoothRateLimiter$SmoothBursty
请求数量{100.0},耗时为{994},tps 为{50.0},实际 tps{101.0}
RateLimiterclass com.google.common.util.concurrent.SmoothRateLimiter$SmoothWarmingUp
请求数量{100.0},耗时为{2032},tps 为{50.0},实际 tps{50.0}
RateLimiterclass com.google.common.util.concurrent.SmoothRateLimiter$SmoothWarmingUp
请求数量{100.0},耗时为{2032},tps 为{50.0},实际 tps{50.0}
RateLimiterclass com.google.common.util.concurrent.SmoothRateLimiter$SmoothWarmingUp
请求数量{100.0},耗时为{2031},tps 为{50.0},实际 tps{50.0}
RateLimiterclass com.google.common.util.concurrent.SmoothRateLimiter$SmoothWarmingUp
请求数量{100.0},耗时为{2031},tps 为{50.0},实际 tps{50.0}
RateLimiterclass com.google.common.util.concurrent.SmoothRateLimiter$SmoothWarmingUp
请求数量{100.0},耗时为{2032},tps 为{50.0},实际 tps{50.0}

Process finished with exit code 0

 分布式采用： redis + lua 即可