☕️【Java 专题系列】「回顾 RateLimiter」针对于限流器的入门到精通（针对于源码分析介绍）

@Testpublic void  testSample() {    RateLimiter rateLimiter = RateLimiter.create(500)}

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

/** * The currently stored permits. * 当前存储令牌数 */double storedPermits;/** * The maximum number of stored permits. * 最大存储令牌数 */double maxPermits;/** * The interval between two unit requests, at our stable rate. E.g., a stable rate of 5 permits * per second has a stable interval of 200ms. * 添加令牌时间间隔 */double stableIntervalMicros;/** * 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. * 下一次请求可以获取令牌的起始时间 * 由于RateLimiter允许预消费，上次请求预消费令牌后 * 下次请求需要等待相应的时间到nextFreeTicketMicros时刻才可以获取令牌 */private long nextFreeTicketMicros = 0L;// could be either in the past or future

@CanIgnoreReturnValuepublic double acquire() {  return acquire(1);}
@CanIgnoreReturnValuepublic double acquire(int permits) {  long microsToWait = reserve(permits);  stopwatch.sleepMicrosUninterruptibly(microsToWait);  return 1.0 * microsToWait / SECONDS.toMicros(1L);}
final long reserve(int permits) {  checkPermits(permits);  synchronized (mutex()) {    return reserveAndGetWaitLength(permits, stopwatch.readMicros());  }}

public boolean tryAcquire(int permits) {  return tryAcquire(permits, 0, MICROSECONDS);}
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();    if (!canAcquire(nowMicros, timeoutMicros)) {      return false;    } else {      microsToWait = reserveAndGetWaitLength(permits, nowMicros);    }  }  stopwatch.sleepMicrosUninterruptibly(microsToWait);  return true;}
private boolean canAcquire(long nowMicros, long timeoutMicros) {  return queryEarliestAvailable(nowMicros) - timeoutMicros <= nowMicros;}
@Overridefinal long queryEarliestAvailable(long nowMicros) {  return nextFreeTicketMicros;}

/** * Updates {@code storedPermits} and {@code nextFreeTicketMicros} based on the current time. */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;    }}

final long reserveEarliestAvailable(int requiredPermits, long nowMicros) {  resync(nowMicros);  long returnValue = nextFreeTicketMicros; // 返回的是上次计算的nextFreeTicketMicros  double storedPermitsToSpend = min(requiredPermits, this.storedPermits); // 可以消费的令牌数  double freshPermits = requiredPermits - storedPermitsToSpend; // 还需要的令牌数  long waitMicros =      storedPermitsToWaitTime(this.storedPermits, storedPermitsToSpend)          + (long) (freshPermits * stableIntervalMicros); // 根据freshPermits计算需要等待的时间
  this.nextFreeTicketMicros = LongMath.saturatedAdd(nextFreeTicketMicros, waitMicros); // 本次计算的nextFreeTicketMicros不返回  this.storedPermits -= storedPermitsToSpend;  return returnValue;}

SmoothBursty(SleepingStopwatch stopwatch, double maxBurstSeconds) {  super(stopwatch);  this.maxBurstSeconds = maxBurstSeconds; // 最大存储maxBurstSeconds秒生成的令牌}
@Overridevoid 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;  }}

@Overridedouble coolDownIntervalMicros() {  return stableIntervalMicros;}

@Overridedouble coolDownIntervalMicros() {  return warmupPeriodMicros / maxPermits;}

@Overridelong storedPermitsToWaitTime(double storedPermits, double permitsToTake) {  return 0L;}

@Overridelong storedPermitsToWaitTime(double storedPermits, double permitsToTake) {  double availablePermitsAboveThreshold = storedPermits - thresholdPermits;  long micros = 0;  // measuring the integral on the right part of the function (the climbing line)  if (availablePermitsAboveThreshold > 0.0) {    double permitsAboveThresholdToTake = min(availablePermitsAboveThreshold, permitsToTake);    // TODO(cpovirk): Figure out a good name for this variable.    double length =        permitsToTime(availablePermitsAboveThreshold)            + permitsToTime(availablePermitsAboveThreshold - permitsAboveThresholdToTake);    micros = (long) (permitsAboveThresholdToTake * length / 2.0);    permitsToTake -= permitsAboveThresholdToTake;  }  // measuring the integral on the left part of the function (the horizontal line)  micros += (long) (stableIntervalMicros * permitsToTake);  return micros;}