Go 语言结合 Redis 实现固定窗口、滑动窗口、令牌桶和漏桶限流算法的示例代 ...

固定窗口算法

• 原理：将时间划分为固定大小的窗口，在每个窗口内对哀求举行计数。如果哀求数超过设定的阈值，则拒绝后续哀求，直到进入下一个窗口。
  
• 代码：
  

1. package main
3. import (
4.     "fmt"
5.     "time"
7.     "github.com/go-redis/redis/v8"
8. )
10. // rdb 是全局的 Redis 客户端实例，用于与 Redis 服务器进行交互
11. var rdb = redis.NewClient(&redis.Options{
12.     Addr:     "localhost:6379", // Redis 服务器地址和端口
13.     Password: "",               // Redis 密码，这里为空表示无密码
14.     DB:       0,                // 使用默认的数据库编号
15. })
17. // 定义固定窗口算法的常量
18. const (
19.     windowSize = 60 // 窗口大小，单位为秒
20.     limit      = 100 // 窗口内允许的最大请求数
21. )
23. // fixedWindowRateLimit 函数实现了固定窗口限流算法
24. func fixedWindowRateLimit(key string) bool {
25.     // 获取当前时间的 Unix 时间戳
26.     currentTime := time.Now().Unix()
27.     // 计算当前窗口的起始时间
28.     windowStart := currentTime - (currentTime % windowSize)
29.     // 构建当前窗口对应的 Redis key
30.     windowKey := fmt.Sprintf("%s:%d", key, windowStart)
32.     // 对 Redis 中的当前窗口计数器进行自增操作，并获取自增后的计数值
33.     count, err := rdb.Incr(rdb.Context(), windowKey).Result()
34.     if err != nil {
35.         // 如果自增操作出现错误，打印错误信息并返回 false
36.         fmt.Println("Error incrementing counter:", err)
37.         return false
38.     }
39.     // 如果计数值为 1，说明是该窗口的第一个请求，为该窗口设置过期时间
40.     if count == 1 {
41.         rdb.Expire(rdb.Context(), windowKey, time.Duration(windowSize)*time.Second)
42.     }
43.     // 如果计数值超过了允许的最大请求数，返回 false 表示请求被限流
44.     if count > limit {
45.         return false
46.     }
47.     // 否则，返回 true 表示请求通过
48.     return true
49. }
51. func main() {
52.     // 调用 fixedWindowRateLimit 函数进行限流判断
53.     if fixedWindowRateLimit("api_request") {
54.         fmt.Println("请求通过")
55.     } else {
56.         fmt.Println("请求被限流")
57.     }
58. }

复制代码

• 优缺点：实现简单，但可能会出现临界问题，即在窗口切换的刹时可能会出现流量高峰。
  

滑动窗口算法

• 原理：将固定窗口进一步细分，通过多个小窗口来统计哀求数，随着时间的推移，窗口不断滑动，从而更精确地控制流量。
  
• 代码：
  

1. package main
3. import (
4.     "fmt"
5.     "time"
7.     "github.com/go-redis/redis/v8"
8. )
10. // rdb 是全局的 Redis 客户端实例，用于与 Redis 服务器进行交互
11. var rdb = redis.NewClient(&redis.Options{
12.     Addr:     "localhost:6379", // Redis 服务器地址和端口
13.     Password: "",               // Redis 密码，这里为空表示无密码
14.     DB:       0,                // 使用默认的数据库编号
15. })
17. // 定义滑动窗口算法的常量
18. const (
19.     windowSize = 60 // 窗口大小，单位为秒
20.     limit      = 100 // 窗口内允许的最大请求数
21. )
23. // slidingWindowRateLimit 函数实现了滑动窗口限流算法
24. func slidingWindowRateLimit(key string) bool {
25.     // 获取当前时间的 Unix 时间戳
26.     currentTime := time.Now().Unix()
27.     // 移除 Redis 有序集合中时间戳小于当前窗口起始时间的元素
28.     rdb.ZRemRangeByScore(rdb.Context(), key, "0", fmt.Sprintf("%d", currentTime-windowSize))
29.     // 向 Redis 有序集合中添加当前时间戳，分数为当前时间戳
30.     rdb.ZAdd(rdb.Context(), key, &redis.Z{
31.         Score:  float64(currentTime),
32.         Member: currentTime,
33.     })
34.     // 获取 Redis 有序集合中当前窗口内的元素数量
35.     count, err := rdb.ZCard(rdb.Context(), key).Result()
36.     if err != nil {
37.         // 如果获取元素数量操作出现错误，打印错误信息并返回 false
38.         fmt.Println("Error getting count:", err)
39.         return false
40.     }
41.     // 如果元素数量超过了允许的最大请求数，返回 false 表示请求被限流
42.     if count > limit {
43.         return false
44.     }
45.     // 否则，返回 true 表示请求通过
46.     return true
47. }
49. func main() {
50.     // 调用 slidingWindowRateLimit 函数进行限流判断
51.     if slidingWindowRateLimit("api_request") {
52.         fmt.Println("请求通过")
53.     } else {
54.         fmt.Println("请求被限流")
55.     }
56. }

复制代码

• 优缺点：比固定窗口算法更精确地控制流量，但实现相对复杂，且需要更多的 Redis 操作。
  

令牌桶算法

• 原理：体系以固定的速率向令牌桶中添加令牌，每个哀求需要从令牌桶中获取一个或多个令牌才能被处理。如果令牌桶中没有足够的令牌，则哀求被拒绝。
  
• 代码：
  

1. package main
3. import (
4.     "fmt"
5.     "time"
7.     "github.com/go-redis/redis/v8"
8. )
10. // rdb 是全局的 Redis 客户端实例，用于与 Redis 服务器进行交互
11. var rdb = redis.NewClient(&redis.Options{
12.     Addr:     "localhost:6379", // Redis 服务器地址和端口
13.     Password: "",               // Redis 密码，这里为空表示无密码
14.     DB:       0,                // 使用默认的数据库编号
15. })
17. // 定义令牌桶算法的常量
18. const (
19.     capacity        = 100        // 令牌桶的容量
20.     rate            = 1          // 令牌生成速率，每秒生成 1 个令牌
21.     requiredTokens  = 1          // 每个请求所需的令牌数
22. )
24. // tokenBucketScript 是用于执行令牌桶算法的 Lua 脚本
25. var tokenBucketScript = `
26. -- 获取传入的令牌桶 key
27. local tokens_key = KEYS[1]
28. -- 构建存储上次更新时间的 key
29. local last_time_key = tokens_key .. ":last_time"
30. -- 获取令牌桶容量
31. local capacity = tonumber(ARGV[2])
32. -- 获取令牌生成速率
33. local rate = tonumber(ARGV[3])
34. -- 获取当前时间
35. local now = tonumber(ARGV[1])
36. -- 获取每个请求所需的令牌数
37. local required_tokens = tonumber(ARGV[4])
39. -- 从 Redis 中获取上次更新时间
40. local last_time = tonumber(redis.call('get', last_time_key))
41. -- 从 Redis 中获取当前令牌数
42. local tokens = tonumber(redis.call('get', tokens_key))
44. -- 如果上次更新时间为空，说明是首次请求，初始化相关值
45. if last_time == nil then
46.     last_time = now
47.     tokens = capacity
48. end
50. -- 计算从上次更新到现在生成的令牌数
51. local generated_tokens = (now - last_time) * rate
52. -- 更新令牌数，确保不超过令牌桶容量
53. tokens = math.min(capacity, tokens + generated_tokens)
55. -- 如果令牌数小于请求所需的令牌数，说明令牌不足，拒绝请求
56. if tokens < required_tokens then
57.     redis.call('set', last_time_key, last_time)
58.     redis.call('set', tokens_key, tokens)
59.     return 0
60. else
61.     -- 否则，处理请求，扣除相应的令牌数
62.     tokens = tokens - required_tokens
63.     redis.call('set', last_time_key, now)
64.     redis.call('set', tokens_key, tokens)
65.     return 1
66. end
67. `
69. // tokenBucketRateLimit 函数调用 Lua 脚本来实现令牌桶限流算法
70. func tokenBucketRateLimit(key string) bool {
71.     // 获取当前时间的 Unix 时间戳
72.     currentTime := time.Now().Unix()
73.     // 执行 Lua 脚本，并获取执行结果
74.     result, err := rdb.Eval(rdb.Context(), tokenBucketScript, []string{key}, currentTime, capacity, rate, requiredTokens).Int64()
75.     if err != nil {
76.         // 如果执行脚本出现错误，打印错误信息并返回 false
77.         fmt.Println("Error executing script:", err)
78.         return false
79.     }
80.     // 如果结果为 1，表示请求通过；否则，表示请求被限流
81.     return result == 1
82. }
84. func main() {
85.     // 调用 tokenBucketRateLimit 函数进行限流判断
86.     if tokenBucketRateLimit("api_request") {
87.         fmt.Println("请求通过")
88.     } else {
89.         fmt.Println("请求被限流")
90.     }
91. }

复制代码

• 优缺点：能够平滑地控制流量，答应一定程度的突发流量，但实现相对复杂。
  

漏桶限流算法

• 原理：哀求就像水一样注入漏桶，漏桶以固定的速率处理哀求。如果哀求的注入速率超过漏桶的处理速率，多余的哀求将被丢弃。
  
• 代码：
  

1. package main
3. import (
4.     "fmt"
5.     "time"
7.     "github.com/go-redis/redis/v8"
8. )
10. // rdb 是全局的 Redis 客户端实例，用于与 Redis 服务器进行交互
11. var rdb = redis.NewClient(&redis.Options{
12.     Addr:     "localhost:6379", // Redis 服务器地址和端口
13.     Password: "",               // Redis 密码，这里为空表示无密码
14.     DB:       0,                // 使用默认的数据库编号
15. })
17. // 定义漏桶算法的常量
18. const (
19.     capacity     = 100        // 漏桶的容量
20.     rate         = 1          // 漏桶的流出速率，每秒流出 1 个单位
21.     requestSize  = 1          // 每个请求的大小
22. )
24. // leakyBucketScript 是用于执行漏桶算法的 Lua 脚本
25. var leakyBucketScript = `
26. -- 获取传入的漏桶 key
27. local bucket_key = KEYS[1]
28. -- 构建存储上次更新时间的 key
29. local last_time_key = bucket_key .. ":last_time"
30. -- 获取漏桶容量
31. local capacity = tonumber(ARGV[2])
32. -- 获取漏桶流出速率
33. local rate = tonumber(ARGV[3])
34. -- 获取当前时间
35. local now = tonumber(ARGV[1])
36. -- 获取每个请求的大小
37. local request_size = tonumber(ARGV[4])
39. -- 从 Redis 中获取上次更新时间
40. local last_time = tonumber(redis.call('get', last_time_key))
41. -- 从 Redis 中获取当前漏桶中的水量
42. local water = tonumber(redis.call('get', bucket_key))
44. -- 如果上次更新时间为空，说明是首次请求，初始化相关值
45. if last_time == nil then
46.     last_time = now
47.     water = 0
48. end
50. -- 计算从上次更新到现在流出的水量
51. local outflow = (now - last_time) * rate
52. -- 更新漏桶中的水量，确保不小于 0
53. water = math.max(0, water - outflow)
55. -- 如果漏桶中的水量加上当前请求的大小超过了漏桶容量，说明漏桶已满，拒绝请求
56. if water + request_size > capacity then
57.     redis.call('set', last_time_key, last_time)
58.     redis.call('set', bucket_key, water)
59.     return 0
60. else
61.     -- 否则，处理请求，增加漏桶中的水量
62.     water = water + request_size
63.     redis.call('set', last_time_key, now)
64.     redis.call('set', bucket_key, water)
65.     return 1
66. end
67. `
69. // leakyBucketRateLimit 函数调用 Lua 脚本来实现漏桶限流算法
70. func leakyBucketRateLimit(key string) bool {
71.     // 获取当前时间的 Unix 时间戳
72.     currentTime := time.Now().Unix()
73.     // 执行 Lua 脚本，并获取执行结果
74.     result, err := rdb.Eval(rdb.Context(), leakyBucketScript, []string{key}, currentTime, capacity, rate, requestSize).Int64()
75.     if err != nil {
76.         // 如果执行脚本出现错误，打印错误信息并返回 false
77.         fmt.Println("Error executing script:", err)
78.         return false
79.     }
80.     // 如果结果为 1，表示请求通过；否则，表示请求被限流
81.     return result == 1
82. }
84. func main() {
85.     // 调用 leakyBucketRateLimit 函数进行限流判断
86.     if leakyBucketRateLimit("api_request") {
87.         fmt.Println("请求通过")
88.     } else {
89.         fmt.Println("请求被限流")
90.     }
91. }

复制代码

• 优缺点：可以平滑地处理哀求，保证哀求以固定的速率被处理，但无法应对突发流量。
  

总结

算法实现复杂度限流精度突发流量处理实用场景固定窗口算法简单低差流量平稳、精度要求低的场景滑动窗口算法较复杂高一样平常流量波动大、精度要求高的场景令牌桶算法较复杂高好可容忍突发流量、需平滑限流的场景漏桶算法较复杂高差对流量稳定性要求极高的场景

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。