Java常见的限流算法

1、限流算法简介

在分布式系统中，高并发场景下，为了防止系统因突然的流量激增而导致的崩溃，同时保证服务的高可用性和稳定性，限流是最常用的手段。常见的限流算法主要有：固定窗口算法、滑动窗口算法、漏桶算法、令牌桶算法。

2、固定窗口算法

固定窗口限流算法，也叫计数器限流算法，是最简单的一种限流算法。主要原理是：通过设定一个固定大小的时间窗口，在该时间窗口内允许通过的请求数量。每个请求进来都会在计数器上加一，当计数器达到设定的阈值时，请求会被拒绝。当超过设置的时间，计数器会重置为0。

public class FixWindowLimiter {
    /**
     * 每秒限制请求数
     */
    private final long perSecondLimit = 50;
    /**
     * 上一个窗口的开始时间
     */
    public long preStartTime = System.currentTimeMillis();
    /**
     * 计数器
     */
    private int counter;
 
    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        // 假设窗口时间位1秒，在窗口期内判断计数器是否超过限制的请求数
        if (now - preStartTime < 1000) {
        	// 计数器小于限制数时放行，否则拒绝请求
            if (counter < perSecondLimit) {
                counter++;
                return true;
            } else {
                return false;
            }
        }
        // 时间窗口过期，重置计数器和时间戳
        counter = 0;
        preStartTime = now;
        return true;
    }
}

优点：

• 实现简单，容易理解。
• 适用于突发流量较小的场景。

缺点：

• 无法处理时间窗口的临界突变问题。
• 对于高并发场景，难以保证系统稳定性。
• 无法实现更加精细的限流控制。

3、滑动窗口算法

滑动窗口算法相当于对固定窗口算法的一种改进。在滑动窗口算法中，将固定窗口算法中的固定时间窗口继续划分为若干个固定大小的窗口，并统计每个窗口内的请求次数。当某个窗口内的请求次数超过设定的阈值时，请求会被拒绝。滑动窗口算法可以根据业务需求灵活调整窗口的大小和时间间隔，实现更加精细的限流控制。

public class SlidingWindowLimiter {
    // 固定时间窗口大小，单位毫秒
    private long windowSize;
    // 固定窗口拆分的小窗口数
    private int windowNum;
    // 每个窗口允许通过最大请求数
    private int maxRequestCount;
    // 各个窗口内请求计数
    private int[] perWindowCount;
    // 请求总数
    private int totalCount;
    // 当前窗口下标
    private int windowId;
    // 每个小窗口大小，毫秒
    private long perWindowSize;
    // 窗口右边界
    private long windowRightBorder;
    
    /**
     * 构造函数
     * 
     * @param windowSize 固定时间窗口大小
     * @param windowNum 固定窗口拆分的小窗口数
     * @param maxRequestCount  每个窗口允许通过最大请求数
     */
    public SlidingWindowLimiter(long windowSize, int windowNum, int maxRequestCount) {
        this.windowSize = windowSize;
        this.windowNum = windowNum;
        this.maxRequestCount = maxRequestCount;
        perWindowCount = new int[windowNum];
        perWindowSize = windowSize / windowNum;
        windowRightBorder = System.currentTimeMillis();
    }
    
    /**
     * 限流方法
     * @return
     */
    public synchronized boolean tryAcquire() {
        long currentTime = System.currentTimeMillis();
        if (currentTime > windowRightBorder){
            do {
                windowId = (++windowId) % windowNum;
                totalCount -= perWindowCount[windowId];
                perWindowCount[windowId]=0;
                windowRightBorder += perWindowSize;
            }while (windowRightBorder < currentTime);
        }
        if (totalCount < maxRequestCount){
            System.out.println("tryAcquire success,{}"+windowId);
            perWindowCount[windowId]++;
            totalCount++;
            return true;
        }else{
            System.out.println("tryAcquire fail,{}"+windowId);
            return false;
        }
    }
	
	/**
     * 测试方法
     * @param args
     * @throws InterruptedException
     */
	public static void main(String[] args) throws InterruptedException {
        SlidingWindowLimiter slidingWindowLimiter = new SlidingWindowLimiter(1000, 10, 10);
        TimeUnit.MILLISECONDS.sleep(800);
        for (int i = 0; i < 15; i++) {
            boolean acquire = slidingWindowLimiter.tryAcquire();
            if (acquire){
                System.out.println("执行任务");
            }else{
                System.out.println("被限流");
            }
            TimeUnit.MILLISECONDS.sleep(10);
        }
    }
}

优点：

• 可以根据业务需求灵活调整窗口的大小和时间间隔，实现更加精细的限流控制。
• 解决了固定窗口算法的窗口边界问题，避免突发流量压垮服务器。

缺点：

• 窗口的大小和时间间隔需要根据具体业务场景进行调整，实现较为复杂。
• 需要统计窗口内的请求次数，计算较为复杂。

4、漏桶算法

漏桶算法是一种基于固定速率的流量控制算法。在漏桶算法中，请求像水一样不断地注入漏桶，而漏桶会按照固定的速率将水漏掉。如果注入的速率持续大于漏出的速率，则会出现限流的效果。漏桶算法可以限制请求的速率，并且可以防止出现过载的情况。如果入口流量过大，漏桶可能会溢出，导致数据丢失。

public class LeakyBucketLimiter {
    /**
     * 桶的最大容量
     */
    public long capacity = 10;
    /**
     * 桶内当前水量
     */
    public long count = 0;
    /**
     * 漏水速率（每秒5次）
     */
    public long rate = 5;
    /**
     * 上次漏水时间
     */
    public static long lastLeakTime = System.currentTimeMillis();

    /**
     * 限流方法，返回true表示通过
     */
    public synchronized boolean tryAcquire() {
        // 调用漏水方法
        this.leak();
        // 判断是否超过最大请求数量
        if (count < capacity) {
            count++;
            return true;
        }
        return false;
    }

    /**
     * 漏水方法，计算并更新这段时间内漏水量
     */
    private void leak() {
        // 获取系统当前时间
        long currentTime = System.currentTimeMillis();
        // 计算这段时间内，需要流出的水量
        long leakWater = (currentTime - lastLeakTime) * rate / 1000;
        count = Math.max(count - leakWater, 0);
        lastLeakTime = currentTime;
    }
}

优点：

• 可以限制请求的速率，并且不会出现过载的情况。
• 可以实现较为精细的限流控制。

缺点：

• 如果入口流量过大，超过了桶的容量，那么就需要丢弃部分请求。
• 由于速率是固定的，即使下游能够处理更大的流量，漏桶也不允许突发流量通过。

5、令牌桶算法

令牌桶算法是一种基于令牌的流量控制算法。在令牌桶算法中，系统会向令牌桶中不断添加令牌，每个请求会消耗掉一个令牌，如果令牌桶中没有足够的令牌，则请求会被拒绝。令牌桶算法可以限制请求的速率，同时不会出现过载的情况。

public class TokenBucketRateLimiter {
    /**
     * 桶的最大容量
     */
    public long capacity = 10;
    /**
     * 桶内当前的令牌数量
     */
    public long count = 0;
    /**
     * 令牌生成速率（每秒5次）
     */
    public long tokenRate = 5;
    /**
     * 上次生成令牌的时间
     */
    public long lastGenerateTime = System.currentTimeMillis();

    /**
     * 限流方法，返回true表示通过
     */
    public boolean limit() {
        // 调用生成令牌方法
        this.generateTokens();
        // 判断桶内是否还有令牌
        if (count > 0) {
            count--;
            return true;
        }
        return false;
    }

    /**
     * 生成令牌方法，计算并更新这段时间内生成的令牌数量
     */
    private void generateTokens() {
        long currentTime = System.currentTimeMillis();
        // 计算这段时间内，需要生成的令牌数量
        long tokens = (currentTime - lastGenerateTime) * tokenRate / 1000;
        count = Math.min(count + tokens, capacity);
        lastGenerateTime = currentTime;
    }
}

优点：

• 令牌桶算法可以处理突发流量。当桶满时，能够以最大速度处理请求。
• 与漏桶算法相比，令牌桶算法提供了更大的灵活性。

缺点：

• 需要维护令牌桶和令牌生成速度等状态信息，实现较为复杂。
• 当令牌桶溢出时，会导致请求被拒绝，影响用户体验。