Guava-RateLimiter令牌桶限流算法

前言

高并发系统一般会才采用三种策略来保护系统：缓存、服务降级、限流；

1. 缓存：比如Redis。先查询缓存，如果命中则返回；如果没有数据，查询数据库后返回并写入缓存；
2. 服务降级：比如Spring Cloud Hystrix。当服务出现问题需要暂时屏蔽掉，并在上游及时响应用户请求;
3. 限流：通过对并发访问/请求进行限速，或者对一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理；

1. 限流算法简介

常见有漏桶算法和令牌桶算法；

1. 漏桶算法
   漏桶作为计量工具（The Leaky Bucket Algorithm as a Meter）时，可以用于流量整形（Traffic Shaping）和流量控制（TrafficPolicing），漏桶算法的描述如下：
   一个固定容量的漏桶，按照常量固定速率流出水滴；
   如果桶是空的，则不需流出水滴；
   可以以任意速率流入水滴到漏桶；
   如果流入水滴超出了桶的容量，则流入的水滴溢出了（被丢弃），而漏桶容量是不变的。
   漏桶(Leaky Bucket)算法思路很简单,水(请求)先进入到漏桶里,漏桶以一定的速度出水(接口有响应速率),当水流入速度过大会直接溢出(访问频率超过接口响应速率),然后就拒绝请求,可以看出漏桶算法能强行限制数据的传输速率.示意图如下:
   
   可见这里有两个变量,一个是桶的大小,支持流量突发增多时可以存多少的水(burst),另一个是水桶漏洞的大小(rate)。
   因为漏桶的漏出速率是固定的参数,所以,即使网络中不存在资源冲突(没有发生拥塞),漏桶算法也不能使流突发(burst)到端口速率.因此,漏桶算法对于存在突发特性的流量来说缺乏效率.

2. 令牌桶算法
   令牌桶算法是一个存放固定容量令牌的桶，按照固定速率往桶里添加令牌。令牌桶算法的描述如下：
   假设限制2r/s，则按照500毫秒的固定速率往桶中添加令牌；
   桶中最多存放b个令牌，当桶满时，新添加的令牌被丢弃或拒绝；
   当一个n个字节大小的数据包到达，将从桶中删除n个令牌，接着数据包被发送到网络上；
   如果桶中的令牌不足n个，则不会删除令牌，且该数据包将被限流（要么丢弃，要么缓冲区等待）。
   令牌桶算法(Token Bucket)和 Leaky Bucket 效果一样但方向相反的算法,更加容易理解.随着时间流逝,系统会按恒定1/QPS时间间隔(如果QPS=100,则间隔是10ms)往桶里加入Token(想象和漏洞漏水相反,有个水龙头在不断的加水),如果桶已经满了就不再加了.新请求来临时,会各自拿走一个Token,如果没有Token可拿了就阻塞或者拒绝服务。
   
   令牌桶的另外一个好处是可以方便的改变速度. 一旦需要提高速率,则按需提高放入桶中的令牌的速率. 一般会定时(比如100毫秒)往桶中增加一定数量的令牌, 有些变种算法则实时的计算应该增加的令牌的数量.

这两种算法的主要区别在于“ 漏桶算法”能够强行限制数据的传输速率，而“令牌桶算法”在能够限制数据的平均传输速率外，还允许某种程度的突发传输。在“令牌桶算法”中，只要令牌桶中存在令牌，那么就允许突发地传输数据直到达到用户配置的门限，因此它适合于具有突发特性的流量。

2. RateLimiter

Guava中开源出来一个令牌桶算法的工具类RateLimiter，可以轻松实现限流的工作。

RateLimiter有两个实现类：SmoothBursty和SmoothWarmingUp;
两者都是令牌桶算法的变种实现，区别在于SmoothBursty加令牌的速度是恒定的，而SmoothWarmingUp会有个预热期，在预热期内加令牌的速度是慢慢增加的，直到达到固定速度为止。其适用场景是，对于有的系统而言刚启动时能承受的QPS较小，需要预热一段时间后才能达到最佳状态。
使用RateLimiter的时候，查看源码可知，具体实现根据create方法参数，返回不同的实现类；

2.1 方法摘要

返回类型	方法描述
double	acquire(); 从RateLimiter获取一个令牌，该方法会被阻塞直到获取到请求
double	acquire(int permits); 从RateLimiter获取指定令牌数，该方法会被阻塞直到获取到请求
static RateLimiter	create(double permitsPerSecond); 根据指定的稳定吞吐率创建RateLimiter，这里的吞吐率是指每秒多少令牌数（通常是指QPS，每秒多少查询）
static RateLimiter	create(double permitsPerSecond, long warmupPeriod, TimeUnit unit); 根据指定的稳定吞吐率和预热期来创建RateLimiter，这里的吞吐率是指每秒多少令牌数（通常是指QPS，每秒多少个请求量），在这段预热时间内，RateLimiter每秒分配的许可数会平稳地增长直到预热期结束时达到其最大速率。（只要存在足够请求数来使其饱和）
boolean	tryAcquire(); 从RateLimiter 获取令牌，permits默认为1
boolean	tryAcquire(int permits); 从RateLimiter获取指定令牌数
boolean	tryAcquire(int permits, long timeout, TimeUnit unit); 从RateLimiter 获取指定令牌数，如果在指定超时间获取到的话返回true，否则返回false
boolean	tryAcquire(long timeout, TimeUnit unit); 从RateLimiter 获取令牌，permits默认为1，如果在指定超时间获取到的话返回true，否则返回false

2.2 RateLimiter使用示例

示例1说明：创建一个令牌桶，每秒生成一个令牌，申请失败立即返回。使用CountdownLatch计数器模拟多线程并发：调用await()方法阻塞当前线程，当计数完成后，唤醒所有线程并发执行。

public static void main(String[] args) {
        //每秒生成一个令牌，返回SmoothBursty实现类
        RateLimiter rateLimiter = RateLimiter.create(1D);
        CountDownLatch countDownLatch = new CountDownLatch(1);
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            Runnable runnable = () -> {
                try {
                    countDownLatch.await();
                    //尝试获取令牌桶中一个令牌，失败立即返回
                    if (rateLimiter.tryAcquire()) {
                        System.out.println(Thread.currentThread().getName() + ": " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "获取到令牌");
                    } else {
                        System.out.println(Thread.currentThread().getName() + ": byebye");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
            executor.submit(runnable);
        }
        countDownLatch.countDown();
        executor.shutdown();
    }

示例2说明：创建一个令牌桶，每秒生成0.1个令牌，即每10s才会有一个令牌，超时时间设置成60s，60s内获取不到令牌返回失败，60s内可以生成6个令牌，加上创建时桶里会有一个令牌，所以超时前最终会有7条线程拿到令牌，并且每个令牌获取时间相隔10s。使用CountdownLatch计数器模拟多线程并发：调用await()方法阻塞当前线程，当计数完成后，唤醒所有线程并发执行。

public static void main(String[] args) {
        //每秒生成一个令牌，返回SmoothBursty实现类
        RateLimiter rateLimiter = RateLimiter.create(0.1D);
        CountDownLatch countDownLatch = new CountDownLatch(1);
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            Runnable runnable = () -> {
                try {
                    countDownLatch.await();
                    //尝试获取令牌桶中一个令牌，最多等待60秒
                    if (rateLimiter.tryAcquire(60, TimeUnit.SECONDS)) {
                        System.out.println(Thread.currentThread().getName() + ": " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "获取到令牌");
                    } else {
                        System.out.println(Thread.currentThread().getName() + ": byebye");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
            executor.submit(runnable);
        }
        countDownLatch.countDown();
        executor.shutdown();
    }