Lua 脚本
在使用 Redis 时,我发现了一个棘手的问题。
问题在哪里?
场景:用户快速点击两次点赞
时间线:
T1: 线程 A 检查 → 未点赞
T2: 线程 B 检查 → 未点赞(同时)
T3: 线程 A 添加点赞 → 成功
T4: 线程 B 添加点赞 → 成功(重复!)
T5: 线程 A 计数 +1 → 101
T6: 线程 B 计数 +1 → 102
结果:
- 点赞集合:用户 ID 重复
- 计数:102(应该是 101)
→ 数据不一致!
原因:三个操作不是原子的。
解决方案:Lua 脚本。
什么是 Lua 脚本?
Lua 脚本:
- Redis 支持的脚本语言
- 在 Redis 服务器端执行
- 保证原子性
- 减少网络往返
为什么能保证原子性?
Redis 执行 Lua 脚本的过程:
1. 客户端发送 Lua 脚本
2. Redis 解析脚本
3. Redis 执行脚本(单线程,不会被打断)
4. 返回结果
关键点:
- Redis 是单线程的
- 执行 Lua 脚本时,其他命令等待
- 整个脚本是一个原子操作
示意图:
不使用 Lua 脚本:
客户端 → Redis: SISMEMBER → 客户端 → Redis: SADD → 客户端 → Redis: INCR
↑____________↑____________________↑
3 次网络往返,可能被其他请求打断
使用 Lua 脚本:
客户端 → Redis: 执行整个脚本 → 返回结果
↑________________________↑
1 次网络往返,原子执行
点赞操作
把”查是否点赞 → 写点赞集合 → 加计数”三步合成一个脚本。
-- like.lua
-- KEYS[1] = 点赞集合 article:{id}:liked_users
-- KEYS[2] = 计数器 article:{id}:like_count
-- ARGV[1] = user_id
local liked = redis.call('SISMEMBER', KEYS[1], ARGV[1])
if liked == 1 then
-- 已经赞过:幂等返回当前计数,不做任何修改
return {0, tonumber(redis.call('GET', KEYS[2]) or '0')}
end
redis.call('SADD', KEYS[1], ARGV[1])
local count = redis.call('INCR', KEYS[2])
return {1, count}
Python 调用:
LIKE_SCRIPT = """
local liked = redis.call('SISMEMBER', KEYS[1], ARGV[1])
if liked == 1 then
return {0, tonumber(redis.call('GET', KEYS[2]) or '0')}
end
redis.call('SADD', KEYS[1], ARGV[1])
local count = redis.call('INCR', KEYS[2])
return {1, count}
"""
def like_article(article_id, user_id):
"""点赞:Lua 脚本保证三步原子"""
liked_key = f"article:{article_id}:liked_users"
count_key = f"article:{article_id}:like_count"
changed, count = redis.eval(
LIKE_SCRIPT, 2, liked_key, count_key, user_id
)
return {"liked": True, "changed": bool(changed), "like_count": count}
返回值的设计:
Lua 脚本返回的是 table,Python 侧拿到的是 list。约定 {0, count} 表示”没变化”、{1, count} 表示”状态变了”,前端据此决定要不要播动画。
为什么脚本能保证原子性?
Redis 执行脚本期间不会执行其他命令——整个脚本就是一个不可分割的原子单元。上面那三步在服务端一口气完成,中间不会被另一个点赞请求插进来。
这个脚本解决的问题正是本章开头那个场景:
没有脚本:
T1: 线程 A SISMEMBER → 0
T2: 线程 B SISMEMBER → 0 ← 两个请求都认为"没赞过"
T3: 线程 A SADD → 1
T4: 线程 B SADD → 1 ← 集合里只有一个用户(Set 去重)
T5: 线程 A INCR → 101
T6: 线程 B INCR → 102 ← 计数比实际多 1 ❌
有脚本:
脚本执行期间没有其他命令能插入
→ 集合和计数永远同步 ✅
取消点赞
取消点赞是对称的操作,同样要在一个脚本里完成。
-- unlike.lua
-- KEYS[1] = 点赞集合 article:{id}:liked_users
-- KEYS[2] = 计数器 article:{id}:like_count
-- ARGV[1] = user_id
local removed = redis.call('SREM', KEYS[1], ARGV[1])
if removed == 0 then
-- 本来就没赞过:幂等返回,计数不动
return {0, tonumber(redis.call('GET', KEYS[2]) or '0')}
end
local count = redis.call('DECR', KEYS[2])
-- 防御:计数不能变成负数
if count < 0 then
redis.call('SET', KEYS[2], 0)
count = 0
end
return {1, count}
为什么这里要加”不能为负”的防御?
正常情况下 SREM 返回 1 说明集合里确实有这条记录,计数减一是对的。但历史数据被改坏过、或者计数和集合本来就对不上时,DECR 可能把数字减到负数。
减到 -1 之后:
页面显示 "-1 个赞" ❌
后续每次点赞变成 0,用户会以为赞丢了
脚本里的兜底把这种情况拉回 0,至少不会展示出负数。真正的修复交给对账任务。
点赞和取消点赞脚本的返回值约定要一致。
两个脚本都返回 {changed, count},调用方可以用同一套逻辑处理:
changed = 0 → 状态没变,前端不播动画
changed = 1 → 状态变了,前端播动画
批量操作
一次点赞多篇文章时,如果每篇都单独调脚本,就是 N 次网络往返。用一个脚本处理所有文章。
-- batch_like.lua
-- KEYS[1..N] = 每篇文章的计数器
-- KEYS[N+1..2N] = 每篇文章的点赞集合
-- ARGV[1..N] = 每篇文章对应的 user_id
local n = #KEYS / 2
local results = {}
for i = 1, n do
local count_key = KEYS[i]
local liked_key = KEYS[n + i]
local user_id = ARGV[i]
if redis.call('SISMEMBER', liked_key, user_id) == 1 then
-- 已赞过:原样返回当前计数
results[i] = {0, tonumber(redis.call('GET', count_key) or '0')}
else
redis.call('SADD', liked_key, user_id)
results[i] = {1, redis.call('INCR', count_key)}
end
end
return results
def batch_like(article_ids, user_id):
"""批量点赞:一次往返处理所有文章"""
count_keys = [f"article:{aid}:like_count" for aid in article_ids]
liked_keys = [f"article:{aid}:liked_users" for aid in article_ids]
keys = count_keys + liked_keys
args = [str(user_id)] * len(article_ids)
raw = redis.eval(BATCH_LIKE_SCRIPT, len(keys), *keys, *args)
return [
{"article_id": aid, "changed": bool(r[0]), "like_count": r[1]}
for aid, r in zip(article_ids, raw)
]
批量脚本的三个注意点:
1. KEYS 的数量要控制。
脚本里循环遍历 KEYS,KEYS 越多执行时间越长,超过 lua-time-limit 会被判定为慢脚本。建议单次批量不超过 100 篇,超了就分批。
2. 所有 key 必须声明在 KEYS 里。
Redis Cluster 模式下,只有声明在 KEYS 里的 key 才会被路由到正确的节点。在脚本里用字符串拼接 key 会导致 MOVED 错误。
3. 批量操作的原子性范围更大。
整个批次在一个脚本里执行,期间其他命令全部排队。批次越大,其他请求的等待时间越长。要在”减少往返”和”阻塞其他请求”之间取平衡。
条件更新
有些场景需要在满足条件时才更新,比如”点赞数不超过 10000 时才算有效”、“只有未关注的用户才能点赞”。
-- conditional_like.lua
-- KEYS[1] = 点赞集合
-- KEYS[2] = 计数器
-- ARGV[1] = user_id
-- ARGV[2] = 最大允许的点赞数
local max_count = tonumber(ARGV[2])
local current = tonumber(redis.call('GET', KEYS[2]) or '0')
if current >= max_count then
-- 达到上限:不点赞,返回当前值和原因码
return {-1, current}
end
if redis.call('SISMEMBER', KEYS[1], ARGV[1]) == 1 then
return {0, current}
end
redis.call('SADD', KEYS[1], ARGV[1])
local count = redis.call('INCR', KEYS[2])
return {1, count}
返回值用不同的码表达不同语义:
| 返回值 | 含义 | 调用方处理 |
|---|---|---|
{1, count} | 点赞成功 | 正常返回 |
{0, count} | 已赞过,幂等 | 返回”已赞”状态 |
{-1, count} | 达到上限,被拒绝 | 返回 403 或降级提示 |
条件判断为什么必须放在脚本里?
脚本外判断:
count = GET key → 100
if count < max: ← 这两行之间可能被别的请求插进来
INCR key → 可能变成 101
→ 超过上限了 ❌
脚本内判断:
GET + 比较 + INCR 在服务端原子完成 → 永远不会越界 ✅
典型的条件更新场景:
1. 活动限流:每天最多 1000 个赞
2. 等级加成:VIP 用户的赞算 2 个
3. 风控拦截:命中黑名单的用户不计赞
4. 冷却期:同一用户 1 分钟内只能赞一次
注意:脚本里的条件判断仍然会有”时间窗口”问题。
脚本原子性只保证”检查”和”修改”之间不被打断,它不能阻止”检查完之后、条件被外部改变”。比如限流计数如果是另一个 key,更新它时依然要在同一个脚本里。
复杂业务逻辑
当点赞要联动其他动作时,脚本的价值更明显:一次脚本完成”计数 + 等级 + 通知”,中间不会有半完成状态。
-- complex_like.lua
-- KEYS[1] = 计数器 article:{id}:like_count
-- KEYS[2] = 点赞集合 article:{id}:liked_users
-- KEYS[3] = 作者获赞总数 author:{uid}:total_likes
-- ARGV[1] = user_id
-- ARGV[2] = author_id
-- ARGV[3] = 等级阈值(达到后触发升级)
local user_id = ARGV[1]
local author_id = ARGV[2]
local threshold = tonumber(ARGV[3])
if redis.call('SISMEMBER', KEYS[2], user_id) == 1 then
return {0, tonumber(redis.call('GET', KEYS[1]) or '0'), 0}
end
redis.call('SADD', KEYS[2], user_id)
local count = redis.call('INCR', KEYS[1])
local author_total = redis.call('INCR', KEYS[3])
-- 达到阈值时触发一次升级事件(用 SETNX 保证只触发一次)
local level_up = 0
if author_total >= threshold then
local flag = f'author:{author_id}:levelup:{threshold}'
if redis.call('SETNX', flag, 1) == 1 then
redis.call('EXPIRE', flag, 86400)
level_up = 1
end
end
return {1, count, level_up}
用 SETNX 保证升级事件只触发一次。
如果直接用 if author_total >= threshold then ...,每次越过阈值都会重复触发。SETNX 让”第一次越过”成为唯一一次。
作者获赞: 999 → 1000 ✅ 触发升级(SETNX 成功)
1000 → 1001 ❌ SETNX 失败,不重复触发
脚本的边界:能读什么,不能做什么。
能做:
- 读写同一个 Redis 实例上的 key
- 做计算、判断、循环
- 触发 PUBLISH 消息
不能做:
- 访问数据库、外部 HTTP 接口
- 调用系统时间之外的阻塞操作
- 写另一个节点的 key(集群模式下会报 MOVED)
所以”升级”之后真正要做的事(发通知、写日志、调服务),应该通过 PUBLISH 抛给订阅方异步处理,而不是在脚本里同步做。
脚本越复杂,阻塞风险越高。
复杂的脚本会让 Redis 主线程卡住,影响所有其他请求。生产上要把脚本控制在”简单判断 + 少量读写”的范围内。
脚本缓存
每次 EVAL 都要把脚本源码传到 Redis,传输 + 解析的开销在脚本较大时很明显。EVALSHA 用脚本的 SHA1 摘要来代替源码。
# 第一次:完整脚本 + 返回 SHA1
redis-cli SCRIPT LOAD "return 1"
"e0e1f9fabfc9d4800c877a703b823ac0578ff831"
# 之后:用 SHA1 调用
redis-cli EVALSHA e0e1f9fabfc9d4800c877a703b823ac0578ff831 0
LIKE_SCRIPT_SHA = "e0e1f9fabfc9d4800c877a703b823ac0578ff831"
def like_article(article_id, user_id):
"""优先走 EVALSHA,未命中时回退到 EVAL 并重新加载"""
liked_key = f"article:{article_id}:liked_users"
count_key = f"article:{article_id}:like_count"
try:
changed, count = redis.evalsha(
LIKE_SCRIPT_SHA, 2, liked_key, count_key, user_id
)
except NoScriptError:
# 脚本不在缓存里(Redis 重启 / 换了实例),重新加载
redis.script_load(LIKE_SCRIPT)
changed, count = redis.eval(
LIKE_SCRIPT, 2, liked_key, count_key, user_id
)
return {"liked": True, "changed": bool(changed), "like_count": count}
NoScriptError 是必须处理的异常。
脚本缓存会因为这些原因丢失:
- Redis 重启(脚本缓存在内存里,重启就没了)
- Redis 主从切换 / 集群扩缩容(换了一个新实例)
- SCRIPT FLUSH(运维手动清空)
如果只写 EVALSHA 不做回退,Redis 一重启,所有点赞请求就会报错。
Python 客户端的封装建议:
def eval_with_cache(script, sha, numkeys, *keys_and_args):
"""统一的 EVALSHA 封装:未命中自动加载并重试一次"""
try:
return redis.evalsha(sha, numkeys, *keys_and_args)
except NoScriptError:
redis.script_load(script)
return redis.evalsha(sha, numkeys, *keys_and_args)
用 SCRIPT LOAD 提前预热。
发布流程:
1. 应用启动时:SCRIPT LOAD 把所有脚本灌进 Redis
2. 记录返回的 SHA1,写进配置
3. 运行期只用 EVALSHA
这样避免了运行期第一次调用时的 NoScriptError 抖动。
SHA1 的生成:
SHA1 是脚本源码的字节序列的摘要。必须保证:
- 脚本源码一个字节都不能差(包括空格和换行)
- 用的 redis-cli / Python 传入的内容与 SCRIPT LOAD 时完全一致
# 用 redis-cli 生成 SHA1
redis-cli SCRIPT LOAD "$(cat like.lua)"
# 或者用 Python
import hashlib
sha = hashlib.sha1(LIKE_SCRIPT.encode()).hexdigest()
脚本管理:
redis-cli SCRIPT EXISTS <sha> # 是否存在
redis-cli SCRIPT FLUSH # 清空所有脚本缓存(慎用)
redis-cli INFO memory # 观察脚本缓存占用的内存
一个优化技巧:把公共逻辑抽成小函数。
多个脚本共用一段逻辑时,可以把这段逻辑单独存成一个”子脚本”,主脚本用 redis.call('redis.sha1hex', ...) 拿到它的 SHA1 再调用。不过这会让脚本之间的依赖变复杂,通常只有脚本数量多时才值得。
性能对比
场景:点赞脚本约 20 行,一次请求包含 3 个 key
EVAL(每次传完整源码):
- 网络传输:约 500 字节源码
- Redis 解析:每次都要重新解析
- 响应时间:P50 0.35ms
EVALSHA(命中缓存):
- 网络传输:40 字节 SHA1
- Redis 直接用已编译的脚本
- 响应时间:P50 0.28ms
| 方式 | 网络传输 | 服务端开销 | 适用 |
|---|---|---|---|
| 三条独立命令 | 3 次往返 | 3 次命令调度 | 完全不需要原子性时 |
| Pipeline | 1 次往返 | 3 次命令调度 | 需要减少往返,但不要求原子 |
| EVAL | 1 次往返 | 解析 + 执行 | 脚本小、调用不频繁 |
| EVALSHA | 1 次往返 | 直接执行 | 脚本大、调用频繁 |
Pipeline 和 Lua 的本质区别:
Pipeline:网络层面的批量,命令之间仍然可以被打断
Lua: 逻辑层面的原子,脚本期间不会有其他命令插入
需要原子性就必须用 Lua;只是嫌往返多,Pipeline 就够了。
脚本越长,EVALSHA 的收益越大。
脚本 5 行: EVAL 0.30ms → EVALSHA 0.29ms 提升不明显
脚本 50 行: EVAL 0.45ms → EVALSHA 0.30ms 提升 50%
脚本 200 行:EVAL 1.20ms → EVALSHA 0.35ms 提升 3 倍
性能优化的顺序:
1. 先用 EVALSHA(改造成本最低,收益稳定)
2. 再减少脚本里的 key 数量(key 越多越慢)
3. 再考虑用 Pipeline 替代不需要原子性的脚本
4. 最后才考虑分片(见《分片计数》一章)
不要过早优化成”一个巨型脚本”。
把 20 个操作塞进一个脚本,会让 Redis 主线程被占住更久,其他请求的延迟会整体上升。脚本的边界应该按”业务原子性”划分,而不是”能合并就合并”。
脚本超时
Lua 脚本在 Redis 主线程上同步执行。执行期间 Redis 不处理任何其他命令——脚本卡住,整个服务就卡住。
时间线:
T0 脚本开始执行(一个死循环)
T1 其他客户端的请求全部排队等待
T2 ... 等待 ...
T3 Redis 判定脚本超时,强制中断它
Redis 的两个相关配置:
# lua-time-limit:脚本最长执行时间(毫秒)
# 默认 5000ms
# 超过后 Redis 会在日志里记 SCRIPT KILL 的建议,并开始接受 SCRIPT KILL 命令
# busy-reply-threshold:Lua 脚本繁忙时,其他命令的等待阈值(毫秒)
# 默认 5000ms
# 超过这个时间还没执行完,其他客户端会收到 BUSY 错误
redis-cli CONFIG GET lua-time-limit
redis-cli CONFIG GET busy-reply-threshold
关键点:Redis 不会真的”杀掉”卡住的脚本。
lua-time-limit 到期后,Redis 只是开始接受 SCRIPT KILL 命令,但它还在等那个脚本自己结束。一个真正的死循环脚本是没法被中断的——Redis 只能重启才能恢复。
所以真正的防线是”不要写出慢脚本”。
慢脚本的常见来源:
1. 循环次数不可控
for i = 1, 1000000 do ... end ❌
→ 循环上界必须来自 KEYS/ARGV,且要设上限
2. 在脚本里做 O(N) 的全量扫描
redis.call('KEYS', '*') ❌ 绝对不要在脚本里用 KEYS 命令
redis.call('SMEMBERS', big_set) ❌ 大集合不要全量取出
3. 一次操作太多 key
批量脚本传入 10000 个 KEYS ❌ 要分批
4. 脚本里调用了会阻塞的命令
BLPOP、BRPOP、BLPOP 等 ❌ 脚本里不能用阻塞命令
给循环加上硬性上限:
-- batch_like.lua 里加一道保护
local n = #KEYS / 2
if n > 100 then
return redis.error_reply('TOO_MANY_KEYS: batch limited to 100')
end
监控慢脚本:
# Redis 6.0+ 提供慢日志
redis-cli SLOWLOG GET 10
# 查看命令统计,找出执行最慢的脚本
redis-cli LATENCY LATEST
redis-cli COMMANDSTATS | grep -i eval
超时的应对策略:
| 情况 | 应对 |
|---|---|
| 偶发超时 | 提高 lua-time-limit,优化脚本逻辑 |
| 频繁超时 | 拆分脚本,改用 Pipeline + 业务层保证幂等 |
| 服务已卡死 | SCRIPT KILL;无效则重启 Redis |
SCRIPT KILL 的前提条件:
- 当前没有正在执行的脚本
- 调用者已经用 SCRIPT LOAD 加载了一个脚本
所以它的用途主要是”在知道有脚本卡住时,清理现场准备重启”,不是日常操作。
脚本调试
Lua 脚本出错时,报错信息往往很难定位。几个实用的调试手段:
1. 用 redis-cli 直接跑脚本:
redis-cli EVAL "return {KEYS[1], ARGV[1]}" 1 mykey 123
交互式调试时可以直接把脚本贴进 redis-cli:
redis-cli
> EVAL "local c = redis.call('GET', KEYS[1]); return c" 1 article:123:like_count
"101"
2. 先用 redis-cli --ldb 做本地调试:
redis-cli --ldb script.lua
--ldb(Lua Debugger)可以在本地逐步执行脚本,不用真的连上 Redis 写入数据。适合调试纯逻辑部分。
3. 用 MONITOR 观察脚本实际发出的命令:
redis-cli MONITOR
MONITOR 会把 Redis 收到的每条命令实时打出来。脚本执行期间能看到它到底调用了哪些命令,参数是什么。
1710000000.123456 [0 127.0.0.1:60866] "EVAL" "local liked = redis.call('SISMEMBER'..." "2" "article:123:liked_users" "article:123:like_count" "1001"
1710000000.123789 [0 127.0.0.1:60866] "SISMEMBER" "article:123:liked_users" "1001"
1710000000.123901 [0 127.0.0.1:60866] "SADD" "article:123:liked_users" "1001"
1710000000.123988 [0 127.0.0.1:60866] "INCR" "article:123:like_count"
MONITOR 能看到脚本内部的每一条命令,这是定位”脚本到底做了什么”最直接的手段。
注意 MONITOR 的开销。 它会记录所有命令,生产环境会显著影响性能,只在排查问题时短暂开启。
4. 在脚本里加调试日志:
-- 调试期临时插入
redis.log(redis.LOG_WARNING, 'like script: article=' .. ARGV[1] .. ' changed=' .. tostring(changed))
脚本执行结束后,日志会出现在 Redis 的日志文件里。调试完记得删掉——redis.log 在每个请求上都有开销。
5. 用 SCRIPT DEBUG 观察执行过程:
redis-cli SCRIPT DEBUG YES
配合 EVAL 使用,Redis 会把脚本每一步的调用打印到客户端。
6. Python 侧的错误处理:
try:
changed, count = redis.eval(LIKE_SCRIPT, 2, liked_key, count_key, user_id)
except ResponseError as e:
# 脚本里的 redis.error_reply() 会走到这里
logger.error("like script failed: article=%s error=%s", article_id, e)
raise
常见的脚本错误:
| 报错 | 原因 |
|---|---|
Lua redis lib command arguments must be strings or integers | 传了非字符串/整数类型的参数 |
Script attempted to access nonexistent global variable | 用了 Redis 没提供/拼错的全局函数 |
MOVED <slot> <host>:<port> | 集群模式下 key 没声明在 KEYS 里 |
CROSSSLOT Keys in request don't hash to the same slot | 多个 key 不在同一个 slot |
NOSCRIPT No matching script | EVALSHA 的 SHA1 不存在 |
CROSSSLOT 是集群模式最常见的坑。
同一脚本的所有 key 必须落在同一个 slot 上。解决办法是给 key 加 hash tag:
# 改之前:不同 slot,脚本会报 CROSSSLOT
article:123:like_count
article:123:liked_users
# 加 hash tag:{} 里的内容决定 slot
article:{123}:like_count
article:{123}:liked_users
→ 两个 key 都在 123 这个 slot 上 ✅
点赞 + 限流
把”限流”和”点赞”放在同一个脚本里,能保证限流判断和计数修改之间不会被插队。
-- like_with_rate_limit.lua
-- KEYS[1] = 计数器 article:{id}:like_count
-- KEYS[2] = 点赞集合 article:{id}:liked_users
-- KEYS[3] = 限流计数器 rate:user:{uid}:{minute}
-- ARGV[1] = user_id
-- ARGV[2] = 每分钟最大点赞次数
local user_id = ARGV[1]
local limit = tonumber(ARGV[2])
-- 1. 先限流:窗口内的次数 +1
local current = redis.call('INCR', KEYS[3])
if current == 1 then
-- 窗口的第一个请求,设置过期时间
redis.call('EXPIRE', KEYS[3], 60)
end
if current > limit then
-- 超过限制:撤销这次计数,返回限流错误
redis.call('DECR', KEYS[3])
return {-1, tonumber(redis.call('GET', KEYS[1]) or '0')}
end
-- 2. 再点赞
if redis.call('SISMEMBER', KEYS[2], user_id) == 1 then
return {0, tonumber(redis.call('GET', KEYS[1]) or '0')}
end
redis.call('SADD', KEYS[2], user_id)
local count = redis.call('INCR', KEYS[1])
return {1, count}
def like_with_limit(article_id, user_id, limit=10):
"""点赞 + 限流:一次脚本完成"""
count_key = f"article:{article_id}:like_count"
liked_key = f"article:{article_id}:liked_users"
# 分钟级时间桶,key 里带上分钟数,实现固定窗口
minute_bucket = int(time.time() // 60)
rate_key = f"rate:user:{user_id}:{minute_bucket}"
changed, count = redis.eval(
LIKE_WITH_RATE_LIMIT_SCRIPT, 3,
count_key, liked_key, rate_key,
user_id, limit,
)
if changed == -1:
raise RateLimitExceeded(f"用户 {user_id} 点赞过于频繁")
return {"liked": True, "changed": bool(changed), "like_count": count}
为什么限流和点赞必须在同一个脚本里?
分开做:
T1: INCR rate_key → 11
T2: 检查 11 > 10 → 限流,拒绝
T3: ... 这条路径没问题
但反过来:
T1: 检查 rate_key → 9,未超限
T2: (此时另一个请求把计数推到 11)
T3: INCR rate_key → 12,超限了,但请求已经放行 ❌
“检查”和”自增”分开做,中间就有窗口。脚本把它们合成一个原子操作,超限就一定被拦住。
限流计数用 INCR + EXPIRE 的原子写法。
脚本里 if current == 1 then EXPIRE 是安全的,因为脚本原子执行,没有第二个请求能在这个 if 判断和 EXPIRE 之间插进来。如果放在客户端用两条命令,就有”INCR 成功但 EXPIRE 没执行”的风险——key 永不过期,该用户被永久限流。
固定窗口 vs 滑动窗口:
固定窗口(上面的实现):
- key = rate:user:{uid}:{minute_bucket}
- 每分钟一个 key,到点自然切换
- 缺点:窗口边界可以"刷"——59 秒刷 10 次,60 秒后再刷 10 次
滑动窗口(用 ZSET):
- key = rate:user:{uid}:sliding
- ZSET 存每次请求的时间戳
- 脚本里先 ZREMRANGEBYSCORE 删掉窗口外的,再 ZCARD 计数
- 精确,但内存占用大,脚本也更复杂
多数点赞场景用固定窗口就够了,滑动窗口留给真正严格的反刷场景。
生产环境还要加一层兜底:
- 脚本之外,限流 key 要设置合理的 TTL,防止内存泄漏
- 限流之外,还要有基于账号、设备、IP 的风控识别(见《Redis 计数》的缓存一致性一节)
- 限流计数和业务计数要分开 key,不要混用
练习 1
Lua 脚本如何保证原子性?
解题思路:
这道题问的是 Lua 脚本的原子性从哪来,要从 Redis 的单线程命令执行模型讲起,说明脚本是被当作一条命令整体执行的。
详细步骤:
Redis 单线程模型:
Redis 执行命令的顺序:
1. 客户端 A 发送命令
2. Redis 执行命令
3. 客户端 B 发送命令
4. Redis 执行命令
5. ...
关键点:
- Redis 是单线程的
- 命令按顺序执行
- 一个命令执行期间,其他命令等待
Lua 脚本:
- 整个脚本作为一个命令
- 执行期间不会被其他命令打断
- 保证原子性最终答案:
原子性来自 Redis 的单线程命令执行模型——所有命令在同一个线程里顺序执行,一个命令执行期间不会被其他命令打断。Lua 脚本在 Redis 中被当作一条命令整体执行,执行期间其他客户端的命令只能排队等待,因此脚本里的读取、判断与更新被合成了一次不可分割的状态变化。
练习 2
Lua 脚本如何处理错误?
解题思路:
这道题问的是脚本执行出错时怎么让调用方知道、以及出错后状态是否干净,要区分『加载期错误』和『运行期错误』。
详细步骤:
错误处理方案:
原子操作要点
- 这里关注的是把读取、判断和更新合成一个不可打断的状态变化,而不是记住脚本语法。
两类错误:
- 加载期错误:语法错误、Lua 版本不支持的 API → 脚本根本加载不进去,
EVAL直接返回错误 - 运行期错误:类型错误(如对 string 调用 list 命令)、键类型不对 → 脚本执行到该行中止
处理方式:
- 客户端捕获返回的 error 字段,按业务语义决定重试还是告警
- 脚本内部先做参数与类型的校验,把所有校验放在写操作之前
- 注意:运行期错误中止脚本,但之前已执行的写操作不会回滚,所以校验必须前置
- 在脚本开头用
redis.call('TYPE', KEYS[1])校验键类型,避免误用
最终答案:
脚本出错时 Redis 会把错误信息返回给客户端,调用方据此判断失败并重试或告警。设计上要让脚本尽量『不产生部分写入』:先做所有校验(参数类型、键的类型与状态是否合法),全部通过后再执行写操作;运行期错误会中止脚本,但已执行的写入不会回滚,因此关键校验必须前置。Redis 7 之后还可以用 FUNCTION 配合错误处理来获得更细粒度的控制。
练习 3
如何优化 Lua 脚本的性能?
解题思路:
这道题问的是脚本为什么慢、要优化什么,要从『脚本会阻塞整个 Redis 实例』这个前提出发,落到减少 key 数量、减少往返、缩短执行时间三点。
详细步骤:
优化技巧:
原子操作要点
- 这里关注的是把读取、判断和更新合成一个不可打断的状态变化,而不是记住脚本语法。
具体做法:
- 减少 KEY 数量:脚本只操作必须访问的 key,跨分片操作不如直接用 pipeline
- 避免 O(N) 操作:不要在脚本里对大 Set/Hash 做全量遍历,改为分批
- 减少网络往返:把『读—判断—写』合并为一个脚本,而不是多次 EVAL
- 控制脚本时长:Lua 脚本执行期间会阻塞整个实例,控制在毫秒级
- 不要在脚本里使用全局变量访问 key,改用 KEYS/ARGV 传入,保证 Cluster 下的路由正确
最终答案:
优化要点是让脚本尽可能短、访问的 key 尽可能少:只传真正需要的 KEYS(不要用全局变量拼 key)、把多次操作合并进一个脚本以减少网络往返、避免在脚本里做 O(N) 的遍历(如对大集合做 SMEMBERS)、把脚本执行时间控制在毫秒级。脚本过长会阻塞整个实例,因此热门 key 的脚本必须先压测再上线。
练习 4
Lua 脚本如何访问全局变量?
解题思路:
这道题问的是 Lua 脚本里能不能像普通 Lua 一样用全局变量,答案是被 Redis 的沙箱限制了。
详细步骤:
全局变量限制:
原子操作要点
- 这里关注的是把读取、判断和更新合成一个不可打断的状态变化,而不是记住脚本语法。
限制清单:
- 只能通过
KEYS[]/ARGV[]拿到外部传入的 key 和参数,不能自己拼全局变量名 - 禁用
os、io、require、loadfile、dofile等模块 - 不能使用未授权的命令(不同版本有白名单)
- 不能写死循环(会阻塞整个实例),Redis 5 之后可用忙时检测中断脚本
实践建议:
- 所有外部输入一律走 ARGV,并在脚本开头做类型与合法性校验
- 需要复用的公共逻辑抽成独立的 Lua 文件,在发布流程里拼接进脚本
- 不要在脚本里依赖 Redis 之外的全局状态
最终答案:
Redis 的 Lua 沙箱做了隔离:脚本默认不能访问全局环境(KEYS、ARGV 是通过参数传入的),也不能使用 os、io、loadfile 等危险模块,不能写死循环否则会阻塞整个实例。要访问 key 必须用 KEYS[]、传参用 ARGV[];Redis 7 起还可以通过 FUNCTION 机制安全地暴露受控能力。
练习 5
如何实现 Lua 脚本的”版本管理”?
解题思路:
这道题问的是脚本迭代后旧脚本怎么办,核心是『脚本内容变了但 key 一样怎么办』。
详细步骤:
方案:脚本版本化
版本管理要点:
- 用 SHA1 标识脚本内容:同一份内容只加载一次,调用时用 EVALSHA 传 SHA,省带宽
- 加显式业务版本号:
like_inc:v3,便于灰度、排查与回滚 - 发布流程:SCRIPT LOAD 新脚本 → 灰度切版本 → 观察指标 → 全量切换 → 保留旧版本一段时间
- 处理 NOSCRIPT 错误:脚本缓存被清空后 EVALSHA 会报错,客户端捕获后重新 SCRIPT LOAD 再重试
- Redis 7 可用 FUNCTION + 库(library)做统一注册与版本管理
最终答案:
用版本号管理:把脚本内容计算成 SHA1 作为脚本标识发布(SCRIPT LOAD + EVALSHA),并为脚本维护一个显式的业务版本号(如 like_inc:v3);发布时先加载新脚本、灰度切到新版本号,确认无异常后再下线旧版本,旧版本脚本保留一段时间以便快速回滚。客户端还要处理 NOSCRIPT 错误(脚本缓存被清空后重新加载再重试)。
-
Lua 脚本能否访问外部资源(如数据库、网络)?
-
如何测试 Lua 脚本的正确性?
-
Lua 脚本和 Redis 事务有什么区别?
💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。
发现内容有问题?
告诉我们哪里需要改进。
