public static void main(String[] args) {RateLimiter rateLimiter = RateLimiter.create(10);while (true) {long start = System.currentTimeMillis();rateLimiter.acquire();System.out.println(System.currentTimeMillis() - start);}}　　

static RateLimiter create(double permitsPerSecond, SleepingStopwatch stopwatch) {//创建对象，并且赋值，permitsPerSecond这个是我们设置的qps，stopwatch这个相当于一个计时器，记录相对时间，类似于我上面图中的10ms,100ms等，下面传入的1.0就是一秒的意思，设置上速率就是一秒多少次RateLimiter rateLimiter = new SmoothBursty(stopwatch, 1.0);rateLimiter.setRate(permitsPerSecond);return rateLimiter;}
看一下setRate
public final void setRate(double permitsPerSecond) {checkArgument(permitsPerSecond > 0.0 && !Double.isNaN(permitsPerSecond), "rate must be positive");//从名字就可以看出这是一个互斥锁，这个互斥锁采用了double check懒汉单例模式生成，synchronized (mutex()) {doSetRate(permitsPerSecond, stopwatch.readMicros());}}

final void doSetRate(double permitsPerSecond, long nowMicros) {//这个方法非常重要里面是nextFreeTicketMicros和storedPermits的设置，在生成对象的时候没有用，获取令牌时再讲resync(nowMicros);//这个就是令牌生成间隔，微秒表示double stableIntervalMicros = SECONDS.toMicros(1L) / permitsPerSecond;this.stableIntervalMicros = stableIntervalMicros;这里又有一个doSetRatedoSetRate(permitsPerSecond, stableIntervalMicros);}void doSetRate(double permitsPerSecond, double stableIntervalMicros) {double oldMaxPermits = this.maxPermits;//设置最大令牌maxPermits = maxBurstSeconds * permitsPerSecond;//设置存储令牌if (oldMaxPermits == Double.POSITIVE_INFINITY) {storedPermits = maxPermits;} else {storedPermits =(oldMaxPermits == 0.0)? 0.0 // initial state: storedPermits * maxPermits / oldMaxPermits;}

//获取一个令牌
public double acquire() {return acquire(1);}public double acquire(int permits) {//reserve返回等待时间，内部进行了令牌的获取long microsToWait = reserve(permits);stopwatch.sleepMicrosUninterruptibly(microsToWait);return 1.0 * microsToWait / SECONDS.toMicros(1L);}final long reserve(int permits) {checkPermits(permits);//创建对象时生成的锁synchronized (mutex()) {//stopwatch.readMicros()拿到当前的时间，预订return reserveAndGetWaitLength(permits, stopwatch.readMicros());}}final long reserveAndGetWaitLength(int permits, long nowMicros) {//将数据透传,拿到最早可预订的时间，如果预订时间在未来时间，返回一个大于0的值为等待时间long momentAvailable = reserveEarliestAvailable(permits, nowMicros);return max(momentAvailable - nowMicros, 0);}

final long reserveEarliestAvailable(int requiredPermits, long nowMicros) {//这个方法很重要先看下面这个方法的讲解，在从这里往下看resync(nowMicros);//返回下次发放令牌时间，如果这个时间大于当前时间，在调用的上层会sleeplong returnValue = nextFreeTicketMicros;//拿到此次花费的令牌double storedPermitsToSpend = min(requiredPermits, this.storedPermits);// 如果令牌不够，这里就会大于0，下面就会得出一个等待时间double freshPermits = requiredPermits - storedPermitsToSpend;long waitMicros =storedPermitsToWaitTime(this.storedPermits, storedPermitsToSpend)+ (long) (freshPermits * stableIntervalMicros);//将下次发放令牌的时间加上等待时间this.nextFreeTicketMicros = LongMath.saturatedAdd(nextFreeTicketMicros, waitMicros);this.storedPermits -= storedPermitsToSpend;return returnValue;}void resync(long nowMicros) {if (nowMicros > nextFreeTicketMicros) {//当前时间大于下次令牌发放时间，新的令牌为当前时间减去下次发放令牌时间除以生成令牌的时间间隔double newPermits = (nowMicros - nextFreeTicketMicros) / coolDownIntervalMicros();//不能超过最大令牌数storedPermits = min(maxPermits, storedPermits + newPermits);//更新下次发放令牌时间为当前时间nextFreeTicketMicros = nowMicros;}}