深入解析：Redis事务与Lua脚本的强强联合

在构建高并发、高性能的应用程序时，Redis作为一款优秀的内存数据存储，其提供的原子性操作至关重要。Redis提供了两种主要方式来实现复杂操作的原子性：事务和Lua脚本。本文将深入探讨这两者的工作机制、优缺点以及如何在实际场景中选择和使用它们。

一、Redis事务：基础与局限

Redis事务的核心命令是 MULTI, EXEC, DISCARD。它允许将多个命令打包，然后一次性、按顺序地执行。

1.1 事务的基本使用

一个典型的事务流程如下：

127.0.0.1:6379> MULTI        # 开启事务
OK
127.0.0.1:6379> SET name "Alice"
QUEUED
127.0.0.1:6379> INCR counter
QUEUED
127.0.0.1:6379> EXEC         # 执行事务
1) OK
2) (integer) 1

在 MULTI 和 EXEC 之间的所有命令都不会立即执行，而是被放入一个队列中。当执行 EXEC 时，Redis会原子性地执行队列中的所有命令。

1.2 事务的ACID特性

• 原子性（Atomicity）：Redis事务是原子的。EXEC 命令触发事务中所有命令的执行，如果客户端在调用 EXEC 之前断连，则所有操作都不会执行；如果 EXEC 被成功调用，则所有操作都会执行。注意：Redis事务不支持回滚（Rollback）。即使事务中的某个命令失败（例如对字符串执行INCR），其他命令仍然会继续执行，这与传统关系型数据库不同。
• 一致性（Consistency）：事务执行前后，数据库的完整性约束不会被破坏。
• 隔离性（Isolation）：Redis是单线程执行命令的，因此事务中的所有命令都是串行化执行的，保证了完美的隔离性，不会受到其他客户端命令的干扰。
• 持久性（Durability）：取决于Redis的持久化配置（RDB或AOF）。

1.3 使用WATCH实现乐观锁

事务的一个主要局限是它无法解决竞态条件（Race Condition）。例如，一个“先检查后设置”的场景：

1. 客户端A读取键 balance 的值为100。
2. 客户端B也读取了 balance 的值为100。
3. 客户端A在事务中将 balance 减少10，设置为90并提交。
4. 客户端B在事务中也将 balance 减少10，设置为90并提交。最终结果是90，而不是预期的80。

为了解决这个问题，Redis提供了 WATCH 命令，用于实现乐观锁（Optimistic Locking）。

# 客户端A
127.0.0.1:6379> WATCH balance   # 监视balance键
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> DECRBY balance 10
QUEUED
127.0.0.1:6379> EXEC            # 如果在WATCH后EXEC前，balance被其他客户端修改，则EXEC返回(nil)，事务执行失败。
1) (integer) 80

# 客户端B（在A执行WATCH后，EXEC前修改了balance）
127.0.0.1:6379> SET balance 1000
OK

# 此时客户端A的EXEC会失败，返回(nil)。客户端A需要重试整个逻辑（重新WATCH，获取新值，再执行MULTI/EXEC）。

事务的局限性总结：

1. 无法回滚：命令语法错误会在EXEC前被检测到，整个事务失败。但运行时错误（如类型错误）不会阻止其他命令执行。
2. 复杂性：结合 WATCH 实现复杂逻辑时，需要处理执行失败和重试，代码逻辑变得复杂。
3. 后置执行：事务中的读操作无法使用之前命令的结果。因为所有命令在EXEC时才执行，在MULTI后添加的命令无法依赖队列中前面命令的执行结果。

二、Lua脚本：更强大的原子操作

为了克服事务的局限性，Redis从2.6版本开始内置了Lua脚本引擎。开发者可以编写Lua脚本，Redis会原子地、不可中断地执行整个脚本。

2.1 Lua脚本的基本使用

使用 EVAL 命令执行Lua脚本。

# 语法：EVAL "lua_script" numkeys key [key ...] arg [arg ...]
127.0.0.1:6379> EVAL "return redis.call('SET', KEYS[1], ARGV[1])" 1 mykey "Hello Lua"
OK
127.0.0.1:6379> GET mykey
"Hello Lua"

• "lua_script"： Lua脚本代码字符串。
• numkeys： 指定后续有几个key参数。
• key [key ...]： 作为键名参数，在脚本中通过 KEYS[1], KEYS[2] 访问。
• arg [arg ...]： 作为附加参数，在脚本中通过 ARGV[1], ARGV[2] 访问。
• redis.call()： 在Lua脚本中调用Redis命令的核心函数。

2.2 为什么Lua脚本是原子的？

Redis使用单个Lua解释器来运行所有脚本，并且当脚本运行时，整个服务器不会被其他脚本或Redis命令执行。这种语义类似于 MULTI/EXEC 包裹的事务。这意味着在脚本执行期间，不会有竞态条件发生，无需使用 WATCH。

2.3 脚本缓存与EVALSHA

为了避免每次执行都传输相同的脚本，Redis提供了 SCRIPT LOAD 和 EVALSHA 命令。

# 1. 加载脚本，返回一个SHA1校验和
127.0.0.1:6379> SCRIPT LOAD "return redis.call('GET', KEYS[1])"
"a5a0e83445c83d7dace17d02ccf6bb390ac8657b"

# 2. 使用EVALSHA通过校验和执行脚本
127.0.0.1:6379> EVALSHA a5a0e83445c83d7dace17d02ccf6bb390ac8657b 1 mykey
"Hello Lua"

如果脚本已经在服务器缓存中，使用 EVALSHA 可以节省网络带宽，提升性能。

三、实战对比：秒杀库存扣减场景

让我们用一个经典的“秒杀扣减库存”场景来对比事务和Lua脚本的用法。

需求：检查库存是否大于0，如果大于0则扣减库存。

3.1 使用事务 + WATCH 的实现

import redis

def deduct_stock_with_watch(conn, product_key):
    """
    使用WATCH和事务扣减库存
    可能需要重试
    """
    while True: # 重试循环
        try:
            conn.watch(product_key)
            current_stock = int(conn.get(product_key) or 0)
            if current_stock <= 0:
                conn.unwatch() # 库存不足，取消监视
                return False

            pipe = conn.pipeline()
            pipe.multi() # 开启事务
            pipe.decr(product_key)
            result = pipe.execute() # 如果在此期间product_key被修改，execute()会抛出WatchError
            return True # 扣减成功
        except redis.WatchError:
            # 键被修改，重试
            continue

# 初始化
r = redis.Redis()
r.set('sku_123', 10) # 初始库存为10

# 模拟并发扣减
success = deduct_stock_with_watch(r, 'sku_123')
print(f"扣减结果: {success}")

3.2 使用Lua脚本的实现

import redis

# 预先定义Lua脚本
LUA_DEDUCT_SCRIPT = """
local stock_key = KEYS[1]
local current_stock = tonumber(redis.call('GET', stock_key))
if (current_stock <= 0) then
    return 0 -- 库存不足，返回0
end
redis.call('DECR', stock_key)
return 1 -- 扣减成功，返回1
"""

def deduct_stock_with_lua(conn, product_key):
    """
    使用Lua脚本扣减库存
    无需重试逻辑，一次执行保证原子性
    """
    # 第一种方式：直接使用EVAL
    # result = conn.eval(LUA_DEDUCT_SCRIPT, 1, product_key)

    # 第二种方式（推荐）：使用EVALSHA
    script_sha = conn.script_load(LUA_DEDUCT_SCRIPT)
    result = conn.evalsha(script_sha, 1, product_key)
    return bool(result)

# 初始化
r = redis.Redis()
r.set('sku_456', 10) # 初始库存为10

# 模拟并发扣减
success = deduct_stock_with_lua(r, 'sku_456')
print(f"扣减结果: {success}")

3.3 对比分析

四、Lua脚本使用注意事项

虽然Lua脚本非常强大，但在使用时也需要注意以下几点：

1. 脚本不应过长：Lua脚本会阻塞Redis单线程。长时间运行的脚本会严重影响Redis的响应性。务必保持脚本轻量、高效。
2. 避免死循环：编写脚本时要格外小心，确保不会有死循环。Redis默认配置了 lua-time-limit（通常为5秒），如果脚本超时，Redis会记录日志并开始接受其他命令，但脚本本身可能仍会继续运行（除非使用 SCRIPT KILL）。
3. 确保脚本的确定性：脚本的行为应该是确定的，即对于相同的KEYS和ARGV，执行结果始终相同。不要在脚本中调用像 TIME 这样的非确定性命令。
4. 调试：Redis没有内置的Lua调试器。可以通过 redis.log 函数在Redis日志中打印信息来辅助调试。

-- 在Lua脚本中记录日志
redis.log(redis.LOG_NOTICE, "Debug: Current stock is " .. current_stock)

五、总结与选择建议

• Redis事务：适用于相对简单、不需要在命令队列中使用中间结果的批量操作。当需要基于某个键的当前值进行条件更新时，必须结合 WATCH 使用，但要准备好处理竞争失败和重试。
• Lua脚本：是大多数需要复杂原子操作场景的首选。它提供了真正意义上的原子性，将复杂逻辑封装在服务器端，减少了网络开销，避免了竞态条件，代码也更简洁。特别是在高并发场景下（如秒杀、抢购），Lua脚本的优势非常明显。

总而言之，Redis事务是基础，而Lua脚本则是实现复杂、高性能原子操作的终极武器。理解两者的原理和适用场景，将帮助你在实际开发中做出最合适的技术选型，构建出更加健壮和高效的应用程序。