知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 08 - 事务与 Lua 脚本 ## Redis 事务 ### 基本命令 ```bash MULTI # 开启事务 EXEC # 执行事务(提交) DISCARD # 放弃事务(回滚) WATCH # 乐观锁,监视 key ``` ### 事务执行流程 ```bash MULTI SET balance 100 INCR counter SET name "张三" EXEC # EXEC 后,三条命令按顺序原子执行 # 输出: # 1) OK # 2) (integer) 1 # 3) OK ``` ### Redis 事务 vs 数据库事务 - **Redis 事务有"执行不可分割"的原子性,但没有"全成功或全失败"的原子性**。 - 为什么redis事务失败了也不会发生回滚。 - Redis 官方的解释是:运行时错误(如对 String 执行 INCR)属于编程错误,不应该在生产环境出现,所以不值得为此付出回滚的性能代价。 - 假设事务有错误呢?此时分为**语法错误和运行时错误** 1. 语法错误(入队时就报错):**整个事务不执行** MULTI SET key value INVALID_COMMAND ← 语法错误,入队失败 EXEC ← 整个事务被放弃 2. 运行时错误(执行时才报错):**只有出错的命令失败,其他命令继续执行** MULTI SET key "hello" INCR key ← 运行时错误(key 是字符串,不能自增) SET other "world" EXEC # 结果: # 1) OK ← SET key 成功 # 2) ERR ← INCR key 失败 # 3) OK ← SET other 成功(没有回滚!) - 成功的成功,失败的失败,不能回滚。 ### WATCH 乐观锁 - "先监视 key → 改之前检查有没有被别人动过 → 没动过才提交,动过就放弃" 的 CAS 机制 ```bash # 场景:转账,需要保证余额充足时才扣减 WATCH balance # 监视 balance val = GET balance # 读取当前余额(100) MULTI DECRBY balance 50 # 扣减 50 EXEC # 如果 WATCH 之后 balance 被其他客户端修改,EXEC 返回 nil(事务失败) # 如果没有被修改,EXEC 正常执行 ``` WATCH 乐观锁执行流程:  *图:WATCH + MULTI/EXEC 实现乐观锁的并发示例* ``` 客户端 A 客户端 B ────────────────────────────────────────────── WATCH balance WATCH balance GET balance → 100 GET balance → 100 MULTI MULTI DECRBY balance 50 DECRBY balance 30 EXEC → OK (先到先得) EXEC → nil (balance 被 A 改了) UNWATCH 重新 WATCH → GET balance → 50 MULTI → DECRBY 30 → EXEC → OK CAS 本质: WATCH → 标记"我关心 balance" EXEC 时检查:标记的 key 有没有被改过? 没改过 → 执行事务 改过了 → 返回 nil,事务放弃 WATCH 的限制: WATCH 不能跨 EXEC 保持(EXEC 后自动取消) 需要循环重试才能实现完整的乐观锁 ``` ```java // 实现乐观锁的完整流程(Java 伪代码): while (true) { redis.watch("balance"); int balance = Integer.parseInt(redis.get("balance")); if (balance < 50) { redis.unwatch(); throw new Exception("余额不足"); } redis.multi(); redis.decrby("balance", 50); List<Object> result = redis.exec(); if (result != null) { break; // 事务成功 } // result == null 说明 balance 被修改,重试 } ``` ## Lua 脚本 ### Redis 事务 vs Lua 脚本 对比  *图:Redis 事务与 Lua 脚本在七个维度上的差异* ``` Redis 事务 (MULTI/EXEC) Lua 脚本 (EVAL) ┌──────────────────────────────────────────────────────────────────────┐ │ 原子性 命令执行期间不插入其他命令 整个脚本原子执行 │ │ 回滚 不支持(语法错误全部不执行, 不支持(执行到一半 │ │ 运行时错误只跳过错误命令) 出错会停止,已执行的 │ │ 不会回滚) │ │ 条件执行 WATCH 实现乐观锁(CAS) 脚本内写 if/else 逻辑 │ │ 复杂度 简单,适合批量命令执行 复杂,支持分支/循环 │ │ 网络开销 每条命令一次往返(除非 Pipeline) 一次 EVAL 全部执行 │ │ 隔离性 命令不交错,但中间可穿插其他命令 完全隔离,不可打断 │ │ 适用场景 简单批量操作、CAS 并发控制 复杂原子操作、限流、 │ │ 分布式锁释放 │ └──────────────────────────────────────────────────────────────────────┘ 核心区别记忆: MULTI/EXEC:命令排好队,EXEC 时一口气执行(中间不会被插队) Lua 脚本:整段代码作为一个原子块执行(连排队的间隙都没有) ``` ### 为什么用 Lua 脚本 - **要么全执行完,要么执行到哪算哪**,redis事务失败不会影响后续,但是lua脚本失败会影响后续 ``` Redis 事务不支持回滚,且两个命令之间可能被其他客户端插入。 Lua 脚本在 Redis 中是原子执行的: 脚本执行期间,Redis 不会处理其他命令 脚本中的所有操作要么全部执行,要么全部不执行(遇到错误时) ``` ### Lua 脚本保证原子性的原理 ``` 原子性在并发编程中和事务中是两个不同的概念: 数据库中的原子性:"要么都执行要么都回滚" 并发编程中的原子性:"操作不可拆分、不被中断" Lua 脚本保证的是并发编程中的原子性: Redis 会将 Lua 脚本封装成一个单独的事务 在脚本执行期间,如果有其他客户端请求,Redis 会暂存起来 等 Lua 脚本处理完毕后,才处理被暂存的请求 → 整个脚本作为一个整体执行,中间不会被其他命令插入 但是:如果命令执行过程中产生错误,事务不会回滚 会影响后续命令的执行(这点和 Redis 事务不同) ``` ### Redis 事务和 Lua 脚本的区别  *图:Redis 事务与 Lua 脚本在四类特性上的对比* ``` 维度 Redis 事务 Lua 脚本 ────────────────────────────────────────────────────────── 原子性 不可中断,但命令失败不影响后续 不可中断,命令失败会影响后续 交互次数 每条命令都需要一次网络交互 一次性提交整个脚本 前后依赖 后续命令不能依赖前一个命令的结果 可以依赖前一个命令的结果 回滚 不支持 不支持 ``` ### 基本语法 ```lua -- 在 Lua 脚本中调用 Redis 命令 redis.call('SET', KEYS[1], ARGV[1]) redis.call('EXPIRE', KEYS[1], ARGV[2]) -- redis.call:命令失败时抛出错误,终止脚本 -- redis.pcall:命令失败时返回错误对象,脚本继续执行 ``` ```bash # 执行 Lua 脚本 EVAL script numkeys key1 key2 ... arg1 arg2 ... # 示例:原子性地设置 key 并设置过期时间 EVAL "redis.call('SET', KEYS[1], ARGV[1]); redis.call('EXPIRE', KEYS[1], ARGV[2])" 1 mykey myvalue 3600 # 加载脚本(返回 SHA1 哈希) SCRIPT LOAD "return redis.call('GET', KEYS[1])" # 返回:abc123... # 用 SHA1 执行(避免重复传输脚本) EVALSHA abc123... 1 mykey ``` ### 实战:原子性扣减库存 ```lua -- decrstock.lua -- KEYS[1]: 库存 key -- ARGV[1]: 扣减数量 local stock = tonumber(redis.call('GET', KEYS[1])) if stock == nil then return -1 -- key 不存在 end if stock < tonumber(ARGV[1]) then return -2 -- 库存不足 end redis.call('DECRBY', KEYS[1], ARGV[1]) return stock - tonumber(ARGV[1]) -- 返回剩余库存 ``` ```java // Java 调用 String script = Files.readString(Path.of("decrstock.lua")); Long result = (Long) redis.eval(script, 1, "stock:product:1001", "1"); if (result == -1) { throw new RuntimeException("商品不存在"); } else if (result == -2) { throw new RuntimeException("库存不足"); } else { System.out.println("扣减成功,剩余库存:" + result); } ``` ### 实战:分布式锁的释放(Lua 保证原子性) ```lua -- unlock.lua -- KEYS[1]: 锁的 key -- ARGV[1]: 锁的 value(UUID) if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) else return 0 end ``` ```java String luaScript = """ if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end """; redis.eval(luaScript, Collections.singletonList(lockKey), Collections.singletonList(lockValue)); ``` ### 实战:限流(滑动窗口) ```lua -- ratelimit.lua -- KEYS[1]: 限流 key(如 ratelimit:user:1001) -- ARGV[1]: 当前时间戳(毫秒) -- ARGV[2]: 时间窗口大小(毫秒) -- ARGV[3]: 最大请求数 local key = KEYS[1] local now = tonumber(ARGV[1]) local window = tonumber(ARGV[2]) local limit = tonumber(ARGV[3]) -- 删除窗口外的旧记录 redis.call('ZREMRANGEBYSCORE', key, 0, now - window) -- 获取当前窗口内的请求数 local count = redis.call('ZCARD', key) if count < limit then -- 未超限,记录本次请求 redis.call('ZADD', key, now, now) redis.call('EXPIRE', key, math.ceil(window / 1000)) return 1 -- 允许 else return 0 -- 拒绝 end ``` ## 面试常见问题 **Q:Redis 事务和数据库事务有什么区别?** A:Redis 事务不支持回滚——运行时错误只影响出错的命令,其他命令继续执行。Redis 事务保证的是命令的原子性(EXEC 时一起执行,不被插入),而不是 ACID 中的原子性(全部成功或全部失败)。 **Q:为什么用 Lua 脚本而不是 Redis 事务?** A:Lua 脚本在 Redis 中是真正原子执行的,执行期间不处理其他命令,且支持条件判断和循环。Redis 事务虽然也是原子的,但不支持回滚,且 WATCH 乐观锁在高并发下重试次数多。Lua 脚本更适合需要"读-判断-写"的原子操作场景,如扣减库存、分布式锁释放。 --- 上一篇:[07 - 分布式锁](./07-distributed-lock.md) | 返回:[目录](./README.md)
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入