深入理解限流算法：从固定窗口到分布式限流-优快云博客

本文介绍了常见的限流算法，包括固定窗口、滑动窗口、漏斗算法、令牌桶和滑动日志限流，详细讨论了各自的优缺点。在分布式限流场景中，提到了使用Redis的zset和list数据结构来实现。通过对各种算法的分析，有助于选择适合的限流策略。

文章目录

常见限流算法
分布式限流

常见限流算法

固定窗口
滑动窗口
漏斗算法
令牌桶
滑动日志
分布式限流

固定窗口

固定窗口限流算法，是维护一个时间窗口和一个计数器，在这个时间窗口内，请求数达到一定的限制后，则不再接受请求，若检测到超过窗口时间，则将计数器置为0
具体实现代码如下

public class FixWindow implements LimitingAlgorithm {

    // 窗口时间，单位为ms
    private long windowSize;
    // 窗口时间内次数
    private long limit;
    // 当前窗口次数
    private long count;
    // 上一窗口的开始时间
    private long lastWindowStartTime = System.currentTimeMillis();

    public FixWindow(long windowSize, long limit) {
        this.windowSize = windowSize;
        this.limit = limit;
    }

    @Override
    public synchronized boolean tryAcquire() {
        System.out.println(count);
        long now = System.currentTimeMillis();
        if (now - lastWindowStartTime < windowSize) {
            // 在窗口期间内
            if (count < limit) {
                count++;
                return true;
            } else {
                return false;
            }

        }
        count = 1;
        lastWindowStartTime = now;
        return true;
    }
    
}

优点：易于实现，内存占用小
缺点：有临界问题，可能在两个窗口变更的交接处，流量瞬间达到2n

滑动窗口

滑动窗口是固定窗口的优化版本，可以将窗口细化，流量控制更精准
代码实现如下：

public class SlideWindow implements LimitingAlgorithm {


    // 滑动窗口的时间宽度，单位为ms
    private long windowSize;
    // 单个窗口时间内次数
    private long limit;

    private final TreeMap<Long, Integer> counters;

    public SlideWindow(long windowSize, long limit) {
        this.windowSize = windowSize;
        this.limit = limit;
        this.counters = new TreeMap<>();
    }

    @Override
    public synchronized boolean tryAcquire() {

        long now = System.currentTimeMillis();

        int currentWindowCount = getCurrentWindowCount(now);

        System.out.println(currentWindowCount);

        if (currentWindowCount >= limit) {
            return false;
        }
        // 计数器+1
        counters.merge(now, 1, Integer::sum);

        return true;
    }

    /**
     * 获取窗口中的所有请求数，并删除所有无效的子窗口计数器
     *
     * @return
     */
    private int getCurrentWindowCount(long currentWindowTime) {

        long windowStartTime = currentWindowTime - windowSize;
        int result = 0;

        // 遍历当前存储的计数器，删除无效的子窗口计数器，并累加当前窗口中的所有计数器之和
        Iterator<Map.Entry<Long, Integer>> iterator = counters.entrySet().iterator();

        while (iterator.hasNext()) {
            Map.Entry<Long, Integer> entry = iterator.next();
            if (entry.getKey() < windowStartTime) {
                iterator.remove();
            } else {
                result += entry.getValue();
            }
        }
        return result;

    }
}

优点：流量控制更精准
缺点：占用内存较大，需要清除旧数据，耗费性能，当窗口中流量达到阀值时，流量会瞬间切断

漏斗算法

顾名思义，漏斗算法，是以稳定的速率放行，当注入速度持续大于漏出速度时，漏斗变满，此时新进入的请求将会被丢弃。限流和流量整形是漏斗算法的核心能力

基本代码实现如下：

public class LeakyBucket implements LimitingAlgorithm {

    // 桶的容量
    private final int capacity;

    // 单位时间漏出速率
    private final int limit;
    
    // 时间单位 ms
    private final int limitUnit;

    // 剩余水量
    private long leftWater;

    // 上次注入时间
    private long refreshTime = System.currentTimeMillis();

    public LeakyBucket(int capacity, int limit, int limitUnit) {
        this.capacity = capacity;
        this.limit = limit;
        this.limitUnit = limitUnit;
    }

    @Override
    public synchronized boolean tryAcquire() {

        // 计算剩余水量
        long now = System.currentTimeMillis();

        long timeGapUnit = (now - refreshTime) / limitUnit;

        leftWater = Math.max(0, leftWater - timeGapUnit * limit);

        refreshTime = now;

        if (leftWater < capacity) {
            leftWater++;
            return true;
        }

        return false;
    }
}

优点：漏斗算法可以用来平滑突发流量，保证系统不被突发流量压垮。
缺点：漏斗算法对流量控制过于严格，不利于流量伸缩

令牌桶

令牌桶算法具有以下特点：

以恒定的速率发放令牌，每过一定的单位时间，添加一定的令牌
假设令牌桶的容量是b，如果令牌桶已满，则新的令牌会被丢弃
请求能够通过限流器的前提是令牌桶中有令牌

实现代码如下：

public class TokenBucket implements LimitingAlgorithm {

    /**
     * 令牌桶的容量「限流器允许的最大突发流量」
     */
    private final long capacity;
    /**
     * 单位令牌发放速率
     */
    private final long limit;

    /**
     * 单位时间
     */
    private final long limitUnit;

    /**
     * 最后一个令牌发放的时间
     */
    long lastTokenTime = System.currentTimeMillis();
    /**
     * 当前令牌数量
     */
    private long currentTokens;


    public TokenBucket(long capacity, long limit, long limitUnit) {
        this.capacity = capacity;
        this.limit = limit;
        this.limitUnit = limitUnit;
    }

    @Override
    public boolean tryAcquire() {

        long now = System.currentTimeMillis();
        if (now - lastTokenTime >= limitUnit) {
            long newPermits = (now - lastTokenTime) / limitUnit * limit;
            currentTokens = Math.min(capacity, currentTokens + newPermits);
            lastTokenTime = now;
        }
        if (currentTokens > 0) {
            currentTokens--;
            return true;
        }
        return false;
    }
}

优点：有一定提示突发流量处理能力，并且能够以恒定的速率增加令牌，是漏斗算法的一种优化
缺点：暂时没想到

滑动日志限流

通过统计日志请求的打印，来检测单位时间的请求数，从而来控制限流，可以实现自己想要的限流策略，实现较复杂

总结

漏斗和令牌桶比较适合阻塞式的限流场景，不给通行就等着
时间窗口比较适合对时间敏感的限流场景，不行就返回，稍后再试

分布式限流

可以采用中间价redis或者nginx来实现分布式限流。

redis的zset数据结构可以起到类似前面用到的Treemap的作用，实现一个分布式的滑动窗口限流，利用ZREMRANGEBYSCORE删除滑动窗口之外的数据，再用ZCARD计数
redis的list数据结构也可以实现令牌桶算法，利用list获取数据的阻塞功能，但由于利用中间件每次请求都需要与中间件有交互，会有一定的性能损耗，所以可以考虑批量的思想，一次获取多个令牌，但也会有一定的流量处理误差，实际情况中，还是根据自己的模拟测试来调整