Lua 脚本


原子性问题

在使用 Redis 时,我发现了一个棘手的问题。

问题在哪里?

场景:用户快速点击两次点赞

时间线:
T1: 线程 A 检查 → 未点赞
T2: 线程 B 检查 → 未点赞(同时)
T3: 线程 A 添加点赞 → 成功
T4: 线程 B 添加点赞 → 成功(重复!)
T5: 线程 A 计数 +1 → 101
T6: 线程 B 计数 +1 → 102

结果:
- 点赞集合:用户 ID 重复
- 计数:102(应该是 101)
→ 数据不一致!

原因:三个操作不是原子的。

解决方案:Lua 脚本。


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 次命令调度完全不需要原子性时
Pipeline1 次往返3 次命令调度需要减少往返,但不要求原子
EVAL1 次往返解析 + 执行脚本小、调用不频繁
EVALSHA1 次往返直接执行脚本大、调用频繁

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 scriptEVALSHA 的 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

解题思路:

这道题问的是 Lua 脚本的原子性从哪来,要从 Redis 的单线程命令执行模型讲起,说明脚本是被当作一条命令整体执行的。

详细步骤:

Redis 单线程模型:

Redis 执行命令的顺序:
1. 客户端 A 发送命令
2. Redis 执行命令
3. 客户端 B 发送命令
4. Redis 执行命令
5. ...

关键点:
- Redis 是单线程的
- 命令按顺序执行
- 一个命令执行期间,其他命令等待

Lua 脚本:
- 整个脚本作为一个命令
- 执行期间不会被其他命令打断
- 保证原子性

最终答案:

原子性来自 Redis 的单线程命令执行模型——所有命令在同一个线程里顺序执行,一个命令执行期间不会被其他命令打断。Lua 脚本在 Redis 中被当作一条命令整体执行,执行期间其他客户端的命令只能排队等待,因此脚本里的读取、判断与更新被合成了一次不可分割的状态变化。

练习 2

Lua 脚本如何处理错误?

Lua错误处理调试

解题思路:

这道题问的是脚本执行出错时怎么让调用方知道、以及出错后状态是否干净,要区分『加载期错误』和『运行期错误』。

详细步骤:

错误处理方案:

原子操作要点

  • 这里关注的是把读取、判断和更新合成一个不可打断的状态变化,而不是记住脚本语法。

两类错误:

  1. 加载期错误:语法错误、Lua 版本不支持的 API → 脚本根本加载不进去,EVAL 直接返回错误
  2. 运行期错误:类型错误(如对 string 调用 list 命令)、键类型不对 → 脚本执行到该行中止

处理方式:

  • 客户端捕获返回的 error 字段,按业务语义决定重试还是告警
  • 脚本内部先做参数与类型的校验,把所有校验放在写操作之前
  • 注意:运行期错误中止脚本,但之前已执行的写操作不会回滚,所以校验必须前置
  • 在脚本开头用 redis.call('TYPE', KEYS[1]) 校验键类型,避免误用

最终答案:

脚本出错时 Redis 会把错误信息返回给客户端,调用方据此判断失败并重试或告警。设计上要让脚本尽量『不产生部分写入』:先做所有校验(参数类型、键的类型与状态是否合法),全部通过后再执行写操作;运行期错误会中止脚本,但已执行的写入不会回滚,因此关键校验必须前置。Redis 7 之后还可以用 FUNCTION 配合错误处理来获得更细粒度的控制。

练习 3

如何优化 Lua 脚本的性能?

Lua性能优化最佳实践

解题思路:

这道题问的是脚本为什么慢、要优化什么,要从『脚本会阻塞整个 Redis 实例』这个前提出发,落到减少 key 数量、减少往返、缩短执行时间三点。

详细步骤:

优化技巧:

原子操作要点

  • 这里关注的是把读取、判断和更新合成一个不可打断的状态变化,而不是记住脚本语法。

具体做法:

  1. 减少 KEY 数量:脚本只操作必须访问的 key,跨分片操作不如直接用 pipeline
  2. 避免 O(N) 操作:不要在脚本里对大 Set/Hash 做全量遍历,改为分批
  3. 减少网络往返:把『读—判断—写』合并为一个脚本,而不是多次 EVAL
  4. 控制脚本时长:Lua 脚本执行期间会阻塞整个实例,控制在毫秒级
  5. 不要在脚本里使用全局变量访问 key,改用 KEYS/ARGV 传入,保证 Cluster 下的路由正确

最终答案:

优化要点是让脚本尽可能短、访问的 key 尽可能少:只传真正需要的 KEYS(不要用全局变量拼 key)、把多次操作合并进一个脚本以减少网络往返、避免在脚本里做 O(N) 的遍历(如对大集合做 SMEMBERS)、把脚本执行时间控制在毫秒级。脚本过长会阻塞整个实例,因此热门 key 的脚本必须先压测再上线。

练习 4

Lua 脚本如何访问全局变量?

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 脚本的”版本管理”?

Lua版本管理运维

解题思路:

这道题问的是脚本迭代后旧脚本怎么办,核心是『脚本内容变了但 key 一样怎么办』。

详细步骤:

方案:脚本版本化

版本管理要点:

  1. 用 SHA1 标识脚本内容:同一份内容只加载一次,调用时用 EVALSHA 传 SHA,省带宽
  2. 加显式业务版本号:like_inc:v3,便于灰度、排查与回滚
  3. 发布流程:SCRIPT LOAD 新脚本 → 灰度切版本 → 观察指标 → 全量切换 → 保留旧版本一段时间
  4. 处理 NOSCRIPT 错误:脚本缓存被清空后 EVALSHA 会报错,客户端捕获后重新 SCRIPT LOAD 再重试
  5. Redis 7 可用 FUNCTION + 库(library)做统一注册与版本管理

最终答案:

用版本号管理:把脚本内容计算成 SHA1 作为脚本标识发布(SCRIPT LOAD + EVALSHA),并为脚本维护一个显式的业务版本号(如 like_inc:v3);发布时先加载新脚本、灰度切到新版本号,确认无异常后再下线旧版本,旧版本脚本保留一段时间以便快速回滚。客户端还要处理 NOSCRIPT 错误(脚本缓存被清空后重新加载再重试)。


思考题

  1. Lua 脚本能否访问外部资源(如数据库、网络)?

  2. 如何测试 Lua 脚本的正确性?

  3. Lua 脚本和 Redis 事务有什么区别?

💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。

发现内容有问题?

告诉我们哪里需要改进。