【优雅代码】17-guava限流源码解析

欢迎关注b站账号/公众号【六边形战士夏宁】，一个要把各项指标拉满的男人。该文章已在github目录收录。
屏幕前的大帅比和大漂亮如果有帮助到你的话请顺手点个赞、加个收藏这对我真的很重要。别下次一定了，都不关注上哪下次一定。

• 可直接运行的完整代码
• 上一篇guava布隆过滤与限流算法源码解析
• 下一篇利用function实现list、tree互转工具

1.背景

承接前一篇章的guava精选方法

2.限流

这部分和其它限流算法的令牌桶算法基本一致

2.1使用

@SneakyThrows
public static void rate() {
    // 这里直接设置的就QPS(每秒查询率)
    RateLimiter rateLimiter = RateLimiter.create(1);
    while (true){
        System.out.println(rateLimiter.tryAcquire());
        Thread.sleep(300);
    }
}

true
false
false
false
true

2.2核心源码

1. 构造方法

// 主流程方法,保留了部分说明注释，这里创建了一个计时器后面用于计算时间的
public static RateLimiter create(double permitsPerSecond) {
    /*
     *
     * T0 at 0 seconds
     * T1 at 1.05 seconds
     * T2 at 2 seconds
     * T3 at 3 seconds
     *
     * Due to the slight delay of T1, T2 would have to sleep till 2.05 seconds, and T3 would also
     * have to sleep till 3.05 seconds.
     */
    return create(permitsPerSecond, SleepingStopwatch.createFromSystemTimer());
  }
// 继续主流程往下走，然后默认构造了平均的令牌桶限流策略
static RateLimiter create(double permitsPerSecond, SleepingStopwatch stopwatch) {
    RateLimiter rateLimiter = new SmoothBursty(stopwatch, 1.0 /* maxBurstSeconds */);
    // 该方法标记为主流程方法2，设置速率，非常重要的方法
    rateLimiter.setRate(permitsPerSecond);
    return rateLimiter;
  }
// 该方法标记为主流程方法2
public final void setRate(double permitsPerSecond) {
    synchronized (mutex()) {
        // 标记为方法主流程方法3，后面那个参数就是获取当前时间的
      doSetRate(permitsPerSecond, stopwatch.readMicros());
    }
  }
// 该标记为方法主流程方法3,注意会有多个doSetRate，但是传参不一样
final void doSetRate(double permitsPerSecond, long nowMicros) {
    // 用于刷新当前令牌数，在构造方法不重要，获取令牌时会再次调用
    resync(nowMicros);
    // ****中间这个赋值很重要***，其它地方会在调用这个结果，这里本身传入的是QPS
    // 即原先为每秒可以获取X个令牌，通过下列公式获得，每微妙可获得的令牌数,也可以从字面意思理解，获得令牌的微秒间隔
    double stableIntervalMicros = SECONDS.toMicros(1L) / permitsPerSecond;
    this.stableIntervalMicros = stableIntervalMicros;
    // 下面这个方法不重要
    doSetRate(permitsPerSecond, stableIntervalMicros);
  }

1. 获取令牌

public boolean tryAcquire() {
    // 直接不等待，走快速失败的逻辑
    return tryAcquire(1, 0, MICROSECONDS);
  }

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();
          // 计算有没有可用令牌，根据nextFreeTicketMicros
      if (!canAcquire(nowMicros, timeoutMicros)) {
        return false;
      } else {
          // 获取令牌并返回等待时间为0，进入该方法，主流程2
        microsToWait = reserveAndGetWaitLength(permits, nowMicros);
      }
    }
    stopwatch.sleepMicrosUninterruptibly(microsToWait);
    return true;
  }
 // 主流程2从上一步进入
final long reserveAndGetWaitLength(int permits, long nowMicros) {
    // 进入该方法，主流程3
    long momentAvailable = reserveEarliestAvailable(permits, nowMicros);
    // 因为now就是最大的，所以max是0
    return max(momentAvailable - nowMicros, 0);
  }
 // 主流程3从上一步进入。这里涉及令牌桶的核心算法
@Override
  final long reserveEarliestAvailable(int requiredPermits, long nowMicros) {
      // 主流程4
    resync(nowMicros);
    long returnValue = nextFreeTicketMicros;
    // 返回要消耗掉的令牌数，这里需要先看主流程4的逻辑，如果够消耗则返回1，不够消耗只有零点几
    double storedPermitsToSpend = min(requiredPermits, this.storedPermits);
    // 这里有两种情况，如果令牌有余额，则1-1=0，如果令牌不足则获得一个小于1的数
    double freshPermits = requiredPermits - storedPermitsToSpend;
    // 这里左边固定是0，就不贴源码了
    // 根据上面的情况，这里有可能是0即有余令牌，那么再往下走两行，下次刷新时间则不动。如果小于1则令牌不够，将差额和间隔进行相乘获得还需要下个令牌的时间
    long waitMicros =
        storedPermitsToWaitTime(this.storedPermits, storedPermitsToSpend)
            + (long) (freshPermits * stableIntervalMicros);
     // 这里赋值下次的时间，其实就是把两个参数加起来，然后就得到了下次的时间，这也是为什么示例中的2.05的下次就是3.05
    this.nextFreeTicketMicros = LongMath.saturatedAdd(nextFreeTicketMicros, waitMicros);
    // 这里减掉消耗掉的令牌数
    this.storedPermits -= storedPermitsToSpend;
    return returnValue;
  }

// 主流程4
 void resync(long nowMicros) {
    // if nextFreeTicket is in the past, resync to now
    // 如果当前时间大于下次获取时间则进入，正常情况是一定大于的，否则就没有多余的令牌可以发
    if (nowMicros > nextFreeTicketMicros) {
        // coolDownIntervalMicros()这个就是返回stableIntervalMicros
        // 前面存的这玩意儿现在再除回去进行还原，即可以获得的令牌数,注意这里是可以返回零点几的
      double newPermits = (nowMicros - nextFreeTicketMicros) / coolDownIntervalMicros();
      // 相加得到现在的令牌数，根据上一行，这里通常是几点几
      storedPermits = min(maxPermits, storedPermits + newPermits);
      // 标记获取令牌时间
      nextFreeTicketMicros = nowMicros;
    }
  }