【guava系列】RateLimiter之SmoothBursty

使用方式

import java.util.concurrent.TimeUnit;

/**
 * @author woniu
 * @date 2022/6/1 21:44
 **/
public class TestRateLimiter {

    public static void main(String[] args) throws InterruptedException {
        // 其中5为设定的每秒许可证的数量
        RateLimiter rateLimiter = RateLimiter.create(5);
        // 不会产生阻塞
        System.out.println(rateLimiter.acquire(4));
        // 会产生月0.8s左右的阻塞时长
        System.out.println(rateLimiter.acquire(10));
        // 会产生约2s左右的阻塞时长
        System.out.println(rateLimiter.acquire(1));
    }
}

解释一下该限流器–平滑突发。平滑何解？突发又有所指？
关于平滑，是因为有固定的速率来产生许可证，不会忽高忽低。
关于突发，就是上边例子中注释显示的，会有阻塞时长。可以应对突发，但是要后继偿还（个人对该实现持保留意见，并不认为这种不设上线的突发是一个好的设计，如果有一个rateLimiter.acquire(10000)，是不是就会导致下次等待2000s，等待是小事，如果过多的流量将应用搞垮了，得不偿失）。

核心参数

学会了用，接下来看看轮子是怎么造的。
RateLimiter中的关于构造一个SmoothBursty，其实就是设置了一个计时器，和流速。

  static RateLimiter create(double permitsPerSecond, SleepingStopwatch stopwatch) {
    // 设置计时器以及最大的突发时长
    RateLimiter rateLimiter = new SmoothBursty(stopwatch, 1.0 /* maxBurstSeconds */);
    // 设置每秒的许可证数量
    rateLimiter.setRate(permitsPerSecond);
    return rateLimiter;
  }

设置流速com.google.common.util.concurrent.RateLimiter#setRate

  public final void setRate(double permitsPerSecond) {
    checkArgument(
        permitsPerSecond > 0.0 && !Double.isNaN(permitsPerSecond), "rate must be positive");
    // 加锁，但是关于mutex()方法尽然是个单例，代码写的如此之严谨
    synchronized (mutex()) {
      // 具体实现由子类实现。这就是一个模板模式
      doSetRate(permitsPerSecond, stopwatch.readMicros());
    }
  }

接下来看下com.google.common.util.concurrent.SmoothRateLimiter#doSetRate(double, long)的具体实现。

  final void doSetRate(double permitsPerSecond, long nowMicros) {
    resync(nowMicros);
    // 计算每个许可证的时间间隔，如每秒5个，那么这个值就是200
    double stableIntervalMicros = SECONDS.toMicros(1L) / permitsPerSecond;
    this.stableIntervalMicros = stableIntervalMicros;
    doSetRate(permitsPerSecond, stableIntervalMicros);
  }

com.google.common.util.concurrent.SmoothRateLimiter.SmoothBursty#doSetRate

    void doSetRate(double permitsPerSecond, double stableIntervalMicros) {
      // 这里没有设置对应的maxPermits，所以该值为0
      double oldMaxPermits = this.maxPermits;
      // 计算突发时，可以承载的最大许可证数量
      maxPermits = maxBurstSeconds * permitsPerSecond;
      // 如果原来的突发量是正数，则更新
      if (oldMaxPermits == Double.POSITIVE_INFINITY) {
        // if we don't special-case this, we would get storedPermits == NaN, below
        storedPermits = maxPermits;
      } else {
        // 三元判断，这个值会为0
        storedPermits =
            (oldMaxPermits == 0.0)
                ? 0.0 // initial state
                : storedPermits * maxPermits / oldMaxPermits;
      }
    }

这样一个SmoothBursty对象初始化完成以及设置了当前的对象所需的全部信息。

• maxPermits 最大许可证，与permitsPerSecond一致
• storedPermits 当前的存储许可证数量，初始值为0
• stableIntervalMicros 产生一个许可证的时间间隔，1/permitsPerSecond

申请许可证

有两种方式，一种尝试申请(tryAcquire)，一种阻塞式申请(acquire)。我们分别来看其中的实现。首先看阻塞式申请。

  public double acquire(int permits) {
    // 计算申请这些许可证的耗时
    long microsToWait = reserve(permits);
    // 等待，这次的等待并不是针对于此次的申请，而是针对于上一次，如果上一次申请已经消耗了未来的许可证，那么此次就要等待补充完成后，才会释放新的许可证。也就是仅允许一次突发，且需要后续的补偿回来。
    stopwatch.sleepMicrosUninterruptibly(microsToWait);
    // 返回此次等待的时长。
    return 1.0 * microsToWait / SECONDS.toMicros(1L);
  }

中间的流程不看了，也是一个模板模式，具体实现仍然看具体子类。其中，com.google.common.util.concurrent.SmoothRateLimiter#reserveEarliestAvailable的具体实现

  final long reserveEarliestAvailable(int requiredPermits, long nowMicros) {
    // 重新设置当前的许可证相关信息
    resync(nowMicros);
    long returnValue = nextFreeTicketMicros;
    // 当前需要用掉的通行许可证
    double storedPermitsToSpend = min(requiredPermits, this.storedPermits);
    // 仍需要新的许可证数量, 不会出现负数，最差是个0
    double freshPermits = requiredPermits - storedPermitsToSpend;
    long waitMicros =
            // 该值为0
        storedPermitsToWaitTime(this.storedPermits, storedPermitsToSpend)
                // 计算出新的许可证需要的时长
            + (long) (freshPermits * stableIntervalMicros);

    // 计算出下次可以申请的时间
    this.nextFreeTicketMicros = LongMath.saturatedAdd(nextFreeTicketMicros, waitMicros);
    this.storedPermits -= storedPermitsToSpend;
    return returnValue;
  }

这样就完成了当前许可证的申请，甚至可以预先申请一批许可证。
接下来我们看待超时时间的尝试申请方式。

  public boolean tryAcquire(int permits, long timeout, TimeUnit unit) {
    long timeoutMicros = max(unit.toMicros(timeout), 0);
    checkPermits(permits);
    long microsToWait;
    synchronized (mutex()) {
      // 获取当前的时间，这个时间并发系统时间，而是距离启动时的时间差，这样会将数字变小，这个设计也很不错。
      long nowMicros = stopwatch.readMicros();
      // 计算在超时时间内，是否可以完成申请，如果不可以直接返回FALSE。
      // 举个例子，比如说下次可申请时间为5，当前时间为1, 超时时间为1，那么此次申请就是无效的，没有必要等待了。
      if (!canAcquire(nowMicros, timeoutMicros)) {
        return false;
      } else {
        // 仍然具体例子，下次申请时间为5，当前时间为4，超时时间为1，那么此次申请就是有效的，因为，在1s超时时，就可以进行新的许可证申请了。
        microsToWait = reserveAndGetWaitLength(permits, nowMicros);
      }
    }
    // 这里停顿的时间，就是1s
    stopwatch.sleepMicrosUninterruptibly(microsToWait);
    return true;
  }

其他逻辑与原理的阻塞式申请无异。这里仅是避免了无效的时间等待。

总结

优势：

• 可应对突然流量
• 流量均衡

劣势：

• 对应对突发流量没有做上限控制