通过acquire方法看懂RateLimiter限流机制

通过acquire方法看懂RateLimiter限流机制

关键方法

1）resync，动态计算剩余令牌数量和下次发放时间；

2）reserveEarliestAvailable，预定令牌，允许超发，超发后重新计算剩余令牌数量清零，并且会延长nextFreeTicketMicros下一次获取令牌的时间；

如果超发，下一次发放令牌请求，会sleep到超发时刻；

acquire获取令牌的时候，计算下次获取令牌时间，如果没有足够令牌会sleep再返回；

public double acquire(int permits) {
  // 预定令牌
  // mutex控制并发，以达到限流目的
  long microsToWait = reserve(permits);
  // 不可中断的sleep，while循环sleep纳秒级，详情请看源码
  // 发生条件在reserve里
  stopwatch.sleepMicrosUninterruptibly(microsToWait);
  // 返回sleep时间
  return 1.0 * microsToWait / SECONDS.toMicros(1L);
}

预定方法，mutex做同步控制

final long reserve(int permits) {
  // 判断>0
  checkPermits(permits);
  // 同步控制
  synchronized (mutex()) {
    return reserveAndGetWaitLength(permits, stopwatch.readMicros());
  }
}

单例mutex，面试你可能经常遇到要你写，那就参考google实际应用场景里的写法写一个

// Can't be initialized in the constructor because mocks don't call the constructor.
private volatile Object mutexDoNotUseDirectly;

private Object mutex() {
  Object mutex = mutexDoNotUseDirectly;
  if (mutex == null) {
    // 同步控制
    synchronized (this) {
      mutex = mutexDoNotUseDirectly;
      if (mutex == null) {
        mutexDoNotUseDirectly = mutex = new Object();
      }
    }
  }
  return mutex;
}

可以获取令牌的时间

final long reserveAndGetWaitLength(int permits, long nowMicros) {
    //可以获取令牌的时间
  long momentAvailable = reserveEarliestAvailable(permits, nowMicros);
  return max(momentAvailable - nowMicros, 0);
}

触发令牌计算resync

返回下次发放令牌时间，也是返回值，决定sleep时间

如果发放令牌数超过当前剩余令牌数，重新计算下次发放时间，当前令牌照常发放，允许一定超发

@Override
final long reserveEarliestAvailable(int requiredPermits, long nowMicros) {
// 计算好剩余令牌数量和下次发放令牌时间
  resync(nowMicros);
  // 下次发放令牌时间，也是返回值，决定sleep时间
  long returnValue = nextFreeTicketMicros;
  
  // 如果发放令牌数超过当前剩余令牌数，重新计算下次发放时间
  double storedPermitsToSpend = min(requiredPermits, this.storedPermits);
  double freshPermits = requiredPermits - storedPermitsToSpend;
  
  // 如果超发会延长nextFreeTicketMicros
  long waitMicros = storedPermitsToWaitTime(this.storedPermits, storedPermitsToSpend)
      + (long) (freshPermits * stableIntervalMicros);
  try {
    // 如果超发会延长nextFreeTicketMicros
    this.nextFreeTicketMicros = LongMath.checkedAdd(nextFreeTicketMicros, waitMicros);
  } catch (ArithmeticException e) {
    this.nextFreeTicketMicros = Long.MAX_VALUE;
  }
  // 扣减已经发放的令牌数量，如果超发会扣减成0
  this.storedPermits -= storedPermitsToSpend;
  
  // 返回resync计算的下次发放令牌时间，也是返回值，决定sleep时间
  return returnValue;
  
}

void resync(long nowMicros)

所有入口都有同步控制

计算storedPermits，剩余令牌数量

计算下一次可以发放令牌的时间，nextFreeTicketMicros

/**
 * The currently stored permits.
 */
double storedPermits;

/**
 * The time when the next request (no matter its size) will be granted. After granting a
 * request, this is pushed further in the future. Large requests push this further than small
 * requests.
 */
private long nextFreeTicketMicros = 0L; // could be either in the past or future

void resync(long nowMicros) {
  // if nextFreeTicket is in the past, resync to now
  // 当前请求时间大于下次发放时间的时候才重新计算
  if (nowMicros > nextFreeTicketMicros) {
  // 计算剩余令牌总数量
    storedPermits = min(maxPermits,
        storedPermits
          + (nowMicros - nextFreeTicketMicros) / coolDownIntervalMicros());
   // 下次发放时间设置为当前时间
    nextFreeTicketMicros = nowMicros;
  }
}