加群联系作者vx：xiaoda0423

仓库地址：https://webvueblog.github.io/JavaPlusDoc/

https://1024bat.cn/

https://github.com/webVueBlog/fastapi_plus

https://webvueblog.github.io/JavaPlusDoc/

点击勘误issues，哪吒感谢大家的阅读

深入分析Redis Lua脚本运行原理

1. Lua脚本基础

1.1 什么是Lua

Lua是一种轻量级、高效的脚本语言，设计目标是嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。Lua由标准C编写而成，几乎可以在所有操作系统和平台上运行。

1.2 Lua的主要特性

• 轻量级：Lua解释器只有约200KB

• 高效性：Lua的执行速度在脚本语言中名列前茅

• 可嵌入性：易于嵌入到其他语言和应用中

• 简洁的语法：语法简单易学

• 动态类型：变量不需要类型定义

• 自动内存管理：内置垃圾回收

• 函数式编程特性：函数是一等公民

1.3 Lua在Redis中的基本语法

-- 这是单行注释
--[[
这是多行注释
可以跨越多行
--]]

-- 变量和赋值
local x = 10
local name = "Redis"

-- 条件语句
if x > 5then
    return"大于5"
else
    return"小于等于5"
end

-- 循环
local sum = 0
for i = 1, 10do
    sum = sum + i
end

-- 函数定义
localfunction add(a, b)
    return a + b
end

-- 表（Lua中的主要数据结构）
local t = {}
t[1] = "hello"
t[2] = "world"
t.name = "table example"

2. Redis中的Lua脚本

2.1 为什么Redis需要Lua脚本

Redis引入Lua脚本主要解决以下问题：

1. 原子性操作：Redis的单个命令是原子性的，但多个命令的组合不是。Lua脚本可以将多个操作打包成一个原子操作。

2. 减少网络开销：使用脚本可以将多个命令一次性发送到Redis服务器，减少网络往返次数。

3. 复杂逻辑处理：某些业务逻辑在客户端实现会很复杂，而使用Lua脚本可以在服务器端直接处理。

4. 提高性能：将复杂操作放在服务器端执行，可以减少客户端与服务器之间的数据传输。

2.2 Redis中执行Lua脚本的命令

Redis提供了两个主要命令来执行Lua脚本：

2.2.1 EVAL命令

EVAL script numkeys key [key ...] arg [arg ...]

• script：Lua脚本内容

• numkeys：键名参数的个数

• key：键名参数列表，在Lua脚本中通过KEYS[1], KEYS[2]等访问

• arg：附加参数列表，在Lua脚本中通过ARGV[1], ARGV[2]等访问

示例：

EVAL "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}" 2 key1 key2 first second

2.2.2 EVALSHA命令

EVALSHA sha1 numkeys key [key ...] arg [arg ...]

• sha1：脚本的SHA1校验和

• 其他参数与EVAL相同

EVALSHA命令用于执行已经缓存在Redis服务器中的脚本，避免每次都传输完整的脚本内容。

2.2.3 脚本管理命令

• SCRIPT LOAD script：将脚本加载到脚本缓存，但不执行

• **SCRIPT EXISTS sha1 [sha1 ...]**：检查脚本是否已缓存

• SCRIPT FLUSH：清空脚本缓存

• SCRIPT KILL：杀死当前正在运行的脚本

3. Redis Lua脚本的执行机制

3.1 Lua环境初始化

Redis在启动时会初始化一个Lua环境，这个环境是所有客户端共享的。Redis对这个Lua环境做了以下定制：

1. 沙箱化：移除了可能造成安全问题的Lua标准库函数

2. 添加Redis API：提供了redis.call()和redis.pcall()等函数来执行Redis命令

3. 随机数控制：确保脚本的确定性执行

4. 执行时间限制：防止脚本执行时间过长

3.2 脚本的加载与缓存

当Redis接收到EVAL命令时，会执行以下步骤：

1. 计算脚本的SHA1校验和

2. 检查脚本缓存中是否已存在该校验和

3. 如果不存在，将脚本编译并存入缓存

4. 执行脚本

而EVALSHA命令则直接从第2步开始，如果缓存中不存在该校验和，会返回错误。

3.3 脚本执行流程

1. 参数传递：将KEYS和ARGV参数传递给Lua环境

2. 脚本执行：在Lua环境中执行脚本

3. 结果转换：将Lua返回值转换为Redis协议格式

4. 返回结果：将结果返回给客户端

3.4 Redis与Lua的数据类型映射

4. Lua脚本的原子性与事务

4.1 原子性保证

Redis保证Lua脚本的原子性，即脚本执行期间，不会有其他脚本或命令执行。这是通过以下机制实现的：

1. 单线程执行：Redis的单线程模型确保同一时间只有一个命令在执行

2. 脚本不可中断：一旦脚本开始执行，除非使用SCRIPT KILL命令（且脚本未执行写操作），否则不能中断

4.2 与MULTI/EXEC事务的比较

4.3 脚本超时处理

Redis默认不允许脚本执行时间超过一定限制（可通过lua-time-limit配置）。当脚本执行时间过长时：

1. Redis服务器会开始接受SCRIPT KILL和SHUTDOWN NOSAVE命令

2. 如果脚本未执行写操作，可以使用SCRIPT KILL终止脚本

3. 如果脚本已执行写操作，只能使用SHUTDOWN NOSAVE关闭服务器

5. Lua脚本的性能优化

5.1 性能优势

Lua脚本相比于客户端执行多个命令有以下性能优势：

1. 减少网络往返：一次网络请求完成多个操作

2. 减少上下文切换：服务器端一次性执行所有操作

3. 原子性保证：无需使用WATCH/MULTI/EXEC等机制

5.2 性能优化技巧

1. 使用EVALSHA代替EVAL：减少脚本传输开销

2. 最小化脚本复杂度：保持脚本简单高效

3. 避免长时间运行：脚本执行会阻塞Redis服务器

4. 合理使用redis.call和redis.pcall：redis.pcall会捕获错误但性能略低

5. 预加载常用脚本：使用SCRIPT LOAD预加载常用脚本

5.3 常见性能陷阱

1. 无限循环：脚本中的无限循环会导致Redis服务器阻塞

2. 大量数据处理：在脚本中处理大量数据会消耗大量内存和CPU

3. 频繁调用redis.call：每次调用都有开销，应尽量减少调用次数

4. 复杂计算：Lua不适合进行复杂计算，应将复杂计算放在客户端

6. Lua脚本的实际应用场景

6.1 计数器和限流器

-- 简单的限流器：每个用户每分钟最多访问10次
local user_id = KEYS[1]
local current_time = tonumber(ARGV[1])
local time_window = 60-- 60秒
local max_requests = 10

-- 清理过期的访问记录
redis.call("ZREMRANGEBYSCORE", user_id, 0, current_time - time_window)

-- 获取当前时间窗口内的访问次数
local count = redis.call("ZCARD", user_id)

if count < max_requests then
    -- 记录本次访问
    redis.call("ZADD", user_id, current_time, current_time .. ":" .. math.random())
    return1-- 允许访问
else
    return0-- 拒绝访问
end

6.2 分布式锁

-- 获取锁
local lock_key = KEYS[1]
local lock_value = ARGV[1]  -- 通常是一个唯一标识符
local ttl = tonumber(ARGV[2])  -- 锁的过期时间

if redis.call("SET", lock_key, lock_value, "NX", "PX", ttl) then
    return1-- 获取锁成功
else
    return0-- 获取锁失败
end

-- 释放锁（确保只有锁的持有者才能释放锁）
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
    return0
end

6.3 原子性计数器更新

-- 原子性地更新多个计数器
local counter1 = KEYS[1]
local counter2 = KEYS[2]
local counter3 = KEYS[3]
local increment = tonumber(ARGV[1])

redis.call("INCRBY", counter1, increment)
redis.call("INCRBY", counter2, increment * 2)
redis.call("INCRBY", counter3, increment * 3)

return {
    redis.call("GET", counter1),
    redis.call("GET", counter2),
    redis.call("GET", counter3)
}

6.4 复杂数据结构操作

-- 在有序集合中查找并更新元素
local zset_key = KEYS[1]
local member = ARGV[1]
local new_score = tonumber(ARGV[2])

local current_score = redis.call("ZSCORE", zset_key, member)
if current_score then
    -- 元素存在，更新分数
    redis.call("ZADD", zset_key, new_score, member)
    return {1, new_score - tonumber(current_score)}
else
    -- 元素不存在，添加新元素
    redis.call("ZADD", zset_key, new_score, member)
    return {0, new_score}
end

7. Lua脚本的调试与测试

7.1 调试技巧

1. 使用redis.log：在脚本中使用redis.log()函数记录调试信息

   redis.log(redis.LOG_WARNING, "Debug: value = " .. tostring(value))

2. 分步测试：将复杂脚本分解为简单步骤，逐步测试

3. 使用redis-cli --eval：redis-cli提供了--eval选项来执行Lua脚本文件

   redis-cli --eval script.lua key1 key2 , arg1 arg2

7.2 常见错误及解决方案

1. 语法错误：检查Lua语法，特别是括号、引号和关键字

2. 类型错误：确保数据类型转换正确，特别是字符串和数字之间的转换

3. 键不存在：处理键不存在的情况，使用条件判断

4. 脚本超时：优化脚本性能，避免长时间运行

5. 内存溢出：控制数据量，避免在脚本中处理大量数据

7.3 单元测试

可以使用以下方法对Lua脚本进行单元测试：

1. 使用测试框架：如Busted（Lua测试框架）

2. 模拟Redis环境：创建模拟的redis.call和redis.pcall函数

3. 集成测试：在实际Redis环境中测试脚本

8. Lua脚本的最佳实践

8.1 安全性考虑

1. 避免使用外部输入：不要直接将用户输入作为脚本内容

2. 限制脚本权限：使用redis.replicate_commands()控制脚本复制行为

3. 设置执行时间限制：配置lua-time-limit参数

4. 避免敏感操作：不要在脚本中执行FLUSHALL、SHUTDOWN等敏感命令

8.2 可维护性建议

1. 添加注释：详细注释脚本功能和逻辑

2. 模块化：将复杂脚本分解为小型、可重用的函数

3. 版本控制：使用版本控制系统管理脚本

4. 文档化：记录脚本的用途、参数和返回值

8.3 部署策略

1. 预加载脚本：在应用启动时预加载常用脚本

2. 脚本管理：使用工具或框架管理脚本

3. 监控脚本执行：监控脚本执行时间和资源消耗

4. 灰度发布：新脚本先在测试环境验证，再逐步部署到生产环境

9. Redis Lua脚本与Redis模块的比较

9.1 Lua脚本的局限性

1. 功能受限：只能使用Redis提供的API

2. 性能限制：复杂计算会影响Redis性能

3. 调试困难：缺乏完善的调试工具

4. 无状态：每次执行都是独立的，无法保存状态

9.2 Redis模块的优势

1. 更高性能：C语言编写，直接访问Redis内部API

2. 功能更强：可以实现更复杂的功能

3. 可以保存状态：模块可以维护自己的状态

4. 更好的集成：可以与Redis核心功能更紧密集成

9.3 选择建议

• 使用Lua脚本：简单的原子操作、临时性需求、不需要高性能

• 使用Redis模块：复杂功能、高性能需求、需要保存状态、长期使用

10. 实战案例：基于Lua脚本的秒杀系统

10.1 需求分析

秒杀系统需要解决的核心问题：

1. 并发控制：防止超卖

2. 性能要求：高并发、低延迟

3. 防重复购买：一个用户只能购买一次

4. 库存实时性：库存数据需要实时准确

10.2 Lua脚本实现

-- 秒杀脚本
-- KEYS[1]: 商品库存key
-- KEYS[2]: 已购买用户集合key
-- ARGV[1]: 用户ID
-- ARGV[2]: 购买数量

local stock_key = KEYS[1]
local purchased_users_key = KEYS[2]
local user_id = ARGV[1]
local quantity = tonumber(ARGV[2])

-- 检查用户是否已购买
if redis.call("SISMEMBER", purchased_users_key, user_id) == 1then
    return {0, "用户已购买"}
end

-- 检查库存
local stock = tonumber(redis.call("GET", stock_key) or"0")
if stock < quantity then
    return {0, "库存不足"}
end

-- 扣减库存并记录用户购买
redis.call("DECRBY", stock_key, quantity)
redis.call("SADD", purchased_users_key, user_id)

-- 返回成功和剩余库存
return {1, stock - quantity}

10.3 Java客户端调用示例

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import java.util.Arrays;

publicclass SecKillService {
    privatefinal JedisPool jedisPool;
    privatefinal String stockKey = "product:stock:";
    privatefinal String purchasedUsersKey = "product:purchased:users:";
    privatefinal String secKillScript;
    private String secKillScriptSha1;

    public SecKillService(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
        // 秒杀脚本
        this.secKillScript = """
            local stock_key = KEYS[1]
            local purchased_users_key = KEYS[2]
            local user_id = ARGV[1]
            local quantity = tonumber(ARGV[2])

            if redis.call("SISMEMBER", purchased_users_key, user_id) == 1 then
                return {0, "用户已购买"}
            end

            local stock = tonumber(redis.call("GET", stock_key) or "0")
            if stock < quantity then
                return {0, "库存不足"}
            end

            redis.call("DECRBY", stock_key, quantity)
            redis.call("SADD", purchased_users_key, user_id)

            return {1, stock - quantity}
        """;
        
        // 预加载脚本
        try (Jedis jedis = jedisPool.getResource()) {
            this.secKillScriptSha1 = jedis.scriptLoad(secKillScript);
        }
    }

    public boolean secKill(String productId, String userId, int quantity) {
        try (Jedis jedis = jedisPool.getResource()) {
            String stockKey = this.stockKey + productId;
            String purchasedUsersKey = this.purchasedUsersKey + productId;
            
            // 执行秒杀脚本
            Object result = jedis.evalsha(
                secKillScriptSha1,
                Arrays.asList(stockKey, purchasedUsersKey),
                Arrays.asList(userId, String.valueOf(quantity))
            );
            
            // 解析结果
            if (result instanceof List) {
                List