Guava RateLimiter限流源码解析

RateLimiter的设计思想

RateLimiter最大的特点是它可以以一个稳定的速率让线程通过。当线程过多的时候,它可以通过sleep使线程暂停,从而达到强制控制线程通过速度的目标。

控制QPS最简单的方法是可以通过保留上个线程通过的时间,从而可以计算下次请求通过时间。但是,这样RateLimiter只知道最后一个线程通过的时间。如果RateLimiter长时间没有使用,然后一个请求到达并通过,这时RateLimiter会立即忘记在过去很长时间中,RateLimiter并没有被充分利用,这会导致RateLimiter利用率不足。由于过去未充分利用RateLimiter,这可能意味着过剩的资源,RateLimiter应该加速一段时间,从而充分利用过剩的资源。

另一方面,过去资源未充分利用可能意味着它的缓存过期,在预热阶段发生很很消耗性能的操作,例如在Executors.newCachedThreadPool所创建的线程池中,线程超过1分钟未之后,就会被销毁,一个新的任务需要被执行时,需要重新创建线程。

RateLimiter通过记录下个线程可以获取到令牌的时间,从而达到控制线程通过速率的目的。

Guava中RateLimiter有两种实现SmoothBursty和SmoothWarmingUp,这里主要介绍SmoothBursty。

重要属性介绍

maxBurstSeconds:通过maxBurstSeconds来控制保存的令牌数量。如果一个RateLimiter是2QPS,maxBurstSeconds是10秒,这样,我们可以最多保存2*10=20个令牌。
storedPermits:当前令牌桶中令牌的个数。
maxPermits:令牌桶中做多存储令牌的数量。
stableIntervalMicros:生成令牌的时间间隔。例如,每秒可以生成5个令牌,那stableIntervalMicros是200。
nextFreeTickerMicros:生成下个令牌的时间。

RateLimiter的创建

在RateLimiter中,通过它的静态方法创建SmoothBursty

  public static RateLimiter create(double permitsPerSecond) {
    return create(permitsPerSecond, SleepingStopwatch.createFromSystemTimer());
  }
  @VisibleForTesting
  static RateLimiter create(double permitsPerSecond, SleepingStopwatch stopwatch) {
    RateLimiter rateLimiter = new SmoothBursty(stopwatch, 1.0 /* maxBurstSeconds */);
    rateLimiter.setRate(permitsPerSecond);
    return rateLimiter;
  }
    SmoothBursty(SleepingStopwatch stopwatch, double maxBurstSeconds) {
      super(stopwatch);
      this.maxBurstSeconds = maxBurstSeconds;
    }

stopwatch是控制有关时间和sleep线程的。
maxBurstSeconds是用来控制保存令牌的数量的。

  public final void setRate(double permitsPerSecond) {
    checkArgument(
        permitsPerSecond > 0.0 && !Double.isNaN(permitsPerSecond), "rate must be positive");
    synchronized (mutex()) {
      doSetRate(permitsPerSecond, stopwatch.readMicros());
    }
  }

mutex()通过双检查锁始终返回一个同一个单例对象,从而使方法doSetRate()的线程安全。
stopwatch.readMicros()读取了当前时间。

  @Override
  final void doSetRate(double permitsPerSecond, long nowMicros) {
    resync(nowMicros);
    double stableIntervalMicros = SECONDS.toMicros(1L) / permitsPerSecond;
    this.stableIntervalMicros = stableIntervalMicros;
    doSetRate(permitsPerSecond, stableIntervalMicros);
  }

resync方法主要用于同步RateLimiter中storedPermits和nextFreeTicketMicros.
stableIntervalMicros是生产一个令牌的所使用的时间,比如permitsPerSecond=0.5(每秒钟生产0.5个令牌),那生产一个令牌的时间是2秒(2000毫秒)。
doSetRate通过计算,计算出storedPermits和maxPermits的值。
以上方法导致最终的结果就是storedPermits=0,maxPermits=0,nextFreeTicketMicros是当前的时间。

  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;
    }
  }

当RateLimiter初始化的时候,nextFreeTicketMicros=0。coolDownIntervalMicros方法返回stableIntervalMicros,在RateLimiter初始化的时候,stableIntervalMicros=0,所以newPermits是Infinity。在RateLimiter初始化的时候,maxPermits=0,所以storedPermits=0,表示刚初始化的时候,RateLimiter中没有缓存的令牌。
resync还将nextFreeTicketMicros更新为当前的时间。

   @Override
    void doSetRate(double permitsPerSecond, double stableIntervalMicros) {
      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 {
        storedPermits =
            (oldMaxPermits == 0.0)
                ? 0.0 // initial state
                : storedPermits * maxPermits / oldMaxPermits;
      }
    }

当RateLimiter初始化的时候,会走else语句,因为oldMaxPermits是0,导致storedPermits=0。

RateLimiter的使用

  @CanIgnoreReturnValue
  public double acquire(int permits) {
    long microsToWait = reserve(permits);
    stopwatch.sleepMicrosUninterruptibly(microsToWait);
    return 1.0 * microsToWait / SECONDS.toMicros(1L);
  }

reserve方法会计算出当前线程下次启动需要等待的时间,然后通过sleep将线程暂停,当线程重新启动的时候,返回线程暂停的时间。

final long reserve(int permits) {
    checkPermits(permits);
    synchronized (mutex()) {
      return reserveAndGetWaitLength(permits, stopwatch.readMicros());
    }
}

final long reserveAndGetWaitLength(int permits, long nowMicros) {
    long momentAvailable = reserveEarliestAvailable(permits, nowMicros);
    return max(momentAvailable - nowMicros, 0);
}

@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;
}

reserveEarliestAvailable主要用于计算当前线程获取到令牌的时间,在计算的过程中会考虑缓存的令牌。
还会计算下个线程获取到令牌的时间,并赋给nextFreeTicketMicros。

你可能感兴趣的:(Guava RateLimiter限流源码解析)