Redis 分布式限流器的三种 Lua 实现
单机限流挡不住多实例流量,网关层限流又离业务太远,接口级的分布式限流通常落在 Redis 上(本文基于 Redis 7)。固定窗口、滑动窗口、令牌桶三种算法各有取舍,核心难点是「判断与计数」的原子性。本文给出三种算法的 Lua 实现与选型建议。
一、为什么判断和计数必须原子
限流的逻辑只有一句:请求数没超就放行并计数,超了就拒绝。拆成「读计数、比较、写计数」三条命令,并发下多个实例同时读到同一个旧值、全部放行,限流直接失效。Redis 的 Lua 脚本在单线程内连续执行,中间不会插入其他命令,这是所有方案的基础设施。下面三个脚本都可以用 EVAL 直接验证,也可以通过 Spring Data Redis 的 execute 嵌入业务。
二、固定窗口:最简单,但有边界突刺
-- KEYS[1] 计数 key,ARGV[1] 窗口秒数,ARGV[2] 上限
local current = redis.call('INCR', KEYS[1])
if current == 1 then
redis.call('EXPIRE', KEYS[1], tonumber(ARGV[1]))
end
if current > tonumber(ARGV[2]) then
return 0
end
return 1
INCR 返回 1 说明是新窗口的第一次访问,此时设置过期时间,之后只增不设。整个脚本两条 Redis 调用,性能最好,内存只有一个 key。
缺陷在窗口边界:限制每分钟 100 次,第 59 秒放行 100 次、第 61 秒又放行 100 次,两秒内实际通过 200 次。对「防突发」要求不高的接口(防爬虫、防重复提交)可以接受,要求高就上滑动窗口。
三、滑动窗口:用 ZSet 记录每次请求
-- KEYS[1] 窗口 ZSet,ARGV[1] 窗口秒数,ARGV[2] 上限,ARGV[3] 请求唯一 ID
local t = redis.call('TIME')
local now = tonumber(t[1])
local window = tonumber(ARGV[1])
local limit = tonumber(ARGV[2])
redis.call('ZREMRANGEBYSCORE', KEYS[1], 0, now - window)
local count = redis.call('ZCARD', KEYS[1])
if count < limit then
redis.call('ZADD', KEYS[1], now, ARGV[3])
redis.call('EXPIRE', KEYS[1], window + 1)
return 1
end
return 0
每个请求占一个成员,score 是时间戳;先清出窗口外的旧记录,再数当前窗口内有多少次。限流精度是真正的任意滑动窗口,没有边界突刺。代价是内存与 QPS 成正比:每秒 1000 次请求、窗口 60 秒,ZSet 里要维护约 6 万个成员。所以它适合低频高价值操作(下单、发短信),不适合全站接口。
四、令牌桶:按速率放行,容忍突发
令牌以固定速率生成进桶,桶满溢出;请求消耗令牌,没令牌就拒绝。它允许短时突发(桶里攒的令牌),又限制长期平均速率,是网关和云厂商限流的主流算法:
-- KEYS[1] 桶 key,ARGV[1] 每秒令牌数,ARGV[2] 桶容量,ARGV[3] 本次消耗
local t = redis.call('TIME')
local now = tonumber(t[1])
local rate = tonumber(ARGV[1])
local capacity = tonumber(ARGV[2])
local need = tonumber(ARGV[3])
local info = redis.call('HMGET', KEYS[1], 'tokens', 'ts')
local tokens = tonumber(info[1]) or capacity
local ts = tonumber(info[2]) or now
tokens = math.min(capacity, tokens + (now - ts) * rate)
local allowed = 0
if tokens >= need then
tokens = tokens - need
allowed = 1
end
redis.call('HSET', KEYS[1], 'tokens', tokens, 'ts', now)
redis.call('EXPIRE', KEYS[1], math.ceil(capacity / rate) * 2 + 1)
return allowed
令牌数不靠定时器补充,而是每次请求时按时间差懒计算,Redis 里只存两个数字,内存 O(1)。EXPIRE 按「装满一桶时间的两倍」设置,闲置的桶自动回收。
这个脚本有三处值得逐行确认的细节。info[1] 为 false(Lua 中对应 nil)时取 capacity,让新建的桶一开始就是满的,这是「允许突发」的前提;如果要冷启动从空桶开始,把默认值改成 0。tokens + (now - ts) * rate 必须用 math.min 夹住容量上限,否则闲置一天的桶会攒出天文数字的令牌,一放行就是洪峰。EXPIRE 用 capacity / rate 的两倍,是因为「装满一桶」至少要这么久,比它短会让活跃的桶在补充过程中被误删。
实际测试一桶的突发能力:rate=10、capacity=100 时,一个空闲 10 秒以上的桶能瞬间放行 100 个请求,之后每秒只放 10 个。这个行为对「下游能扛瞬时 100 但扛不住持续 100/s」的场景正好,反过来如果下游连 100 的瞬时都扛不住,就要把 capacity 压到与 rate 接近,让它退化成漏桶。
令牌桶的 Lua 每次请求都要 TIME + HMGET + HSET + EXPIRE 四次内部调用。EVAL 本身的开销很小,但 EXPIRE 每次都执行属于浪费——桶的 TTL 只需要在首次创建时设置,后续重置意义不大(每次都重置等于「永不回收」,反而失去了清理闲置桶的作用)。把 EXPIRE 挪到 info[1] 为空的初始化分支里,既省一次调用,又让闲置桶真正能被回收。
五、滑动窗口的折中:计数器分桶
精确滑动窗口的内存代价让很多人退而求其次,用「分桶计数」近似:把窗口切成若干等份(比如 60 秒切成 6 个 10 秒的桶),每个桶一个计数器,总和就是窗口内的请求数。
-- KEYS[1] 计数 Hash,ARGV[1] 桶宽秒,ARGV[2] 桶数,ARGV[3] 上限
local t = redis.call('TIME')
local now = tonumber(t[1])
local width = tonumber(ARGV[1])
local buckets = tonumber(ARGV[2])
local limit = tonumber(ARGV[3])
local idx = math.floor(now / width) % buckets
local field = 'b' .. idx
local total = 0
for i = 0, buckets - 1 do
total = total + tonumber(redis.call('HGET', KEYS[1], 'b' .. i) or '0')
end
if total >= limit then return 0 end
redis.call('HINCRBY', KEYS[1], field, 1)
redis.call('EXPIRE', KEYS[1], width * buckets + 1)
return 1
关键点是「当前桶」的计数包含了本桶内还没过去的时段,所以实际限制偏严格;桶越宽越严格,也越省内存。buckets 个字段固定,内存与 QPS 无关,精度损失在「最多多放行一个桶的量」这一档。idx 取模保证环形复用,配合 EXPIRE 时间够了。
| 方案 | 内存量级 | 精度 | 每次判定开销 |
| --- | --- | --- | --- |
| 精确 ZSet 滑动窗口 | QPS × 窗口秒 | 精确 | 1 次 ZREMRANGE + 1 次 ZCARD + 1 次 ZADD |
| 分桶计数 | 桶数(常量) | 误差 ≤ 一个桶 | 桶数次 HGET |
| 令牌桶 | 1 个 Hash | 平均速率精确 | TIME + HMGET + HSET |
分桶适合「窗口较长、QPS 很高」的场景,比如「每手机号每天最多 20 次短信」,窗口 86400 秒切成 24 个桶,误差完全可以接受。
六、Java 接入与维度设计
public boolean allow(String dim, int windowSec, int limit) {
Long ok = redis.execute(new DefaultRedisScript<>(FIXED_WINDOW_LUA, Long.class),
List.of("rl:" + dim),
String.valueOf(windowSec), String.valueOf(limit));
return ok != null && ok == 1;
}
// 用户维度与接口维度组合使用
boolean ok = allow("sms:u:1001", 60, 5);
维度设计决定限流的效果:按用户、按 IP、按接口、按全局,通常组合使用——用户维度防单点滥用,全局维度保护下游(比如短信通道总量)。被限流的请求返回 429 并携带重试间隔,而不是裸抛 500。
三组维度要按「谁受损」来划分,而不是按「方便传什么」:用户维度防单个账号刷接口,IP 维度防同一出口的批量请求(注意 NAT 后大量用户共享 IP,阈值要放大),接口维度防某个慢接口被洪峰打穿,全局维度保下游容量。三层叠加时,任意一层拒绝即拒绝,判定顺序从最便宜的开始——先查本地限流,再查全局令牌桶,最后才查需要额外查询的用户维度,能省下大量 Redis 往返。
Redis Cluster 下还有一个必须注意的点:限流脚本的多个 KEYS 必须落在同一个 slot。上面三个脚本都只用了一个 key,天然满足;如果想把「用户维度 + 全局维度」放进同一个脚本,key 名要带相同的 hash tag,例如 rl:{sms}:u:1001 与 rl:{sms}:global,否则会报 CROSSSLOT Keys in request don't hash to the same slot。单个脚本只操作一个 key、在业务层串行判两次,通常是更省心的选择。
被拒绝时的重试间隔要算出来告诉客户端。固定窗口剩多少秒可以直接从 key 的 TTL 读;令牌桶按「还差几个令牌 ÷ 速率」估算;滑动窗口看窗口内最早一条记录的 score 加窗口长度。把这些值塞进 Retry-After 头,客户端才能做正确的退避,否则它只会盲目重试。
三种算法对比:
| 算法 | 内存 | 精度 | 突发 | 适用 |
| --- | --- | --- | --- | --- |
| 固定窗口 | O(1) | 有边界突刺 | 不控制 | 防刷、防重 |
| 滑动窗口 | O(窗口内请求数) | 精确 | 严格平滑 | 低频高价值操作 |
| 令牌桶 | O(1) | 平均速率精确 | 允许受控突发 | 接口级保护、调用下游 |
常见坑 / 最佳实践
- INCR 与 EXPIRE 分开写在应用代码里。 应用在两条命令之间崩溃,key 永不过期、计数只增不清,所有用户被永久限流;必须包进 Lua,且只在 INCR 返回 1 时设过期。
- 用客户端时钟算窗口。 多实例时钟偏差让窗口错位,Lua 里调
TIME以 Redis 时间为准。 - 滑动窗口用于全站高 QPS 接口。 成员数与 QPS × 窗口成正比,高流量接口换令牌桶,O(1) 内存。
- 被限流直接报 500。 前端会立即重试放大流量,应返回 429 + Retry-After,引导客户端退避。
- 只做一层限流。 单靠 Redis 限流,Redis 故障时防线全失;重要接口在网关层再加一道本地限流兜底。
小结
- 分布式限流的原子性靠 Lua:判断与计数在 Redis 单线程内一气呵成。
- 固定窗口 O(1) 内存但有边界突刺,滑动窗口精确但内存随 QPS 增长,令牌桶 O(1) 且允许受控突发。
- 令牌桶用「时间差懒补令牌」代替定时器,Redis 只存令牌数与时间戳。
- 限流 key 要带维度(用户/IP/接口/全局),拒绝时返回 429 引导退避,Redis 之外还要有本地限流兜底。
- 点赞
- 收藏
- 关注作者
评论(0)