RateLimiter 的底层实现是啥?

开发 后端
本文不是一个RateLimiter的详细分析,仅仅是概要分析。

 前言

本文不是一个RateLimiter的详细分析,仅仅是概要分析。

令牌桶算法

一说到RateLimiter,必然要是说的令牌桶,它的大致逻辑如下:

按图实现

令牌桶的图,网上到处可见,按图实现也非常简单,无非是定时添加令牌桶,并提供一个获取令牌的函数,博主实现了一遍代码如下: 

  1. import java.util.concurrent.*;  
  2. public class MyRateLimiter {  
  3.     //令牌桶  
  4.     BlockingQueue<Integer>TOKEN_BUCKET=new LinkedBlockingDeque<>(5);  
  5.     public static void main(String[] args) {  
  6.         MyRateLimiter myRateLimiter=new MyRateLimiter();  
  7.         myRateLimiter.addTokenFixedRate();  
  8.        for(int i=0;i<10;i++){ 
  9.                 myRateLimiter.acqurie();  
  10.                 System.out.println("第几次执行i:" + i + ",执行时间为:" + System.currentTimeMillis());  
  11.         }  
  12.     }  
  13.    /**  
  14.     * 定时添加令牌  
  15.     */  
  16.     public void addTokenFixedRate(){  
  17.         ScheduledExecutorService scheduledExecutorServiceExecutors.newSingleThreadScheduledExecutor();  
  18.         scheduledExecutorService.scheduleAtFixedRate(()-> 
  19.                     boolean suc=TOKEN_BUCKET.offer(1);  
  20.                     if(!suc){  
  21.                         System.out.println("令牌桶满了丢弃");  
  22.                     }  
  23.         },0,200,TimeUnit.MILLISECONDS);  
  24.     }  
  25.     public void acqurie(){  
  26.         while (TOKEN_BUCKET.poll()==null){};  
  27.     }  

测试结果如下,基本满足要求

RateLimiter概要实现

我一开始是按照自己实现的逻辑,去查看Guava的RateLimiter的源码的,结果发现RateLimiter根本没有集合充当桶,核心是记录了下一令牌产生的时间与现存令牌数,并动态更新它们。

概要逻辑图如下:

按照这个图看核心代码就比较容易了,摘录核心代码如下: 

  1. @CanIgnoreReturnValue  
  2. public double acquire(int permits) {  
  3.   long microsToWait = reserve(permits);  
  4.   stopwatch.sleepMicrosUninterruptibly(microsToWait);  
  5.   return 1.0 * microsToWait / SECONDS.toMicros(1L);  
  6.  
  7. //Reserve 一路向下能查到如下代码  reserveEarliestAvailable  
  8. final long reserveEarliestAvailable(int requiredPermits, long nowMicros) {  
  9.     resync(nowMicros);  
  10.     long returnValue = nextFreeTicketMicros 
  11.  // 现存令牌可以提供的令牌数  
  12.     double storedPermitsToSpend = min(requiredPermits, this.storedPermits);  
  13.  //需要刷新的令牌数  
  14.     double freshPermits = requiredPermits - storedPermitsToSpend;  
  15.  //等待时间=需要刷新的令牌数*固定间隔+存储许可等待时间  
  16.     long waitMicros =  
  17.         storedPermitsToWaitTime(this.storedPermits, storedPermitsToSpend)  
  18.             + (long) (freshPermits * stableIntervalMicros); 
  19.   //下次令牌生产时间=本次令牌生产时间+等待时间  
  20.     this.nextFreeTicketMicros = LongMath.saturatedAdd(nextFreeTicketMicros, waitMicros);  
  21.     this.storedPermits -storedPermitsToSpend 
  22.     return returnValue;  

总结:RateLimiter根本没有集合充当桶,核心是记录了下一令牌产生的时间与现存令牌数,并动态更新它们。最后,关注公众号Java技术栈,在后台回复:面试,可以获取我整理的 Java 系列面试题和答案,非常齐全。 

 

责任编辑:庞桂玉 来源: Java技术栈
相关推荐

2021-01-08 08:34:09

Synchronize线程开发技术

2023-07-11 08:00:00

2023-01-04 07:54:03

HashMap底层JDK

2022-06-22 09:07:09

Guava算法

2017-10-23 10:13:18

IO底层虚拟

2010-07-19 14:31:14

SQL Server

2022-12-26 09:27:48

Java底层monitor

2019-05-27 14:40:43

Java同步机制多线程编程

2014-12-25 09:47:59

GuavaGuava并发

2022-12-19 08:00:00

SpringBootWeb开发

2013-03-19 10:29:49

MySQLMySQL ProxyMySQL底层

2014-11-26 10:44:33

DockerOpenStack云计算

2022-04-13 14:43:05

JVM同步锁Monitor 监视

2020-05-27 20:45:31

Redis底层数据

2024-01-29 08:00:00

架构微服务开发

2010-07-19 14:37:20

SQL Server

2024-03-14 14:56:22

反射Java数据库连接

2011-05-30 08:58:59

Android focusable 属性

2017-08-31 11:28:47

Slice底层实现

2021-11-02 12:19:18

Go函数结构
点赞
收藏

51CTO技术栈公众号