RateLimiter实现原理

RateLimiter实现原理

简介

维护 storedPermits、nextFreeTicketMicros 变量，其中 storedPermits代表当前的令牌数目，而 nextFreeTicketMicros 代表获取到下一个令牌的时间。

是一种借用、惰性更新、计算睡眠时间的一种算法。其中的借用，是指对于第一个请求会 先借用令牌桶中没生成好的 若干个令牌直接返回 ，而第二个请求 不管当前令牌桶有多少令牌，也要以固定速率补充回被借用的令牌 后才可以执行，而第三个，也是需要以固定速率补充回第二个借用的令牌才可以执行。而惰性更新，是指不通过定时任务一直更新令牌桶的数目，而是每次请求来执行resync()来计算有多少个令牌准备好了。而计算睡眠时间，则是不通过自旋，或是任务队列挂起唤醒这些做法，而是计算每个请求需要的睡眠时间，做线程睡眠自动苏醒，相当于排队。

优点： 不通过竞争令牌桶中的令牌实现，而是计算等待时间的方式，实现比较简单。同时避免频繁的线程切换和锁竞争，提高性能。

缺点： 借用的思路有可能导致消耗令牌的速率不均匀。依赖系统时间，系统时间的调整可能会影响到正确性。

代码整理

---

在 acquire / tryAcquire() / create()的doSetRate() 中，对 mutex() 加锁， 这个就是细粒度的一个锁。只阻塞this的这个acquire / tryAcquire()方法。

在执行acquire / tryAcquire()中，同步块中

1. resync()
   1. 惰性更新 落后的nextFreeTicketMicros 为当前时间， 也就是如果当前时间已经大于nextFreeTicketMicros,则更新 nextFreeTicketMicros 为当前时间
   2. 惰性更新 storedPermits 加上（当前时间-落后的nextFreeTicketMicros）过程中可以生成多少令牌，作为存储的令牌，不会超过 maxPermits 最大令牌数
2. reserveAndGetWaitLength()
   1. 计算 nextFreeTicketMicros - 当前时间，代表这个请求需要等待的时间： microsToNextFreeTicket
   2. 根据当前令牌桶里的数目，计算还需要多少时间才能偿还 被借用的令牌数目 ，并叠加到下次请求的放行时间：nextFreeTicketMicros
   3. 返回 microsToNextFreeTicket
3. 睡眠 waitMicros 这段时间 Thread.sleep()

---

在执行create()中，

1. doSetRate() 已经在同步代码中
   1. 执行resync()，惰性更新 nextFreeTicketMicros 和 storedPermits。
   2. maxPermits = maxBurstSeconds * permitsPerSecond; 即 最大许可为1秒钟生成多少个许可。作为最大令牌。
   3. 当每秒生成令牌小于1时，相当于系统不会存储令牌。

---

结合源码

demo

 public void contextLoad5() throws InterruptedException {
    //  每秒0.1个请求, 阻塞直到获取到令牌
    RateLimiter rateLimiter = RateLimiter.create(0.1);

    CountDownLatch countDownLatch = new CountDownLatch(10);
    ExecutorService executorService = Executors.newFixedThreadPool(10);
    for (int i = 0; i < 10; i++) {
      executorService.execute(() -> {
        int times = 0;
        while (true) {
          boolean b = rateLimiter.tryAcquire();
          if (b) {
            times++;
            System.out.println(Thread.currentThread().getName() + "当前请求i:【" + times + "】");
          }
          else {
            System.out.println(Thread.currentThread().getName() + "表示已达到限流阈值，拒绝请求..." + times);
          }
          try {
            Thread.sleep(10 * 1000);
          }
          catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      });
    }
    countDownLatch.await();
  }

---

RateLimiter.create(0.1);

// 当前令牌数目
double storedPermits;
// 最大令牌数目
double maxPermits;
// 每个请求需要多少
volatile double stableIntervalMicros;
// 锁 : acquire / tryAcquire / setRate 的锁
private final Object mutex;
// 下一个请求可以放行的时间
private long nextFreeTicketMicros;

// permitsPerSecond: 每秒钟生成多少个请求
static RateLimiter create(RateLimiter.SleepingTicker ticker, double permitsPerSecond) {
  RateLimiter rateLimiter = new RateLimiter.Bursty(ticker, 1.0D);
  rateLimiter.setRate(permitsPerSecond);
  return rateLimiter;
}

public final void setRate(double permitsPerSecond) {
  Preconditions.checkArgument(permitsPerSecond > 0.0D && !Double.isNaN(permitsPerSecond), "rate must be positive");

  // 使用 mutex 作为锁
  synchronized(this.mutex) {
    // 落后的nextFreeTicketMicros ,意味着 nowMicros > this.nextFreeTicketMicros
    // 惰性更新 落后的nextFreeTicketMicros 为当前时间， 也就是如果当前时间已经大于nextFreeTicketMicros,则更新 nextFreeTicketMicros 为当前时间
    // 惰性更新 storedPermits 加上（当前时间-落后的nextFreeTicketMicros）过程中可以生成多少令牌，作为存储的令牌，不会超过 maxPermits 最大令牌数
    this.resync(this.readSafeMicros());
    // 生成一个令牌需要的时间（微秒）: stableIntervalMicros = 1 * 1000 * 1000 / 每秒钟生成多少个请求
    double stableIntervalMicros = (double)TimeUnit.SECONDS.toMicros(1L) / permitsPerSecond;
    this.stableIntervalMicros = stableIntervalMicros;
    // 生成最大令牌数目: maxPermits = 1L * 每秒钟生成多少个请求
    this.doSetRate(permitsPerSecond, stableIntervalMicros);
  }
}


private void resync(long nowMicros) {
  if (nowMicros > this.nextFreeTicketMicros) {
    this.storedPermits = Math.min(this.maxPermits, this.storedPermits + (double)(nowMicros - this.nextFreeTicketMicros) / this.stableIntervalMicros);
    this.nextFreeTicketMicros = nowMicros;
  }
}


void doSetRate(double permitsPerSecond, double stableIntervalMicros) {
  double oldMaxPermits = this.maxPermits;
  this.maxPermits = this.maxBurstSeconds * permitsPerSecond;
  this.storedPermits = oldMaxPermits == 0.0D ? 0.0D : this.storedPermits * this.maxPermits / oldMaxPermits;
}

---

boolean b = rateLimiter.tryAcquire();

public boolean tryAcquire(int permits, long timeout, TimeUnit unit) {
  long timeoutMicros = unit.toMicros(timeout);
  // 校验一下permits是不是负数
  checkPermits(permits);
  long microsToWait;
  // 使用 mutex 作为锁
  synchronized(this.mutex) {
    long nowMicros = this.readSafeMicros();
    // 如果 下一个请求可以放行的时间 大于 当前时间+允许的偏移时间， 说明还没到时间，不能放行
    if (this.nextFreeTicketMicros > nowMicros + timeoutMicros) {
      return false;
    }
    // 否则就是已经可以放行了
    // 计算 nextFreeTicketMicros - 当前时间，代表这个请求需要等待的时间，作为结果返回microsToWait
    // 同时叠加下一个请求需要的时间 加上 偿还本次借用的令牌需要的时间
    microsToWait = this.reserveNextTicket((double)permits, nowMicros);
  }

  // 进行等待 microsToWait， Thread.sleep 一段时间
  this.ticker.sleepMicrosUninterruptibly(microsToWait);
  // 获取令牌成功
  return true;
}



// requiredPermits ： 这次请求总共需要多少个令牌
private long reserveNextTicket(double requiredPermits, long nowMicros) {
  // 落后的nextFreeTicketMicros ,意味着 nowMicros > this.nextFreeTicketMicros
  // 惰性更新 落后的nextFreeTicketMicros 为当前时间
  // 惰性更新 storedPermits 为 （当前时间-落后的nextFreeTicketMicros）过程中产生的 令牌数目
  this.resync(nowMicros);
  // microsToNextFreeTicket (需要等待的时间)  = 下一个请求可以放行的时间 - 当前时间
  long microsToNextFreeTicket = this.nextFreeTicketMicros - nowMicros;
  // storedPermitsToSpend （对于这次请求，当下可以立刻提供多少个令牌） = Math.min(requiredPermits, this.storedPermits);
  double storedPermitsToSpend = Math.min(requiredPermits, this.storedPermits);
  // freshPermits （对于这次请求，还需要提供多少个令牌） = requiredPermits - storedPermitsToSpend;
  double freshPermits = requiredPermits - storedPermitsToSpend;
  // 需要等待的时间 = 从 storedPermits 中借出 storedPermitsToSpend 需要的时间（默认为0） +  还需要多少个令牌 * 生成一个令牌需要的时间
  long waitMicros = this.storedPermitsToWaitTime(this.storedPermits, storedPermitsToSpend) + (long)(freshPermits * this.stableIntervalMicros);
  // 更新 下一个请求可以放行的时间 加上 重新生成借用的令牌需要的时间
  this.nextFreeTicketMicros += waitMicros;
  // 令牌消耗
  this.storedPermits -= storedPermitsToSpend;
  return microsToNextFreeTicket;
}


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

---

rateLimiter.acquire();

public double acquire(int permits) {
  // 校验一下permits是不是负数
  checkPermits(permits);
  long microsToWait;
   // 使用 mutex 作为锁
  synchronized (mutex) {
     // 获取这个请求需要等待多长时间，更新下次请求需要等待的时间
    microsToWait = reserveNextTicket(permits, readSafeMicros());
  }
  // 进行等待 microsToWait， Thread.sleep 一段时间  
  ticker.sleepMicrosUninterruptibly(microsToWait);
  return 1.0 * microsToWait / TimeUnit.SECONDS.toMicros(1L);
}