限流系列：guava rateLimiter

目录

令牌桶算法

Guava-RateLimiter

数据模型

示例

大致流程

acquire

reserve

​​​​​​​reserveAndGetWaitLength

​​​​​​​reserveEarliestAvailable

​​​​​​​resync

​​​​​​​doSetRate

---

令牌桶 算法

令牌桶算法就是以固定速率生成令牌放入桶中，每个请求都需要从桶中获取令牌，没有获取到令牌的请求会被阻塞限流（桶中的令牌不够的时候）；只要能从桶里取出令牌就能通过。

当令牌消耗速度小于生成的速度时，令牌桶内就会预存这些未消耗的令牌（直到桶的上限）；当有突发流量进来时，可以直接从桶中取出令牌，而不会被限流，从而支持突发流量的快速处理。

Guava - RateLimiter

不管是令牌桶算法还是漏桶算法都可以用延迟计算的方式来实现，延迟计算指的是不需要单独的线程来定时生成令牌或者从漏桶中定时取出请求，而是由调用限流器的线程自己去计算是否有足够的令牌以及需要sleep的时间，延迟计算的方式可以节省一个线程资源。

Guava 的 RateLimiter 是一个用于控制访问速率的工具类，常用于限流（如每秒处理请求的数量）。它基于令牌桶算法实现。

​​​​​​​数据模型

|------------------|--------------|---------------------------------------------------------|
| 英文名称 | 中文名称 | 备注 |
| permitsPerSecond | 每秒允许许可数量 | |
| | 桶容量 | maxBurstSeconds * permitsPerSecond默认 maxBurstSeconds=1 |

示例

|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| // 创建一个每秒允许 10 个许可的 RateLimiter RateLimiter rateLimiter = RateLimiter.create(10.0); for (int i = 0; i < 10; i++) { // 获取一个许可，如果没有可用许可，则会阻塞直到有许可 rateLimiter.acquire(); // 执行受控操作 log.info("Processing request " + i); } |

大致流程

点击示例里的acquire()方法，如下所示：

​​​​​​​acquire

@CanIgnoreReturnValue

public double acquire() {

return acquire(1);

}

@CanIgnoreReturnValue

public double acquire(int permits) {

long microsToWait = reserve(permits);

stopwatch.sleepMicrosUninterruptibly(microsToWait);

return 1.0 * microsToWait / SECONDS.toMicros(1L);

}

点击reserve()方法，如下所示：

​​​​​​​reserve

final long reserve(int permits) {

checkPermits(permits);

synchronized (mutex()) {

return reserveAndGetWaitLength(permits, stopwatch.readMicros());

}

}

在这里，计算当前时间的微秒数，作为参数调用reserveAndGetWaitLength方法。

如下所示：

​​​​​​​reserveAndGetWaitLength

final long reserveAndGetWaitLength(int permits, long nowMicros) {

long momentAvailable = reserveEarliestAvailable(permits, nowMicros);

return max(momentAvailable - nowMicros, 0);

}

点击reserveEarliestAvailable()方法，如下所示：

​​​​​​​reserveEarliestAvailable

@Override

final long reserveEarliestAvailable(int requiredPermits, long nowMicros) {

resync(nowMicros);

long returnValue = nextFreeTicketMicros;

double storedPermitsToSpend = min(requiredPermits, this.storedPermits);

double freshPermits = requiredPermits - storedPermitsToSpend;

long waitMicros =

storedPermitsToWaitTime(this.storedPermits, storedPermitsToSpend)

• (long) (freshPermits * stableIntervalMicros);

this.nextFreeTicketMicros = LongMath.saturatedAdd(nextFreeTicketMicros, waitMicros);

this.storedPermits -= storedPermitsToSpend;

return returnValue;

}

点击resync()方法，如下所示：

​​​​​​​resync

void resync(long nowMicros) {

// if nextFreeTicket is in the past, resync to now

if (nowMicros > nextFreeTicketMicros) {

double newPermits = (nowMicros - nextFreeTicketMicros) / coolDownIntervalMicros();

storedPermits = min(maxPermits, storedPermits + newPermits);

nextFreeTicketMicros = nowMicros;

}

}

在这里：

1. 判断当前时刻是否大小上次令牌更新时间，是则进入下一步（这是与resilience4j-ratelimiter差别最大的地方）
2. 计算上次令牌更新时间到当前时刻的时间差（微秒）
3. 获取生成单个令牌所需的时间间隔（微秒/令牌）
4. 计算上次令牌更新时间到当前时刻的时间差这段时间内允许生成的令牌数量，即步骤1除以步骤2。

点击coolDownIntervalMicros()方法，如下所示：

​​​​​​​coolDownIntervalMicros

double coolDownIntervalMicros() {

return stableIntervalMicros;

}

找到stableIntervalMicros变更赋值的地方，如下所示：

​​​​​​​doSetRate

final void doSetRate(double permitsPerSecond, long nowMicros) {

resync(nowMicros);

double stableIntervalMicros = SECONDS.toMicros(1L) / permitsPerSecond;

this.stableIntervalMicros = stableIntervalMicros;

doSetRate(permitsPerSecond, stableIntervalMicros);

}

在这里，将SECONDS.toMicros(1L) / permitsPerSecond得到生成单个令牌所需的时间。