限流算法：漏桶算法与令牌桶算法

限流算法：漏桶算法与令牌桶算法

限流

何为限流？

顾名思义：即对请求或者并发数进行限制。如果我们的服务资源有限、处理能力有限，那么就需要对调用服务的调用方进行流量限制，以防止自身服务由于资源耗尽造成服务崩溃等问题的发生。

常见的限流算法有很多种：

1. 固定窗口算法
2. 滑动窗口算法
3. 漏桶算法
4. 令牌桶算法

此篇文章中，主要对其中两种算法进行分析，分别是：漏桶算法和令牌桶算法。

这两种算法都可以对流量进行限制，而不同点是漏桶算法由于桶的大小是固定的，如果桶满了之后就没法再往里面注水，所以相应来说对请求速率的限制是恒定的，如果我们限制QPS固定是100，那么每秒最多就只会进入100个请求。而令牌桶算法虽然说也是用于限流控制，但是其原理是每秒钟向桶内投入一定量的令牌，当我们的请求进入时会先去桶中拿取令牌，拿到令牌的才可以继续执行。但是比如前一秒钟桶内令牌数量是100，但是只进入了50个请求，那么在下一秒开始的时候是不会清空桶中的令牌数量的，也就是说下一秒桶中的初始令牌数就是50。如果说下一秒放入令牌之前没有请求进入，那么会放入令牌至桶中令牌数达到100。但是如果在放入令牌时有请求进入，那么当前这一秒钟总共可放行的请求数就可能不止100。

对于具体选择哪种限流算法，应当根据具体的业务场景进行选择。总的来说漏桶算法适合恒定限流的业务，而令牌桶算法适合在限流业务情况下，同时接受突发高流量的处理能力。

以下，对这两种算法进行具体分析。

漏桶算法（Leaky Bucket）

代码示例：

package com.springboot.cli.limiter;

/**
 * 漏桶算法
 *
 * @author liangtl
 * @Date 2024/8/11
 */
public class LeakyBucketLimiter {
    // 桶的容量
    private final int capacity;
    // 漏出速率（单位：秒）
    private final int permitsPerSecond;
    // 剩余水量
    private long leftWater;
    // 上次注入时间
    private long timeStamp;

    public LeakyBucketLimiter(int capacity, int permitsPerSecond) {
        this.capacity = capacity;
        this.permitsPerSecond = permitsPerSecond;
        this.leftWater = 0;
        this.timeStamp = System.currentTimeMillis();
    }

    public synchronized boolean tryAcquire(long amount) {
        // 计算该段时间之后的剩余水量
        long now = System.currentTimeMillis();
        long time = (now - timeStamp) / 1000;
        leftWater = Math.max(0, leftWater - permitsPerSecond * time);
        // 更新注水时间
        timeStamp = now;
        // 如果未满，则允许加水，更新注水时间
        if (leftWater + amount < capacity) {
            leftWater += amount;
            return true;
        }
        return false;
    }
}

令牌桶算法（TokenBucketLimiter）

代码示例：

package com.springboot.cli.limiter;

/**
 * 令牌桶算法
 *
 * @author liangtl
 * @Date 2024/8/11
 */
public class TokenBucketLimiter {
    // 桶的容量
    private final long capacity;
    // 当前令牌数量
    private long tokens;
    // 令牌生成速率（单位：s）
    private long refillRate;
    // 上次填充时间
    private long lastRefillTime;

    public TokenBucketLimiter(long capacity, long tokens) {
        this.capacity = capacity;
        this.tokens = tokens;
        this.refillRate = 0;
        this.lastRefillTime = System.currentTimeMillis();
    }

    public synchronized boolean tryAcquire(long amount) {
        // 计算该段时间内填充令牌
        long now = System.currentTimeMillis();
        long timestamp = (now - lastRefillTime) / 1000;
        long newTokens = refillRate * timestamp;

        // 如果令牌数大于0，在不超过桶容量的前提下添加到桶内
        if (newTokens > 0) {
            tokens = Math.min(capacity, newTokens);
            lastRefillTime = now;
        }

        if (tokens > amount) {
            tokens -= amount;
            return true;
        }
        return false;
    }
}

guava的RateLimiter限流

guava目前已有线程的基于令牌桶的限流工具类：RateLimiter

使用方法也非常简单，导入依赖：

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.1-jre</version>
</dependency>

方法介绍：

/**
 * 创建一个新的 RateLimiter 实例，允许每秒发放固定数量的令牌。
 * 例子：RateLimiter limiter = RateLimiter.create(5.0); // 每秒钟允许5个令牌
 */
public static RateLimiter create(double permitsPerSecond) {
    return create(permitsPerSecond, RateLimiter.SleepingStopwatch.createFromSystemTimer());
}

/**
 * 该方法会从 RateLimiter 中获取一个令牌，如果令牌不可用，它会阻塞等待直到令牌可用。
 * 返回获取该令牌所需的时间（单位为秒）。
 */
public double acquire(int permits) {
    long microsToWait = this.reserve(permits);
    this.stopwatch.sleepMicrosUninterruptibly(microsToWait);
    return 1.0D * (double)microsToWait / (double)TimeUnit.SECONDS.toMicros(1L);
}

/**
 * 尝试获取permits个令牌，最多等待 timeout 时间，如果未能在该时间内获取，则返回 false。
 */
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) {
    long timeoutMicros = Math.max(unit.toMicros(timeout), 0L);
    checkPermits(permits);
    long microsToWait;
    synchronized(this.mutex()) {
        long nowMicros = this.stopwatch.readMicros();
        if (!this.canAcquire(nowMicros, timeoutMicros)) {
            return false;
        }

        microsToWait = this.reserveAndGetWaitLength(permits, nowMicros);
    }

    this.stopwatch.sleepMicrosUninterruptibly(microsToWait);
    return true;
}

/**
 * 剩余的一些方法大家可以自行去源码中翻阅，这里只是简单举例了几个常用的
 */

缺陷

以上的算法都不适用于分布式环境，只能用于单机服务

如果要在分布式环境下达到限流效果，需要使用redis。