3.3 Lua 脚本 (Lua Scripting)

文档摘要

3.3 Lua 脚本 (Lua Scripting) Redis 高级特性：Lua 脚本 (Lua Scripting) 详解与实践 Lua 脚本在 Redis 中的作用与优势在 Redis 引入 Lua 脚本之前，要执行一系列操作通常需要多次客户端与服务器之间的交互。例如，实现一个原子性的“获取并自增”操作，可能需要先使用命令获取值，然后在客户端进行自增操作，最后使用命令将新值写回。这种方式存在以下问题：性能损耗：多次网络请求增加了延迟，降低了整体性能。非原子性：在多次命令执行期间，数据可能被其他客户端修改，导致数据不一致。复杂逻辑实现困难：复杂的业务逻辑需要在客户端代码中实现，增加了客户端的复杂性，且难以在服务器端进行统一管理和优化。

3.3 Lua 脚本 (Lua Scripting)

Redis 高级特性：Lua 脚本 (Lua Scripting) 详解与实践

1. Lua 脚本在 Redis 中的作用与优势

在 Redis 引入 Lua 脚本之前，要执行一系列操作通常需要多次客户端与服务器之间的交互。例如，实现一个原子性的“获取并自增”操作，可能需要先使用 GET 命令获取值，然后在客户端进行自增操作，最后使用 SET 命令将新值写回。这种方式存在以下问题：

性能损耗： 多次网络请求增加了延迟，降低了整体性能。
非原子性： 在多次命令执行期间，数据可能被其他客户端修改，导致数据不一致。
复杂逻辑实现困难： 复杂的业务逻辑需要在客户端代码中实现，增加了客户端的复杂性，且难以在服务器端进行统一管理和优化。

Lua 脚本的引入完美地解决了这些问题。通过将 Lua 脚本发送到 Redis 服务器端执行，可以实现：

原子性操作： 整个 Lua 脚本在服务器端原子性执行，保证了操作的完整性和数据一致性。
减少网络开销： 只需要一次网络请求即可完成多个操作，显著提升性能。
复用性与可维护性： 将业务逻辑封装在 Lua 脚本中，可以在服务器端复用，易于维护和管理。
扩展 Redis 功能： 可以自定义复杂的 Redis 命令，满足特定业务需求。

总而言之，Lua 脚本为 Redis 带来了更强大的功能和更高的性能，是构建高性能、高可靠性 Redis 应用的关键技术。

2. Lua 脚本基础：环境与语法

Redis 内嵌了一个 Lua 解释器，用于执行客户端发送的 Lua 脚本。在 Redis 的 Lua 环境中，预定义了一个全局对象 redis，通过这个对象可以调用 Redis 命令，以及访问和操作 Redis 数据。

2.1 Redis Lua 环境

全局对象 redis： 这是 Redis Lua 环境的核心对象，提供了以下主要功能：
- redis.call(command, arg1, arg2, ...): 执行 Redis 命令。这是 Lua 脚本与 Redis 交互的主要方式。
- redis.pcall(command, arg1, arg2, ...): 与 redis.call 类似，但会捕获 Redis 命令执行错误，并返回一个包含错误信息的 Lua 表，而不是直接抛出错误。
- redis.log(level, message): 将日志消息写入 Redis 服务器日志。level 可以是 redis.LOG_DEBUG, redis.LOG_VERBOSE, redis.LOG_NOTICE, redis.LOG_WARNING。
- redis.error_reply(message): 返回一个错误回复给客户端。
- redis.status_reply(message): 返回一个状态回复给客户端。
- redis.sha1hex(string): 计算字符串的 SHA1 摘要。
- redis.replicate_commands(): 显式声明脚本需要复制执行的 Redis 命令（通常用于集群环境，确保脚本在主节点和从节点执行一致）。
- redis.breakpoint() 和 redis.debug(): 用于 Lua 脚本调试（在 Redis 调试模式下可用）。
Lua 标准库： Redis Lua 环境默认加载了部分 Lua 标准库，例如 table, string, math, cjson (如果 Redis 编译时启用了 JSON 支持) 等。但为了安全性和性能考虑，一些可能导致阻塞或不安全的操作的库或函数被禁用，例如 io, os, debug 等库中的部分函数。

2.2 Lua 语法基础 (Redis 脚本常用部分)

变量： Lua 是动态类型语言，变量无需显式声明类型。
```
local my_key = "mykey"
local my_value = 100
```
数据类型： Redis Lua 脚本中常用的数据类型包括：
- string: 字符串
- number: 数字 (Lua 中只有一种数字类型，即双精度浮点数)
- boolean: 布尔值 (true 和 false)
- table: 表 (类似于关联数组或字典)
- nil: 空值

控制结构：

if-then-else: 条件判断


if value > 10 then
    redis.call("SET", "status", "high")
elseif value > 5 then
    redis.call("SET", "status", "medium")
else
    redis.call("SET", "status", "low")
end

while 循环


local count = 0
while count < 5 do
    redis.call("INCR", "counter")
    count = count + 1
end

for 循环


for i = 1, 10 do
    redis.call("LPUSH", "mylist", "item_" .. i)
end

函数： Lua 中函数定义使用 function 关键字。


local function increment_and_get(key)
    redis.call("INCR", key)
    return redis.call("GET", key)
end
local new_value = increment_and_get("mycounter")

注释： 单行注释使用 --，多行注释使用 --[[ ... --]]。

3. Lua 脚本实践：代码示例与详解

接下来，我们将通过一系列代码示例，深入了解 Redis Lua 脚本的实际应用。

3.1 原子性计数器：`INCR` 的 Lua 实现

Redis 提供了 INCR 命令用于原子性地增加键的值。我们可以使用 Lua 脚本实现类似的功能，并进行更灵活的操作。

Lua 脚本示例 (atomic_counter.lua):


local key = KEYS[1] -- 从 KEYS 数组获取键名
local increment_by = ARGV[1] -- 从 ARGV 数组获取自增量
local current_value = redis.call("GET", key) -- 获取当前值
if current_value == false then -- 如果键不存在，则初始化为 0
    current_value = 0
end
current_value = tonumber(current_value) -- 将字符串转换为数字
local new_value = current_value + tonumber(increment_by) -- 计算新值
redis.call("SET", key, new_value) -- 设置新值
return new_value -- 返回新值

代码详解：

KEYS[1] 和 ARGV[1]: Lua 脚本可以通过 KEYS 和 ARGV 数组访问客户端传递的参数。KEYS 数组用于传递键名，ARGV 数组用于传递其他参数。在本例中，KEYS[1] 获取键名，ARGV[1] 获取自增量。
redis.call("GET", key): 使用 redis.call 执行 GET 命令，获取键的当前值。如果键不存在，GET 命令返回 nil，在 Lua 中会被转换为 false。
if current_value == false then ... end: 判断键是否存在，如果不存在，则将 current_value 初始化为 0。
tonumber(current_value): 将从 Redis 获取的字符串值转换为数字类型，以便进行数值运算。
current_value + tonumber(increment_by): 计算新的值。
redis.call("SET", key, new_value): 使用 redis.call 执行 SET 命令，将新的值写回 Redis。
return new_value: 脚本的返回值将作为命令的执行结果返回给客户端。

客户端调用示例 (使用 redis-cli):


redis-cli eval "$(cat atomic_counter.lua)" 1 mycounter 5

eval: Redis 命令，用于执行 Lua 脚本。
$(cat atomic_counter.lua): 将 atomic_counter.lua 文件的内容作为 Lua 脚本传递给 eval 命令。
1: 指定 KEYS 数组的元素个数为 1。
mycounter: KEYS[1] 的值，即键名。
5: ARGV[1] 的值，即自增量。

执行后，如果 mycounter 键不存在，则会被创建并设置为 5。如果存在，则会在原有值的基础上增加 5。命令的返回值就是 mycounter 键的新值。

3.2 分布式锁：基于 Lua 的原子性实现

分布式锁是解决分布式系统中资源竞争问题的常用手段。我们可以利用 Redis Lua 脚本实现一个简单而高效的分布式锁。

Lua 脚本示例 (distributed_lock.lua):


local lock_key = KEYS[1] -- 锁的键名
local lock_value = ARGV[1] -- 锁的值 (通常是唯一标识，例如 UUID)
local expire_time = ARGV[2] -- 锁的过期时间 (秒)
-- 尝试获取锁：如果键不存在，则设置键值并设置过期时间，返回 1 表示获取成功
if redis.call("SETNX", lock_key, lock_value) == 1 then
    redis.call("EXPIRE", lock_key, expire_time)
    return 1
end
-- 如果键已存在，检查是否是自己的锁
local current_value = redis.call("GET", lock_key)
if current_value == lock_value then
    -- 如果是自己的锁，则延长锁的过期时间
    redis.call("EXPIRE", lock_key, expire_time)
    return 1
end
-- 获取锁失败，返回 0
return 0

代码详解：

KEYS[1], ARGV[1], ARGV[2]: 获取锁键名、锁值和过期时间。
redis.call("SETNX", lock_key, lock_value): 使用 SETNX (SET if Not eXists) 命令尝试获取锁。如果键不存在，SETNX 会设置键值并返回 1，表示获取锁成功。如果键已存在，SETNX 不会进行任何操作，并返回 0。
redis.call("EXPIRE", lock_key, expire_time): 如果 SETNX 成功获取锁，则使用 EXPIRE 命令设置锁的过期时间，防止死锁。
检查是否是自己的锁: 如果 SETNX 获取锁失败 (键已存在)，则需要检查是否是当前客户端之前持有的锁。通过 GET 命令获取锁的值，并与当前客户端的 lock_value 进行比较。
延长锁过期时间: 如果是自己的锁，则只需要延长锁的过期时间即可，使用 EXPIRE 命令更新过期时间。
返回结果: 脚本返回 1 表示获取锁成功，返回 0 表示获取锁失败。

客户端调用示例 (获取锁):


redis-cli eval "$(cat distributed_lock.lua)" 1 my_lock my_lock_value 30

my_lock: 锁的键名。
my_lock_value: 锁的值，客户端需要生成一个唯一的标识 (例如 UUID)。
30: 锁的过期时间，单位秒。

客户端调用示例 (释放锁 - 需要确保只释放自己持有的锁):

为了安全地释放锁，我们需要编写另一个 Lua 脚本，确保只有持有锁的客户端才能释放锁，避免误删其他客户端的锁。

Lua 脚本示例 (release_lock.lua):


local lock_key = KEYS[1]
local lock_value = ARGV[1]
-- 检查锁的值是否与给定的值匹配，如果匹配则删除锁
if redis.call("GET", lock_key) == lock_value then
    return redis.call("DEL", lock_key)
else
    return 0 -- 锁的值不匹配，释放锁失败
end

客户端调用示例 (释放锁):


redis-cli eval "$(cat release_lock.lua)" 1 my_lock my_lock_value

my_lock: 锁的键名。
my_lock_value: 持有锁时使用的锁值。

3.3 限流器：基于 Redis 和 Lua 的滑动窗口限流

限流是保护系统免受过载的常用技术。我们可以使用 Redis 和 Lua 脚本实现一个基于滑动窗口的限流器。

Lua 脚本示例 (rate_limiter.lua):


local key = KEYS[1] -- 限流键名 (例如用户 ID)
local limit = tonumber(ARGV[1]) -- 限制次数
local window_size = tonumber(ARGV[2]) -- 窗口大小 (秒)
local current_time = redis.call("TIME")[1] -- 获取当前时间戳 (秒)
-- 清理窗口外的旧请求记录
redis.call("ZREMRANGEBYSCORE", key, 0, current_time - window_size)
-- 获取当前窗口内的请求数量
local current_count = redis.call("ZCARD", key)
-- 检查是否超过限制
if current_count < limit then
    -- 未超过限制，允许请求，并将当前时间戳添加到 Sorted Set
    redis.call("ZADD", key, current_time, current_time)
    redis.call("EXPIRE", key, window_size * 2) -- 设置过期时间，防止 Sorted Set 无限增长
    return 1 -- 允许请求
else
    -- 超过限制，拒绝请求
    return 0 -- 拒绝请求
end

代码详解：

KEYS[1], ARGV[1], ARGV[2]: 获取限流键名、限制次数和窗口大小。
redis.call("TIME")[1]: 使用 TIME 命令获取 Redis 服务器的当前时间戳 (秒级)。
redis.call("ZREMRANGEBYSCORE", key, 0, current_time - window_size): 使用 ZREMRANGEBYSCORE 命令移除 Sorted Set 中 score 值小于 current_time - window_size 的元素，即清理窗口外的旧请求记录。Sorted Set 的 score 值存储的是请求发生的时间戳。
redis.call("ZCARD", key): 使用 ZCARD 命令获取 Sorted Set 中元素的数量，即当前窗口内的请求数量。
if current_count < limit then ... else ... end: 判断当前请求数量是否超过限制。
redis.call("ZADD", key, current_time, current_time): 如果未超过限制，使用 ZADD 命令将当前时间戳添加到 Sorted Set 中，表示记录一次请求。Sorted Set 的 score 和 member 都设置为时间戳，方便后续按时间范围查询和清理。
redis.call("EXPIRE", key, window_size * 2): 设置 Sorted Set 的过期时间，通常设置为窗口大小的两倍，防止 Sorted Set 无限增长，即使在一段时间内没有请求，Sorted Set 也会被自动删除。
返回结果: 脚本返回 1 表示允许请求，返回 0 表示拒绝请求。

客户端调用示例 (限流):


redis-cli eval "$(cat rate_limiter.lua)" 1 user:123 10 60

user:123: 限流键名，例如用户 ID。
10: 限制次数，例如 1 分钟内最多允许 10 次请求。
60: 窗口大小，单位秒 (1 分钟)。

每次请求到达时，客户端调用该 Lua 脚本，如果返回 1，则允许请求；如果返回 0，则拒绝请求。

4. Lua 脚本的加载与复用：`SCRIPT LOAD` 和 `EVALSHA`

每次使用 EVAL 命令执行 Lua 脚本时，都需要将脚本内容完整地发送给 Redis 服务器。对于复杂的脚本，这会增加网络开销。为了提高效率，Redis 提供了 SCRIPT LOAD 命令，可以将 Lua 脚本预先加载到 Redis 服务器，并返回脚本的 SHA1 摘要。之后，可以使用 EVALSHA 命令，通过 SHA1 摘要来执行已加载的脚本，而无需再次发送完整的脚本内容。

步骤：

加载脚本： 使用 SCRIPT LOAD 命令将 Lua 脚本发送给 Redis 服务器。
```
redis-cli script load "$(cat atomic_counter.lua)"
```
服务器会返回脚本的 SHA1 摘要，例如：
```
"a1b2c3d4e5f6..."
```
使用 SHA1 摘要执行脚本： 使用 EVALSHA 命令，并提供脚本的 SHA1 摘要，以及参数 (KEYS 和 ARGV)。
```
redis-cli evalsha a1b2c3d4e5f6... 1 mycounter 5
```
EVALSHA 命令会根据 SHA1 摘要在服务器端查找已加载的脚本，并执行它。如果脚本未加载，EVALSHA 命令会返回错误。

优势：

减少网络开销： 对于频繁使用的脚本，只需要加载一次，后续执行只需传递 SHA1 摘要，减少了网络传输量。
提高性能： 服务器端可以缓存已加载的脚本，提高脚本执行效率。

脚本管理命令：

SCRIPT LOAD script: 加载脚本到服务器，返回 SHA1 摘要。
SCRIPT EXISTS sha1 [sha2 ...]: 检查给定的 SHA1 摘要的脚本是否已加载到服务器。
SCRIPT FLUSH: 清除服务器端所有已加载的脚本缓存。
SCRIPT KILL: 终止当前正在执行的脚本 (仅限于只读脚本，或者在 redis.conf 中配置了 lua-time-limit 超时时间)。
SCRIPT DEBUG YES|SYNC|NO: 设置脚本调试模式。

5. Lua 脚本的错误处理与调试

在 Lua 脚本执行过程中，可能会出现错误，例如 Redis 命令执行失败、Lua 语法错误、运行时错误等。我们需要了解如何处理这些错误，并进行脚本调试。

5.1 错误处理

redis.call 和 redis.pcall: redis.call 在 Redis 命令执行失败时会直接抛出 Lua 错误，导致脚本执行中断。redis.pcall 则会捕获错误，并返回一个包含错误信息的 Lua 表，脚本可以继续执行。建议在生产环境中使用 redis.pcall 进行错误处理，提高脚本的健壮性。
```
local result = redis.pcall("GET", "non_existent_key")
if result.err then
    redis.log(redis.LOG_WARNING, "GET command failed: " .. result.err)
    return redis.error_reply("Key not found")
else
    local value = result[1] -- 获取命令执行结果
    -- ...
end
```
error(message): Lua 脚本可以使用 error(message) 函数抛出 Lua 错误，并中断脚本执行。可以使用 redis.error_reply(message) 将错误信息返回给客户端。

5.2 脚本调试

SCRIPT DEBUG 命令: Redis 提供了 SCRIPT DEBUG 命令，可以设置脚本调试模式。
- SCRIPT DEBUG YES: 开启异步调试模式。脚本执行过程中遇到错误会暂停，并进入调试模式，可以使用 redis-cli 交互式地查看脚本状态和变量值。
- SCRIPT DEBUG SYNC: 开启同步调试模式。脚本执行过程中遇到错误会立即暂停，并进入调试模式。客户端会阻塞等待调试会话结束。
- SCRIPT DEBUG NO: 关闭调试模式。
redis.breakpoint() 和 redis.debug(): 在 Lua 脚本中可以使用 redis.breakpoint() 函数设置断点，使用 redis.debug() 函数输出调试信息。这些函数只在调试模式下生效。
redis-cli --eval 调试模式: 使用 redis-cli --eval 命令执行脚本时，如果脚本发生错误，redis-cli 会显示详细的错误信息，包括错误行号和错误类型，方便调试。

6. 最佳实践与注意事项

脚本的原子性: Lua 脚本在 Redis 中是原子性执行的，务必充分利用这一特性，将需要原子性保证的操作放在一个脚本中执行。
脚本的性能: Lua 脚本的性能通常很高，但也要注意避免在脚本中执行耗时操作，例如复杂的计算、循环、网络请求等。尽量将计算密集型操作放在客户端完成，脚本主要负责 Redis 数据操作。
脚本的安全性: 避免在脚本中使用不安全的 Lua 函数或库。注意参数验证和输入过滤，防止脚本注入攻击。
脚本的长度: 尽量保持脚本简洁高效，避免编写过长或过于复杂的脚本，提高可读性和可维护性。
脚本的版本管理: 对于重要的 Lua 脚本，建议进行版本管理，方便回滚和升级。可以使用 SCRIPT LOAD 和 EVALSHA 机制，将脚本存储在外部文件或配置中心，统一管理和部署。
集群环境下的脚本复制: 在 Redis 集群环境下，默认情况下，只读脚本会在所有节点执行，读写脚本只会发送到 key 所在的节点执行。如果需要确保脚本在所有节点执行一致 (例如涉及到多个 key 的操作)，可以使用 redis.replicate_commands() 函数显式声明需要复制的 Redis 命令。

7. 总结

Redis Lua 脚本是一项强大的高级特性，它为 Redis 带来了原子性操作、高性能、可扩展性等诸多优势。通过本文的详细介绍和代码实践，相信读者已经对 Redis Lua 脚本有了全面的了解。掌握 Lua 脚本，可以帮助开发者构建更高效、更可靠的 Redis 应用，解决更复杂的业务场景问题。在实际应用中，需要根据具体需求选择合适的 Lua 脚本方案，并遵循最佳实践，充分发挥 Lua 脚本的优势，提升 Redis 应用的整体性能和健壮性。

3.3 Lua 脚本 (Lua Scripting)

文档摘要