限流常见算法

限流的演进

固定窗口

/**
* 最后一次成功请求时间
*/
private long lastReqTime = System.currentTimeMillis();  
/**
* 毫秒为单位的时间窗口
*/
private final long windowInMs;
/**
* 时间窗口内最大允许的阈值
*/
private final int threshold;
/**
* 计数器
*/
private long counter;
/**
* 固定窗口时间算法
* @return
*/
boolean synchronized fixedWindowsTryAcquire() {
    long currentTime = System.currentTimeMillis();  //获取系统当前时间
if (currentTime - lastRequestTime > windowInMs) {  //检查是否在时间窗口内
    counter = 0;  // 计数器清0
    lastRequestTime = currentTime;  //开启新的时间窗口
}
if (counter < threshold) {  // 小于阀值
    counter++;  //计数器加1
    return true;
}

return false;
}

问题：边界问题，在两个时间窗口间附近有大量请求，这种拦截不到

滑动窗口

拆分更小子窗口，每过一个子窗口大小的时间，就向右滑动一个子窗口

/**
 * 阈值
 */
private int qps = 2;
/**
 * 时间窗口总大小（毫秒）
 */
private long windowSize = 1000;
/**
 * 多少个子窗口
 */
private Integer windowCount = 10;
/**
 * 窗口列表
 */
private WindowInfo[] windowArray = new WindowInfo[windowCount];

public RateLimiterSlidingWindow(int qps) {
    this.qps = qps;
    long currentTimeMillis = System.currentTimeMillis();
    for (int i = 0; i < windowArray.length; i++) {
        windowArray[i] = new WindowInfo(currentTimeMillis, new AtomicInteger(0));
    }
}

/**
 * 1. 计算当前时间窗口
 * 2. 更新当前窗口计数 & 重置过期窗口计数
 * 3. 当前 QPS 是否超过限制
 *
 * @return
 */
public synchronized boolean slidingWindowTryAcquire() {
    long currentTimeMillis = System.currentTimeMillis();
    // 1. 计算当前时间窗口
    int currentIndex = (int)(currentTimeMillis % windowSize / (windowSize / windowCount));
    // 2.  更新当前窗口计数 & 重置过期窗口计数
    int sum = 0;
    for (int i = 0; i < windowArray.length; i++) {
        WindowInfo windowInfo = windowArray[i];
        if ((currentTimeMillis - windowInfo.getTime()) > windowSize) {
            windowInfo.getNumber().set(0);
            windowInfo.setTime(currentTimeMillis);
        }
        if (currentIndex == i && windowInfo.getNumber().get() < qps) {
            windowInfo.getNumber().incrementAndGet();
        }
        sum = sum + windowInfo.getNumber().get();
    }
    // 3. 当前 QPS 是否超过限制
    return sum <= qps;
}

private class WindowInfo {
    // 窗口开始时间
    private Long time;
    // 计数器
    private AtomicInteger number;

    public WindowInfo(long time, AtomicInteger number) {
        this.time = time;
        this.number = number;
    }
}

问题：无法解决短时间之内集中流量的突击。如果5ms内打满了那么剩余时间一直会拒绝请求，不够平滑，最好能在突发的时候适当拒绝请求为后续请求留一些“额度”

漏桶算法

像注水漏水的过程。往漏桶中以任意速率流入水，以固定的速率流出水。当水超过桶的容量时，会被溢出，也就是被丢弃。因为桶容量是不变的，保证了整体的速率。可以很好的保护自身系统不被突如其来的流量冲垮

/**
 * 每秒处理数（出水率）
 */
private long rate;

/**
 *  当前剩余水量
 */
private long currentWater;

/**
 * 最后刷新时间
 */
private long refreshTime;

/**
 * 桶容量
 */
private long capacity;

/**
 * 漏桶算法
 * @return
 */
public synchronized boolean leakybucketLimitTryAcquire() {
    long currentTime = System.currentTimeMillis();  //获取系统当前时间
    long outWater = (currentTime - refreshTime) / 1000 * rate; //流出的水量 =(当前时间-上次刷新时间)* 出水率
    long currentWater = Math.max(0, currentWater - outWater); // 当前水量 = 之前的桶内水量-流出的水量
    refreshTime = currentTime; // 刷新时间

    // 当前剩余水量还是小于桶的容量，则请求放行
    if (currentWater < capacity) {
        currentWater++;
        return true;
    }
    
    // 当前剩余水量大于等于桶的容量，限流
    return false;
}

问题：面对突发流量的时候，漏桶算法还是循规蹈矩地处理请求，例如：qps=2时，同时有2个请求过来就会被拒绝1个，因为水漏出1个需要500ms，500ms后才能处理第2个请求。流量变突发时，我们肯定希望系统尽量快点处理请求，提升用户体验嘛。

令牌算法

有一个令牌管理员，根据限流大小，定速往令牌桶里放令牌。如果令牌数量满了，超过令牌桶容量的限制，那就丢弃。系统在接受到一个用户请求时，都会先去令牌桶要一个令牌。如果拿到令牌，那么就处理这个请求的业务逻辑；如果拿不到令牌，就直接拒绝这个请求。

/**
 * 每秒处理数（放入令牌数量）
 */
private long putTokenRate;

/**
 * 最后刷新时间
 */
private long refreshTime;

/**
 * 令牌桶容量
 */
private long capacity;

/**
 * 当前桶内令牌数
 */
private long currentToken = 0L;

/**
 * 漏桶算法
 * @return
 */
public synchronized boolean tokenBucketTryAcquire() {
    long currentTime = System.currentTimeMillis();  //获取系统当前时间
    long generateToken = (currentTime - refreshTime) / 1000 * putTokenRate; //生成的令牌 =(当前时间-上次刷新时间)* 放入令牌的速率
    currentToken = Math.min(capacity, generateToken + currentToken); // 当前令牌数量 = 之前的桶内令牌数量+放入的令牌数量
    refreshTime = currentTime; // 刷新时间
    
    //桶里面还有令牌，请求正常处理
    if (currentToken > 0) {
        currentToken--; //令牌数量-1
        return true;
    }
    
    return false;
}

当qps=2突发的2个请求过来都能拿到桶里的2个令牌，请求都可以得到处理。

滑动日志

更精确的限流，但是要记录一定时间内的每次请求

/**
 * 每分钟限制请求数
 */
private static final long PERMITS_PER_MINUTE = 60;
/**
 * 请求日志计数器, k-为请求的时间（秒），value当前时间的请求数量
 */
private final TreeMap<Long, Integer> requestLogCountMap = new TreeMap<>();

@Override
public synchronized boolean tryAcquire() {
    // 最小时间粒度为s
    long currentTimestamp = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC);
    // 获取当前窗口的请求总数
    int currentWindowCount = getCurrentWindowCount(currentTimestamp);
    if (currentWindowCount >= PERMITS_PER_MINUTE) {
        return false;
    }
    // 请求成功，将当前请求日志加入到日志中
    requestLogCountMap.merge(currentTimestamp, 1, Integer::sum);
    return true;
}

/**
 * 统计当前时间窗口内的请求数
 *
 * @param currentTime 当前时间
 * @return -
 */
private int getCurrentWindowCount(long currentTime) {
    // 计算出窗口的开始位置时间
    long startTime = currentTime - 59;
    // 遍历当前存储的计数器，删除无效的子窗口计数器，并累加当前窗口中的所有计数器之和
    return requestLogCountMap.entrySet()
            .stream()
            .filter(entry -> entry.getKey() >= startTime)
            .mapToInt(Map.Entry::getValue)
            .sum();
}