5种限流算法，7种限流方式，挡住突发流量

小鱼儿 2023-09-23 20:36 20阅读 0赞

### 前言 ###

最近几年，随着微服务的流行，服务和服务之间的依赖越来越强，调用关系越来越复杂，服务和服务之间的**稳定性**越来越重要。在遇到突发的请求量激增，恶意的用户访问，亦或请求频率过高给下游服务带来较大压力时，我们常常需要通过缓存、限流、[熔断降级][Link 1]、负载均衡等多种方式保证服务的稳定性。其中**限流**是不可或缺的一环，这篇文章介绍**限流**相关知识。

### 1. 限流 ###

**限流**顾名思义，就是对请求或并发数进行限制；通过对一个时间窗口内的请求量进行限制来保障系统的正常运行。如果我们的服务资源有限、处理能力有限，就需要对调用我们服务的上游请求进行限制，以防止自身服务由于资源耗尽而停止服务。

在限流中有两个概念需要了解。

*  **阈值**：在一个单位时间内允许的请求量。如 [QPS][] 限制为10，说明 1 秒内最多接受 10 次请求。
 *  **拒绝策略**：超过阈值的请求的拒绝策略，常见的拒绝策略有直接拒绝、排队等待等。

### 2. 固定窗口算法 ###

**固定窗口算法**又叫**计数器算法**，是一种**简单**方便的限流算法。主要通过一个支持**原子操作**的计数器来累计 1 秒内的请求次数，当 1 秒内计数达到限流阈值时触发拒绝策略。每过 1 秒，计数器重置为 0 开始重新计数。

#### 2.1. 代码实现 ####

下面是简单的代码实现，QPS 限制为 2，这里的代码做了一些**优化**，并没有单独开一个线程去每隔 1 秒重置计数器，而是在每次调用时进行时间间隔计算来确定是否先重置计数器。

1.  `/**`
2.  `* @author https://www.wdbyte.com`
3.  `*/`
4.  `public class RateLimiterSimpleWindow {`
5.  `// 阈值`
6.  `private static Integer QPS = 2;`
7.  `// 时间窗口（毫秒）`
8.  `private static long TIME_WINDOWS = 1000;`
9.  `// 计数器`
10. `private static AtomicInteger REQ_COUNT = new AtomicInteger();`
11. ``
12. `private static long START_TIME = System.currentTimeMillis();`
13. 
14. `public synchronized static boolean tryAcquire() {`
15. `if ((System.currentTimeMillis() - START_TIME) > TIME_WINDOWS) {`
16. `REQ_COUNT.set(0);`
17. `START_TIME = System.currentTimeMillis();`
18. `}`
19. `return REQ_COUNT.incrementAndGet() <= QPS;`
20. `}`
21. 
22. `public static void main(String[] args) throws InterruptedException {`
23. `for (int i = 0; i < 10; i++) {`
24. `Thread.sleep(250);`
25. `LocalTime now = LocalTime.now();`
26. `if (!tryAcquire()) {`
27. `System.out.println(now + " 被限流");`
28. `} else {`
29. `System.out.println(now + " 做点什么");`
30. `}`
31. `}`
32. `}`
33. `}`

运行结果：

1.  `20:53:43.038922 做点什么`
2.  `20:53:43.291435 做点什么`
3.  `20:53:43.543087 被限流`
4.  `20:53:43.796666 做点什么`
5.  `20:53:44.050855 做点什么`
6.  `20:53:44.303547 被限流`
7.  `20:53:44.555008 被限流`
8.  `20:53:44.809083 做点什么`
9.  `20:53:45.063828 做点什么`
10. `20:53:45.314433 被限流`

从输出结果中可以看到大概每秒操作 3 次，由于限制 QPS 为 2，所以平均会有一次被限流。看起来可以了，不过我们思考一下就会发现这种简单的限流方式是有问题的，虽然我们限制了 QPS 为 2，但是当遇到时间窗口的临界突变时，如 1s 中的后 500 ms 和第 2s 的前 500ms 时，虽然是加起来是 1s 时间，却可以被请求 4 次。

![a536a7317f8b15873c883599ee3e9a7f.png][]

固定窗口算法

简单修改测试代码，可以进行验证：

1.  `// 先休眠 400ms，可以更快的到达时间窗口。`
2.  `Thread.sleep(400);`
3.  `for (int i = 0; i < 10; i++) {`
4.  `Thread.sleep(250);`
5.  `if (!tryAcquire()) {`
6.  `System.out.println("被限流");`
7.  `} else {`
8.  `System.out.println("做点什么");`
9.  `}`
10. `}`

得到输出中可以看到连续 4 次请求，间隔 250 ms 没有却被限制。：

1.  `20:51:17.395087 做点什么`
2.  `20:51:17.653114 做点什么`
3.  `20:51:17.903543 做点什么`
4.  `20:51:18.154104 被限流`
5.  `20:51:18.405497 做点什么`
6.  `20:51:18.655885 做点什么`
7.  `20:51:18.906177 做点什么`
8.  `20:51:19.158113 被限流`
9.  `20:51:19.410512 做点什么`
10. `20:51:19.661629 做点什么`

### 3. 滑动窗口算法 ###

我们已经知道固定窗口算法的实现方式以及它所存在的问题，而滑动窗口算法是对固定窗口算法的改进。既然固定窗口算法在遇到时间窗口的临界突变时会有问题，那么我们在遇到下一个时间窗口前也调整时间窗口不就可以了吗？

下面是滑动窗口的示意图。

![de110e051559bb556e1e7ce748d41768.png][]

滑动窗口算法

上图的示例中，每 500ms 滑动一次窗口，可以发现窗口滑动的间隔越短，时间窗口的临界突变问题发生的概率也就越小，不过只要有时间窗口的存在，还是有可能发生**时间窗口的临界突变问题**。

#### 3.1. 代码实现 ####

下面是基于以上滑动窗口思路实现的简单的滑动窗口限流工具类。

1.  `package com.wdbyte.rate.limiter;`
2.  
3.  `import java.time.LocalTime;`
4.  `import java.util.concurrent.atomic.AtomicInteger;`
5.  
6.  `/**`
7.  `* 滑动窗口限流工具类`
8.  `*`
9.  `* @author https://www.wdbyte.com`
10. `*/`
11. `public class RateLimiterSlidingWindow {`
12. `/**`
13. `* 阈值`
14. `*/`
15. `private int qps = 2;`
16. `/**`
17. `* 时间窗口总大小（毫秒）`
18. `*/`
19. `private long windowSize = 1000;`
20. `/**`
21. `* 多少个子窗口`
22. `*/`
23. `private Integer windowCount = 10;`
24. `/**`
25. `* 窗口列表`
26. `*/`
27. `private WindowInfo[] windowArray = new WindowInfo[windowCount];`
28. 
29. `public RateLimiterSlidingWindow(int qps) {`
30. `this.qps = qps;`
31. `long currentTimeMillis = System.currentTimeMillis();`
32. `for (int i = 0; i < windowArray.length; i++) {`
33. `windowArray[i] = new WindowInfo(currentTimeMillis, new AtomicInteger(0));`
34. `}`
35. `}`
36. 
37. `/**`
38. `* 1. 计算当前时间窗口`
39. `* 2. 更新当前窗口计数 & 重置过期窗口计数`
40. `* 3. 当前 QPS 是否超过限制`
41. `*`
42. `* @return`
43. `*/`
44. `public synchronized boolean tryAcquire() {`
45. `long currentTimeMillis = System.currentTimeMillis();`
46. `// 1. 计算当前时间窗口`
47. `int currentIndex = (int)(currentTimeMillis % windowSize / (windowSize / windowCount));`
48. `// 2. 更新当前窗口计数 & 重置过期窗口计数`
49. `int sum = 0;`
50. `for (int i = 0; i < windowArray.length; i++) {`
51. `WindowInfo windowInfo = windowArray[i];`
52. `if ((currentTimeMillis - windowInfo.getTime()) > windowSize) {`
53. `windowInfo.getNumber().set(0);`
54. `windowInfo.setTime(currentTimeMillis);`
55. `}`
56. `if (currentIndex == i && windowInfo.getNumber().get() < qps) {`
57. `windowInfo.getNumber().incrementAndGet();`
58. `}`
59. `sum = sum + windowInfo.getNumber().get();`
60. `}`
61. `// 3. 当前 QPS 是否超过限制`
62. `return sum <= qps;`
63. `}`
64. 
65. `private class WindowInfo {`
66. `// 窗口开始时间`
67. `private Long time;`
68. `// 计数器`
69. `private AtomicInteger number;`
70. 
71. `public WindowInfo(long time, AtomicInteger number) {`
72. `this.time = time;`
73. `this.number = number;`
74. `}`
75. `// get...set...`
76. `}`
77. `}`

下面是测试用例，设置 QPS 为 2,测试次数 20 次，每次间隔 300 毫秒，预计成功次数在 12 次左右。

1.  `public static void main(String[] args) throws InterruptedException {`
2.  `int qps = 2, count = 20, sleep = 300, success = count * sleep / 1000 * qps;`
3.  `System.out.println(String.format("当前QPS限制为:%d,当前测试次数:%d,间隔:%dms,预计成功次数:%d", qps, count, sleep, success));`
4.  `success = 0;`
5.  `RateLimiterSlidingWindow myRateLimiter = new RateLimiterSlidingWindow(qps);`
6.  `for (int i = 0; i < count; i++) {`
7.  `Thread.sleep(sleep);`
8.  `if (myRateLimiter.tryAcquire()) {`
9.  `success++;`
10. `if (success % qps == 0) {`
11. `System.out.println(LocalTime.now() + ": success, ");`
12. `} else {`
13. `System.out.print(LocalTime.now() + ": success, ");`
14. `}`
15. `} else {`
16. `System.out.println(LocalTime.now() + ": fail");`
17. `}`
18. `}`
19. `System.out.println();`
20. `System.out.println("实际测试成功次数:" + success);`
21. `}`

下面是测试的结果。

1.  `当前QPS限制为:2,当前测试次数:20,间隔:300ms,预计成功次数:12`
2.  `16:04:27.077782: success, 16:04:27.380715: success,`
3.  `16:04:27.684244: fail`
4.  `16:04:27.989579: success, 16:04:28.293347: success,`
5.  `16:04:28.597658: fail`
6.  `16:04:28.901688: fail`
7.  `16:04:29.205262: success, 16:04:29.507117: success,`
8.  `16:04:29.812188: fail`
9.  `16:04:30.115316: fail`
10. `16:04:30.420596: success, 16:04:30.725897: success,`
11. `16:04:31.028599: fail`
12. `16:04:31.331047: fail`
13. `16:04:31.634127: success, 16:04:31.939411: success,`
14. `16:04:32.242380: fail`
15. `16:04:32.547626: fail`
16. `16:04:32.847965: success,`
17. `实际测试成功次数:11`

### 4. 滑动日志算法 ###

滑动日志算法是实现限流的另一种方法，这种方法比较简单。基本逻辑就是记录下所有的请求时间点，新请求到来时先判断最近指定时间范围内的请求数量是否超过指定阈值，由此来确定是否达到限流，这种方式没有了时间窗口突变的问题，限流比较准确，但是因为要记录下每次请求的时间点，所以**占用的内存较多**。

#### 4.1. 代码实现 ####

下面是简单实现的 一个滑动日志算法，因为滑动日志要每次请求单独存储一条记录，可能占用内存过多。所以下面这个实现其实不算严谨的滑动日志，更像一个把 1 秒时间切分成 1000 个时间窗口的滑动窗口算法。

1.  `package com.wdbyte.rate.limiter;`
2.  
3.  `import java.time.LocalTime;`
4.  `import java.util.HashSet;`
5.  `import java.util.Set;`
6.  `import java.util.TreeMap;`
7.  
8.  `/**`
9.  `* 滑动日志方式限流`
10. `* 设置 QPS 为 2.`
11. `*`
12. `* @author https://www.wdbyte.com`
13. `*/`
14. `public class RateLimiterSildingLog {`
15. 
16. `/**`
17. `* 阈值`
18. `*/`
19. `private Integer qps = 2;`
20. `/**`
21. `* 记录请求的时间戳,和数量`
22. `*/`
23. `private TreeMap<Long, Long> treeMap = new TreeMap<>();`
24. 
25. `/**`
26. `* 清理请求记录间隔, 60 秒`
27. `*/`
28. `private long claerTime = 60 * 1000;`
29. 
30. `public RateLimiterSildingLog(Integer qps) {`
31. `this.qps = qps;`
32. `}`
33. 
34. `public synchronized boolean tryAcquire() {`
35. `long now = System.currentTimeMillis();`
36. `// 清理过期的数据老数据，最长 60 秒清理一次`
37. `if (!treeMap.isEmpty() && (treeMap.firstKey() - now) > claerTime) {`
38. `Set<Long> keySet = new HashSet<>(treeMap.subMap(0L, now - 1000).keySet());`
39. `for (Long key : keySet) {`
40. `treeMap.remove(key);`
41. `}`
42. `}`
43. `// 计算当前请求次数`
44. `int sum = 0;`
45. `for (Long value : treeMap.subMap(now - 1000, now).values()) {`
46. `sum += value;`
47. `}`
48. `// 超过QPS限制，直接返回 false`
49. `if (sum + 1 > qps) {`
50. `return false;`
51. `}`
52. `// 记录本次请求`
53. `if (treeMap.containsKey(now)) {`
54. `treeMap.compute(now, (k, v) -> v + 1);`
55. `} else {`
56. `treeMap.put(now, 1L);`
57. `}`
58. `return sum <= qps;`
59. `}`
60. 
61. `public static void main(String[] args) throws InterruptedException {`
62. `RateLimiterSildingLog rateLimiterSildingLog = new RateLimiterSildingLog(3);`
63. `for (int i = 0; i < 10; i++) {`
64. `Thread.sleep(250);`
65. `LocalTime now = LocalTime.now();`
66. `if (rateLimiterSildingLog.tryAcquire()) {`
67. `System.out.println(now + " 做点什么");`
68. `} else {`
69. `System.out.println(now + " 被限流");`
70. `}`
71. `}`
72. `}`
73. `}`

代码中把阈值 QPS 设定为 3，运行可以得到如下日志：

### 5. 漏桶算法 ###

漏桶算法中的漏桶是一个形象的比喻，这里可以用生产者消费者模式进行说明，请求是一个生产者，每一个请求都如一滴水，请求到来后放到一个队列（漏桶）中，而桶底有一个孔，不断的漏出水滴，就如消费者不断的在消费队列中的内容，消费的速率（漏出的速度）等于限流阈值。即假如 QPS 为 2，则每 `1s / 2= 500ms` 消费一次。漏桶的桶有大小，就如队列的容量，当请求堆积超过指定容量时，会触发拒绝策略。

下面是漏桶算法的示意图。

![42b379a2787bf065c88d48472dffefed.png][]

漏桶算法

由介绍可以知道，漏桶模式中的消费处理总是能以恒定的速度进行，可以很好的**保护自身系统**不被突如其来的流量冲垮；但是这也是漏桶模式的缺点，假设 QPS 为 2，同时 2 个请求进来，2 个请求并不能同时进行处理响应，因为每 `1s / 2= 500ms` 只能处理一个请求。

### 6. 令牌桶算法 ###

令牌桶算法同样是实现限流是一种常见的思路，最为常用的 Google 的 Java 开发工具包 Guava 中的限流工具类 RateLimiter 就是令牌桶的一个实现。令牌桶的实现思路类似于生产者和消费之间的关系。

系统服务作为生产者，按照指定频率向桶（容器）中添加令牌，如 QPS 为 2，每 500ms 向桶中添加一个令牌，如果桶中令牌数量达到阈值，则不再添加。

请求执行作为消费者，每个请求都需要去桶中拿取一个令牌，取到令牌则继续执行；如果桶中无令牌可取，就触发拒绝策略，可以是超时等待，也可以是直接拒绝本次请求，由此达到限流目的。

下面是令牌桶限流算法示意图。

![cbeecbf1686da18c75e7d25e2a48bfb8.png][]

令牌桶算法

思考令牌桶的实现可以以下特点。

1.  1s / 阈值（QPS） = 令牌添加时间间隔。
2.  桶的容量等于限流的阈值，令牌数量达到阈值时，不再添加。
3.  可以适应流量突发，N 个请求到来只需要从桶中获取 N 个令牌就可以继续处理。
4.  有启动过程，令牌桶启动时桶中无令牌，然后按照令牌添加时间间隔添加令牌，若启动时就有阈值数量的请求过来，会因为桶中没有足够的令牌而触发拒绝策略，不过如 RateLimiter 限流工具已经优化了这类问题。

#### 6.1. 代码实现 ####

Google 的 Java 开发工具包 Guava 中的限流工具类 RateLimiter 就是令牌桶的一个实现，日常开发中我们也不会手动实现了，这里直接使用 RateLimiter 进行测试。

引入依赖：

1.  `<exclusion>`
2.  `<groupId>com.google.guava</groupId>`
3.  `<artifactId>guava</artifactId>`
4.  `<version>31.0.1-jre</version>`
5.  `</exclusion>`

RateLimiter 限流体验：

1.  `// qps 2`
2.  `RateLimiter rateLimiter = RateLimiter.create(2);`
3.  `for (int i = 0; i < 10; i++) {`
4.  `String time = LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_TIME);`
5.  `System.out.println(time + ":" + rateLimiter.tryAcquire());`
6.  `Thread.sleep(250);`
7.  `}`

代码中限制 QPS 为 2，也就是每隔 500ms 生成一个令牌，但是程序每隔 250ms 获取一次令牌，所以两次获取中只有一次会成功。

1.  `17:19:06.797557:true`
2.  `17:19:07.061419:false`
3.  `17:19:07.316283:true`
4.  `17:19:07.566746:false`
5.  `17:19:07.817035:true`
6.  `17:19:08.072483:false`
7.  `17:19:08.326347:true`
8.  `17:19:08.577661:false`
9.  `17:19:08.830252:true`
10. `17:19:09.085327:false`

#### 6.2. 思考 ####

虽然演示了 Google Guava 工具包中的 RateLimiter 的实现，但是我们需要思考一个问题，就是令牌的添加方式，如果按照指定间隔添加令牌，那么需要开一个线程去定时添加，如果有很多个接口很多个 RateLimiter 实例，**线程数会随之增加**，这显然不是一个好的办法。显然 Google 也考虑到了这个问题，在 RateLimiter 中，是**在每次令牌获取时才进行计算令牌是否足够的**。它通过存储的下一个令牌生成的时间，和当前获取令牌的时间差，再结合阈值，去计算令牌是否足够，同时再记录下一个令牌的生成时间以便下一次调用。

下面是 Guava 中 RateLimiter 类的子类 SmoothRateLimiter 的 `resync()` 方法的代码分析，可以看到其中的令牌计算逻辑。

1.  `void resync(long nowMicros) { // 当前微秒时间`
2.  `// 当前时间是否大于下一个令牌生成时间`
3.  `if (nowMicros > this.nextFreeTicketMicros) {`
4.  `// 可生成的令牌数 newPermits = （当前时间 - 下一个令牌生成时间）/ 令牌生成时间间隔。`
5.  `// 如果 QPS 为2，这里的 coolDownIntervalMicros 就是 500000.0 微秒(500ms)`
6.  `double newPermits = (double)(nowMicros - this.nextFreeTicketMicros) / this.coolDownIntervalMicros();`
7.  `// 更新令牌库存 storedPermits。`
8.  `this.storedPermits = Math.min(this.maxPermits, this.storedPermits + newPermits);`
9.  `// 更新下一个令牌生成时间 nextFreeTicketMicros`
10. `this.nextFreeTicketMicros = nowMicros;`
11. `}`
12. `}`

### 7. Redis 分布式限流 ###

Redis 是一个开源的内存数据库，可以用来作为数据库、缓存、消息中间件等。Redis 是单线程的，又在内存中操作，所以速度极快，得益于 Redis 的各种特性，所以使用 Redis 实现一个限流工具是十分方便的。

下面的演示都基于Spring Boot 项目，并需要以下依赖。

1.  `<dependency>`
2.  `<groupId>org.springframework.boot</groupId>`
3.  `<artifactId>spring-boot-starter-data-redis</artifactId>`
4.  `</dependency>`

配置 Redis 信息。

1.  `spring:`
2.  `redis:`
3.  `database: 0`
4.  `password:`
5.  `port: 6379`
6.  `host: 127.0.0.1`
7.  `lettuce:`
8.  `shutdown-timeout: 100ms`
9.  `pool:`
10. `min-idle: 5`
11. `max-idle: 10`
12. `max-active: 8`
13. `max-wait: 1ms`

#### 7.1. 固定窗口限流 ####

Redis 中的固定窗口限流是使用 `incr` 命令实现的，`incr` 命令通常用来自增计数；如果我们使用时间戳信息作为 key，自然就可以统计每秒的请求量了，以此达到限流目的。

这里有两点要注意。

1.  对于不存在的 key，第一次新增时，value 始终为 1。
2.  INCR 和 EXPIRE 命令操作应该在一个**原子操作**中提交，以保证每个 key 都正确设置了过期时间，不然会有 key 值无法自动删除而导致的内存溢出。

由于 Redis 中实现事务的复杂性，所以这里直接只用 `lua` 脚本来实现[原子操作][Link 2]。下面是 `lua` 脚本内容。

1.  `local count = redis.call("incr",KEYS[1])`
2.  `if count == 1 then`
3.  `redis.call('expire',KEYS[1],ARGV[2])`
4.  `end`
5.  `if count > tonumber(ARGV[1]) then`
6.  `return 0`
7.  `end`
8.  `return 1`

下面是使用 Spring Boot 中 `RedisTemplate` 来实现的 `lua` 脚本调用测试代码。

1.  `/**`
2.  `* @author https://www.wdbyte.com`
3.  `*/`
4.  `@SpringBootTest`
5.  `class RedisLuaLimiterByIncr {`
6.  `private static String KEY_PREFIX = "limiter_";`
7.  `private static String QPS = "4";`
8.  `private static String EXPIRE_TIME = "1";`
9.  
10. `@Autowired`
11. `private StringRedisTemplate stringRedisTemplate;`
12. 
13. `@Test`
14. `public void redisLuaLimiterTests() throws InterruptedException, IOException {`
15. `for (int i = 0; i < 15; i++) {`
16. `Thread.sleep(200);`
17. `System.out.println(LocalTime.now() + " " + acquire("user1"));`
18. `}`
19. `}`
20. 
21. `/**`
22. `* 计数器限流`
23. `*`
24. `* @param key`
25. `* @return`
26. `*/`
27. `public boolean acquire(String key) {`
28. `// 当前秒数作为 key`
29. `key = KEY_PREFIX + key + System.currentTimeMillis() / 1000;`
30. `DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();`
31. `redisScript.setResultType(Long.class);`
32. `//lua文件存放在resources目录下`
33. `redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("limiter.lua")));`
34. `return stringRedisTemplate.execute(redisScript, Arrays.asList(key), QPS, EXPIRE_TIME) == 1;`
35. `}`
36. `}`

代码中虽然限制了 QPS 为 4，但是因为这种限流实现是把毫秒时间戳作为 key 的，所以会有临界窗口突变的问题，下面是运行结果，可以看到因为时间窗口的变化，导致了 QPS 超过了限制值 4。

1.  `17:38:23.122044 true`
2.  `17:38:23.695124 true`
3.  `17:38:23.903220 true`
4.  `# 此处有时间窗口变化，所以下面继续 true`
5.  `17:38:24.106206 true`
6.  `17:38:24.313458 true`
7.  `17:38:24.519431 true`
8.  `17:38:24.724446 true`
9.  `17:38:24.932387 false`
10. `17:38:25.137912 true`
11. `17:38:25.355595 true`
12. `17:38:25.558219 true`
13. `17:38:25.765801 true`
14. `17:38:25.969426 false`
15. `17:38:26.176220 true`
16. `17:38:26.381918 true`

#### 7.3. 滑动窗口限流 ####

通过对上面的基于 `incr` 命令实现的 Redis 限流方式的测试，我们已经发现了固定窗口限流所带来的问题，在这篇文章的第三部分已经介绍了滑动窗口限流的优势，它可以大幅度降低因为窗口临界突变带来的问题，那么如何使用 Redis 来实现滑动窗口限流呢？

这里主要使用 `ZSET` 有序集合来实现滑动窗口限流，`ZSET` 集合有下面几个特点：

1.  ZSET 集合中的 key 值可以自动排序。
2.  ZSET 集合中的 value 不能有重复值。
3.  ZSET 集合可以方便的使用 ZCARD 命令获取元素个数。
4.  ZSET 集合可以方便的使用 ZREMRANGEBYLEX 命令移除指定范围的 key 值。

基于上面的四点特性，可以编写出基于 `ZSET`的滑动窗口限流 `lua` 脚本。

1.  `--KEYS[1]: 限流 key`
2.  `--ARGV[1]: 时间戳 - 时间窗口`
3.  `--ARGV[2]: 当前时间戳（作为score）`
4.  `--ARGV[3]: 阈值`
5.  `--ARGV[4]: score 对应的唯一value`
6.  `-- 1. 移除时间窗口之前的数据`
7.  `redis.call('zremrangeByScore', KEYS[1], 0, ARGV[1])`
8.  `-- 2. 统计当前元素数量`
9.  `local res = redis.call('zcard', KEYS[1])`
10. `-- 3. 是否超过阈值`
11. `if (res == nil) or (res < tonumber(ARGV[3])) then`
12. `redis.call('zadd', KEYS[1], ARGV[2], ARGV[4])`
13. `return 1`
14. `else`
15. `return 0`
16. `end`

下面是使用 Spring Boot 中 `RedisTemplate` 来实现的 `lua` 脚本调用测试代码。

1.  `@SpringBootTest`
2.  `class RedisLuaLimiterByZset {`
3.  
4.  `private String KEY_PREFIX = "limiter_";`
5.  `private String QPS = "4";`
6.  
7.  `@Autowired`
8.  `private StringRedisTemplate stringRedisTemplate;`
9.  
10. `@Test`
11. `public void redisLuaLimiterTests() throws InterruptedException, IOException {`
12. `for (int i = 0; i < 15; i++) {`
13. `Thread.sleep(200);`
14. `System.out.println(LocalTime.now() + " " + acquire("user1"));`
15. `}`
16. `}`
17. 
18. `/**`
19. `* 计数器限流`
20. `*`
21. `* @param key`
22. `* @return`
23. `*/`
24. `public boolean acquire(String key) {`
25. `long now = System.currentTimeMillis();`
26. `key = KEY_PREFIX + key;`
27. `String oldest = String.valueOf(now - 1_000);`
28. `String score = String.valueOf(now);`
29. `String scoreValue = score;`
30. `DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();`
31. `redisScript.setResultType(Long.class);`
32. `//lua文件存放在resources目录下`
33. `redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("limiter2.lua")));`
34. `return stringRedisTemplate.execute(redisScript, Arrays.asList(key), oldest, score, QPS, scoreValue) == 1;`
35. `}`
36. `}`

代码中限制 QPS 为 4，运行结果信息与之一致。

1.  `17:36:37.150370 true`
2.  `17:36:37.716341 true`
3.  `17:36:37.922577 true`
4.  `17:36:38.127497 true`
5.  `17:36:38.335879 true`
6.  `17:36:38.539225 false`
7.  `17:36:38.745903 true`
8.  `17:36:38.952491 true`
9.  `17:36:39.159497 true`
10. `17:36:39.365239 true`
11. `17:36:39.570572 false`
12. `17:36:39.776635 true`
13. `17:36:39.982022 true`
14. `17:36:40.185614 true`
15. `17:36:40.389469 true`

这里介绍了 Redis 实现限流的两种方式，当然使用 Redis 也可以实现漏桶和令牌桶两种限流算法，这里就不做演示了，感兴趣的可以自己研究下。

### 8. 总结 ###

这篇文章介绍实现限流的几种方式，主要是**窗口算法和桶算法**，两者各有优势。

*  窗口算法实现简单，逻辑清晰，可以很直观的得到当前的 QPS 情况，但是会有时间窗口的临界突变问题，而且不像桶一样有队列可以缓冲。
 *  桶算法虽然稍微复杂，不好统计 QPS 情况，但是桶算法也有优势所在。
    
     *  漏桶模式消费速率恒定，可以很好的**保护自身系统**，可以对流量进行整形，但是面对突发流量不能快速响应。
     *  令牌桶模式可以面对突发流量，但是启动时会有缓慢加速的过程，不过常见的开源工具中已经对此优化。

**单机限流与分布式限流**

上面演示的基于代码形式的窗口算法和桶算法限流都适用于单机限流，如果需要分布式限流可以结合注册中心、负载均衡计算每个服务的限流阈值，但这样会降低一定精度，如果对精度要求不是太高，可以使用。

而 Redis 的限流，由于 Redis 的单机性，本身就可以用于分布式限流。使用 Redis 可以实现各种可以用于限流算法，如果觉得麻烦也可以使用开源工具如 redisson，已经封装了基于 Redis 的限流。

**其他限流工具**

文中已经提到了 `Guava` 的限流工具包，不过它毕竟是单机的，开源社区中也有很多分布式限流工具，如阿里开源的 Sentinel 就是不错的工具，Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

一如既往，文章中的代码存放在：github.com/niumoo/JavaNotes

### 参考 ###

Redis INCR:https://redis.io/commands/incr

Rate Limiting Wikipedia：https://en.wikipedia.org/wiki/Rate\_limiting

SpringBoot Redis:https://www.cnblogs.com/lenve/p/10965667.html

来源：[5种限流算法，7种限流方式，挡住突发流量\_文晓武的博客-CSDN博客\_限流算法][5_7_-CSDN]

[Link 1]: https://so.csdn.net/so/search?q=%E7%86%94%E6%96%AD%E9%99%8D%E7%BA%A7&spm=1001.2101.3001.7020
[QPS]: https://so.csdn.net/so/search?q=QPS&spm=1001.2101.3001.7020
[a536a7317f8b15873c883599ee3e9a7f.png]: https://img-blog.csdnimg.cn/img_convert/a536a7317f8b15873c883599ee3e9a7f.png
[de110e051559bb556e1e7ce748d41768.png]: https://img-blog.csdnimg.cn/img_convert/de110e051559bb556e1e7ce748d41768.png
[42b379a2787bf065c88d48472dffefed.png]: https://img-blog.csdnimg.cn/img_convert/42b379a2787bf065c88d48472dffefed.png
[cbeecbf1686da18c75e7d25e2a48bfb8.png]: https://img-blog.csdnimg.cn/img_convert/cbeecbf1686da18c75e7d25e2a48bfb8.png
[Link 2]: https://so.csdn.net/so/search?q=%E5%8E%9F%E5%AD%90%E6%93%8D%E4%BD%9C&spm=1001.2101.3001.7020
[5_7_-CSDN]: https://blog.csdn.net/yangbindxj/article/details/124396314