Redis 分布式限流器的三种 Lua 实现

举报
yd_227606267 发表于 2026/11/19 07:41:01 2026/11/19
【摘要】 固定窗口、滑动窗口、令牌桶的 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) | 平均速率精确 | 允许受控突发 | 接口级保护、调用下游 |

常见坑 / 最佳实践

  1. INCR 与 EXPIRE 分开写在应用代码里。 应用在两条命令之间崩溃,key 永不过期、计数只增不清,所有用户被永久限流;必须包进 Lua,且只在 INCR 返回 1 时设过期。
  2. 用客户端时钟算窗口。 多实例时钟偏差让窗口错位,Lua 里调 TIME 以 Redis 时间为准。
  3. 滑动窗口用于全站高 QPS 接口。 成员数与 QPS × 窗口成正比,高流量接口换令牌桶,O(1) 内存。
  4. 被限流直接报 500。 前端会立即重试放大流量,应返回 429 + Retry-After,引导客户端退避。
  5. 只做一层限流。 单靠 Redis 限流,Redis 故障时防线全失;重要接口在网关层再加一道本地限流兜底。

小结

  • 分布式限流的原子性靠 Lua:判断与计数在 Redis 单线程内一气呵成。
  • 固定窗口 O(1) 内存但有边界突刺,滑动窗口精确但内存随 QPS 增长,令牌桶 O(1) 且允许受控突发。
  • 令牌桶用「时间差懒补令牌」代替定时器,Redis 只存令牌数与时间戳。
  • 限流 key 要带维度(用户/IP/接口/全局),拒绝时返回 429 引导退避,Redis 之外还要有本地限流兜底。
【声明】本内容来自华为云开发者社区博主,不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0)

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。