本文深入剖析Redis在分布式限流中的典型应用，对比令牌桶、漏桶、滑动窗口三种算法的实现差异，结合真实场景分析各方案的性能表现与适用边界，提供可落地的代码级解决方案。

一、为什么需要Redis限流？

在高并发系统中，突如其来的流量洪峰可能导致：
- 服务资源耗尽（数据库连接池枯竭）
- 上游服务被拖垮（雪崩效应）
- API响应时间飙升（用户体验恶化）

单机限流方案（如Guava RateLimiter）在分布式环境下失效时，基于Redis的分布式限流成为通用解法。其核心优势在于：
1. 原子性操作：利用Lua脚本保证多命令执行的原子性
2. 高性能：内存操作+单线程模型避免锁竞争
3. 持久化：异常重启后仍能保持限流状态

二、三种经典算法实现对比

1. 令牌桶算法（Token Bucket）

实现原理：lua
-- KEYS[1]: 限流key
-- ARGV[1]: 桶容量
-- ARGV[2]: 令牌生成速率（个/秒）
-- ARGV[3]: 当前时间戳
local key = KEYS[1]
local capacity = tonumber(ARGV[1])
local rate = tonumber(ARGV[2])
local now = tonumber(ARGV[3])

local lasttokens = tonumber(redis.call("HGET", key, "tokens")) or capacity local lasttime = tonumber(redis.call("HGET", key, "time")) or now

local delta = math.max(0, now - lasttime) local newtokens = math.min(capacity, last_tokens + delta * rate)

local allowed = newtokens >= 1 if allowed then redis.call("HSET", key, "tokens", newtokens - 1)
redis.call("HSET", key, "time", now)
end

return allowed and 1 or 0

特点：
- 允许突发流量（桶内令牌可累积）
- 精确控制平均速率
- 适合电商秒杀等场景

2. 漏桶算法（Leaky Bucket）

实现原理：python
def isallowed(userid):
key = f"leaky:{userid}" # 最后一次请求时间（毫秒） lasttime = redis.get(key) or 0
# 漏水速率（毫秒/次）
leak_rate = 1000 / 10 # 10 QPS

now = time.time() * 1000
elapsed = now - last_time

if elapsed >= leak_rate:
    redis.set(key, now)
    return True
return False

特点：
- 严格平滑流量（恒定速率处理）
- 无法应对突发流量
- 适合API配额控制

3. 滑动窗口计数（Sliding Window）

实现原理：lua
-- KEYS[1]: 限流key
-- ARGV[1]: 时间窗口（秒）
-- ARGV[2]: 最大请求数
local key = KEYS[1]
local window = tonumber(ARGV[1])
local limit = tonumber(ARGV[2])

local now = redis.call("TIME")[1]
local clearBefore = now - window

redis.call("ZREMRANGEBYSCORE", key, 0, clearBefore)
local current = redis.call("ZCARD", key)

if current < limit then
redis.call("ZADD", key, now, now .. math.random())
redis.call("EXPIRE", key, window)
return 1
end
return 0

特点：
- 时间窗口动态滑动
- 内存占用随请求量增长
- 适合实时流控场景

三、关键性能指标对比

| 算法类型 | 时间复杂度 | 空间复杂度 | 突发流量 | 平滑度 | 实现复杂度 |
|----------------|------------|------------|----------|--------|------------|
| 令牌桶 | O(1) | O(1) | 支持 | 中 | 中 |
| 漏桶 | O(1) | O(1) | 不支持 | 高 | 低 |
| 滑动窗口 | O(log N) | O(N) | 支持 | 低 | 高 |

四、生产环境选型建议

1. 电商抢购：令牌桶算法（允许前期爆发）
2. API网关：漏桶算法（保护下游服务）
3. 实时监控：滑动窗口（精确到秒级控制）

避坑指南：
- 使用Pipeline减少网络往返
- 设置合理的key过期时间
- 集群环境下采用一致性哈希分片

五、高级优化技巧

1. 本地缓存+Redis二级校验：
   java // 伪代码示例 if (localBucket.tryAcquire()) { return redisLimiter.acquire(); }

2. 动态限流调整：python

   
   
   

   根据CPU负载自动调整速率

   
   
   

   def dynamiclimit(): load = getcpuload() baserate = 1000 # 默认QPS
   return base_rate * (1 - load/100)

3. 分级限流策略：
   text /api/v1/payment => 1000 QPS /api/v1/payment/wechat => 300 QPS

掌握这些核心要点后，您的系统将具备面对流量冲击时的"自适应盔甲"。