Redis 7.x 系列【31】LUA 脚本

有道无术,术尚可求,有术无道,止于术。

本系列Redis 版本 7.2.5

源码地址:https://gitee.com/pearl-organization/study-redis-demo

文章目录

    • [1. 概述](#1. 概述)
    • [2. 常用命令](#2. 常用命令)
      • [2.1 EVAL](#2.1 EVAL)
      • [2.2 SCRIPT LOAD](#2.2 SCRIPT LOAD)
      • [2.3 EVALSHA](#2.3 EVALSHA)
      • [2.4 SCRIPT FLUSH](#2.4 SCRIPT FLUSH)
      • [2.5 其他](#2.5 其他)
    • [3. 脚本复制](#3. 脚本复制)
    • [4. 案例演示](#4. 案例演示)
      • [4.1 限流](#4.1 限流)
      • [4.2 分布式锁](#4.2 分布式锁)

1. 概述

官方文档

Lua 语言是一种小巧的、高效的、可嵌入的脚本编程语言,由巴西里约热内卢天主教大学 的一个研究小组于 1993 年开发。设计目的是为了通过灵活嵌入应用程序中,为应用程序提供灵活的扩展和定制功能。

参考资料:

Redis 2.6 版本开始支持用户在服务器上传和执行 Lua 脚本,从而实现复杂的操作逻辑。脚本在 Redis 中是以字符串的形式传递给服务器的,然后服务器会执行这些脚本并返回结果。脚本在 Redis 中由内置的执行引擎执行。目前,仅支持一个脚本引擎,即 Lua 5.1 解释器。

Lua 脚本的优势:

  • 原子性:保证一个 Lua 脚本在执行期间是原子性的,即脚本执行期间不会被其他命令打断。在执行脚本期间,服务器的所有活动都会被阻塞,直到脚本运行结束。
  • 减少网络开销:可以将多个命令打包成一个 Lua 脚本执行,减少与 Redis 服务器的网络交互次数。
  • 复用性:可以将复杂的逻辑编写成 Lua 脚本,然后在多个地方重复使用。
  • 高效率:于脚本在服务器上执行,因此从脚本读取和写入数据非常高效。

注意事项:脚本被视为客户端应用程序的一部分,因此它们没有名称、版本或持久性。因此,如果脚本丢失(例如在服务器重新启动、故障切换到副本后等),所有脚本可能需要随时由应用程序重新加载

2. 常用命令

2.1 EVAL

在服务端执行 Lua 脚本。

语法格式:

java 复制代码
EVAL script numkeys [key [key ...]] [arg [arg ...]]

参数说明:

  • scriptLua 编写的脚本源代码
  • numkeys :脚本中用到的 key 的数量
  • [key [key ...]]key 键名称列表,在脚本中可以使用 KEYS[] 进行占位,例如 EVAL 的第三个参数会被赋值给 KEYS[1] ,多个依次类推
  • [arg [arg ...]]:参数列表,在脚本中可以使用 ARGV[] 进行占位,例如 EVAL 的第四个参数会被赋值给 ARGV[1] ,多个依次类推

注意事项:

  • 禁止滥用 Lua EVAL ,例如,每次调用 EVAL 时生成不同的脚本。这些脚本将被添加到 Lua 解释器并缓存到服务端,随着时间的推移会消耗大量内存。
  • Redis 7.4 开始,使用 EVALEVAL_RO 加载的脚本将根据一定数量(按最近最少使用顺序)从 Redis 中删除。可以通过 INFO 命令查看被驱逐的脚本数量。

为了确保脚本在单机和集群环境中正确执行,还需要注意:

  • Lua 脚本的操作应该基于传递给脚本的参数进行,而不应该直接访问存储中的数据结构内容,例如哈希表、列表或集合。
  • 不支持动态键名访问或基于数据内容的键名计算,因此所有访问的键必须在执行脚本时已经确定。这些输入键的名称作为 KEYS 全局运行时变量提供给 Lua 脚本使用。

简单示例:

bash 复制代码
localhost:0>EVAL "return 'Hello, scripting!'" 0
"Hello, scripting!"

示例说明:

  • return 'Hello, scripting!':使用双引号包含的脚本源代码,返回一个字符串
  • 0:没有使用到键

包含参数示例:

bash 复制代码
localhost:0>EVAL "return ARGV[1]" 0 Hello
"Hello"

示例说明:

  • 0:没有使用到键
  • Hello:将 Hello 传递给 ARGV[1]

包含键、参数示例:

bash 复制代码
redis> EVAL "return { KEYS[1], KEYS[2], ARGV[1], ARGV[2], ARGV[3] }" 2 key1 key2 arg1 arg2 arg3
1) "key1"
2) "key2"
3) "arg1"
4) "arg2"
5) "arg3"

示例说明:

  • 2:包含两个键
  • key1:将 Hello 传递给 KEYS[1],按照位置顺序依次类推
  • arg1:将 arg1 传递给 ARGV[1],按照位置顺序依次类推

可以通过 redis.call()redis.pcall()Lua 脚本中调用 Redis 命令,区别在于处理运行时错误(例如语法错误)的方式:

  • call():如果发生错误,错误会直接返回给执行它的客户端
  • pcall():遇到的错误会返回到脚本的执行环境

示例:

bash 复制代码
EVAL "return redis.call('SET', KEYS[1], ARGV[1])" 1 foo bar
OK

2.2 SCRIPT LOAD

每次调用 EVAL 命令时,请求中都会包括脚本的源代码,重复调用来执行相同的脚本集会浪费网络带宽,并且在 Redis 中也会产生一些额外开销,因此 Redis 提供了脚本的缓存机制。

使用 SCRIPT LOAD 可以将 Lua 脚本加载到 Redis 服务器,服务器不会执行脚本,而是仅编译并加载到服务器的缓存中。加载后返回一个 SHA1 摘要,唯一标识了它在缓存中的位置,该摘要可以用于执行已加载的脚本。

语法格式:

bash 复制代码
SCRIPT LOAD script

注意事项:

  • 脚本缓存始终是易失性的,它不被视为数据库的一部分,也不会持久化存储。当服务器重新启动、在故障转移时从副本切换为主服务器时,或者通过调用 SCRIPT FLUSH 命令时,缓存可能会被清空。
  • 应用程序应首先用 SCRIPT LOAD 加载脚本,然后再次调用 EVALSHA 运行缓存的脚本。大多数 Redis 客户端已经提供了自动执行此过程的 API

示例:

bash 复制代码
redis> SCRIPT LOAD "return 'Immabe a cached script'"
"c664a3bf70bd1d45c4284ffebb65a6f2299bfc9f"
redis> EVALSHA c664a3bf70bd1d45c4284ffebb65a6f2299bfc9f 0
"Immabe a cached script

2.3 EVALSHA

用于执行已加载的 Lua 脚本。

语法格式:

bash 复制代码
EVALSHA <sha1> <numkeys> <key> [key ...] <arg> [arg ...]

参数说明:

  • <sha1>:之前已加载缓存的 Lua 脚本的 SHA1 值。

示例:

bash 复制代码
127.0.0.1:6379> SCRIPT LOAD "local key = KEYS[1]\nlocal value = ARGV[1]\n\nredis.call('SET', key, value)"
"5b405e1d1f5c91b27e7e2b091380a848d38a99d6"
127.0.0.1:6379> EVALSHA 5b405e1d1f5c91b27e7e2b091380a848d38a99d6 1 mykey "myvalue"
OK

注意事项:

  • SHA1 对应的脚本不存在时,会报错
  • 在使用管道时,尽量不要使用 EVALSHA ,管道请求中的命令按发送顺序执行,但其他客户端的命令可能会在这些命令之间交错执行。因此,可能会从管道请求中返回NOSCRIPT错误,但无法进行处理。因此,在管道中应当使用普通的 EVAL 或带参数的 EVAL

2.4 SCRIPT FLUSH

清空 Lua 脚本缓存。默认情况下,SCRIPT FLUSH 命令会同步清空缓存。从 Redis 6.2 开始,设置 lazyfree-lazy-user-flush 配置指令为 "yes" 将改变默认的清空模式为异步。

语法格式:

bash 复制代码
SCRIPT FLUSH [ASYNC | SYNC]

参数说明:

  • ASYNC:异步清空缓存
  • SYNC:同步清空缓存

注意事项:

  • 运行命令将完全清空脚本缓存,删除到目前为止执行的所有脚本。
  • 在正常操作期间,脚本应该在缓存中无限期地保留。

示例:

bash 复制代码
localhost:0>SCRIPT FLUSH
"OK"

2.5 其他

其他脚本相关的命令:

  • EVAL_ROEVAL 命令的只读变体,不能执行修改数据的命令。
  • EVALSHA_ROEVALSHA 命令的只读变体,不能执行修改数据的命令。
  • SCRIPT DEBUG:控制内置的 Redis Lua 脚本调试器。
  • SCRIPT EXISTS:判断脚本已存在于缓存中,一个或多个 SHA1 摘要作为参数。返回 1 表示存在, 0 不存在。
  • SCRIPT KILL:中断长时间运行脚本(即慢脚本)的唯一方式,除非关闭服务器。脚本在执行时间超过配置的最大执行时间阈值后被视为慢脚本。只能用于在执行期间未修改数据集的脚本(因为停止只读脚本不会违反脚本引擎的原子性保证)。

3. 脚本复制

集群部署环境下,至少有三个主节点,每个主节点有一个或多个从节点,主从之间使用完全复制保持数据一致性。由于脚本可以修改数据,Redis 确保脚本执行的所有写操作也会被发送到从节点以保持一致性。

脚本复制有以下两种方式:

  • 逐字复制:主节点将脚本的源代码发送到副本,副本然后执行脚本并应用写入效果。
  • 效果复制:只复制脚本的数据修改命令,副本随后运行这些命令而不执行任何脚本。

逐字复制模式意味着副本会重新执行主节点已完成的工作,这是一种浪费。更重要的是,它还要求所有写入脚本都是确定性的。效果复制模式虽然在网络流量方面可能更为冗长,但这种复制模式是确定性的,因此不需要特别考虑其他情况。

直到 Redis 3.2 版本之前,逐字脚本复制是唯一支持的模式,在 Redis 3.2 中添加了效果复制。在 Redis 5.0 中,效果复制成为默认模式,截至 Redis 7.0 ,不再支持逐字复制。

在效果复制模式下,当 Lua 脚本执行时, Redis 会收集 Lua 脚本引擎实际修改数据集的所有命令。当脚本执行结束时,脚本生成的命令序列会被封装成一个 MULTI/EXEC 事务,并发送到副本和 AOF

效果复制的优势:

  • 当脚本计算速度较慢,可以由少数写入命令替换时,重新在副本或重新加载 AOF上计算脚本是一种浪费。在这种情况下,仅复制脚本的效果要好得多。
  • 解除了非确定性函数的限制。例如,您可以在脚本中任意使用 TIMESRANDMEMBER 命令。
  • Lua 伪随机数生成器在每次调用时都是随机种子。

4. 案例演示

Redis 命令的执行是单线程的,Lua 脚本在执行期间是原子性的,并且可以同时执行多个命令。特别适用于多线程环境下,需要保证多个复杂操作的原子性的场景。

4.1 限流

演示需求: 基于固定时间窗口进行 IP 限流, 同一 IP 在一分钟内,只允许访问固定的次数。

resources 目录下添加限流脚本文件:

lua 复制代码
local ipKey = KEYS[1]; -- IP地址
local rate = tonumber(ARGV[1]); -- 允许的请求次数
local requestCount = redis.call('incr', ipKey); -- 每次请求 + 1
if (requestCount == 1) then -- 第一次请求
    redis.call('expire', ipKey, 60); -- 设置过期时间(60S)
    return true ; -- 返回是否允许访问
else -- 不是第一次请求
    if (requestCount > rate) then -- 如果当前请求次数大于允许的请求次数
         return false ;
    end
end

使用 Lettuce 客户端执行脚本:

java 复制代码
    public static void main(String[] args) {
        // 创建客户端
        RedisClient redisClient = RedisClient.create("redis://:123456@127.0.0.1:6379/0");
        // 获取连接
        try (StatefulRedisConnection<String, String> connection = redisClient.connect()) {
            // 执行命令
            RedisCommands<String, String> sync = connection.sync();
            // 获取脚本流
            byte[] lua = getResourceAsByteArray("limit.lua"); 
            // 执行脚本
            boolean eval = sync.eval(lua, ScriptOutputType.BOOLEAN, new String[]{"127.0.0.1"}, "1");
            // 结果判断
            if (!eval) {
                System.out.println("当前访问过于频繁,请稍后重试");
            } else {
                System.out.println("允许访问");
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            redisClient.shutdown();
        }
    }

    public static byte[] getResourceAsByteArray(String resourceName) throws IOException {
        // 使用ClassLoader获取资源作为输入流
        try (InputStream inputStream = LuaTest.class.getClassLoader().getResourceAsStream(resourceName)) {
            if (inputStream == null) {
                return null;
            }
            // 将输入流转换为字节数组
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int length;
            while ((length = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, length);
            }
            return outputStream.toByteArray();
        }
    }

4.2 分布式锁

演示需求: 商品秒杀防止超卖,使用 Redis +Lua 实现分布式锁(生产环境请使用成熟的框架)。

获取锁的命令:

bash 复制代码
SET key value NX EX expire_time

简单的实现原理:

  • 使用 SET NX... 命令设置值,设置成功表示获取到的锁,反之未获取(直接返回失败或循环重试),并设置一个过期时间(避免死锁)
  • 获取到锁后,执行业务逻辑
  • 执行完成后释放锁

resources 目录下添加尝试获取锁脚本文件 tryLock.lua

bash 复制代码
local lockKey = KEYS[1] -- 锁的key
local lockValue = ARGV[1]   -- 锁的值
local lockExpireTime = tonumber(ARGV[2])  -- 锁的过期时间(秒)
local acquiredLock = redis.call('SET', lockKey, lockValue, 'NX', 'EX', lockExpireTime) -- 获取锁
if acquiredLock then
    return true   -- 获取锁成功
else
    return false -- 获取锁失败
end

添加删除锁脚本文件 unlock.lua

bash 复制代码
local lockKey = KEYS[1] -- 锁的key
redis.call('DEL', lockKey) -- 删除锁

创建工具类封装相关分布式锁逻辑:

java 复制代码
public class RedisLockUtils {

    /**
     * 尝试获取锁
     *
     * @param sync   连接
     * @param key    锁的 Key
     * @param value  锁的值
     * @param second 过期时间
     * @return 是否获取到锁
     * @throws IOException
     */
    public static boolean tryLock(RedisCommands<String, String> sync, String key, String value, String second) throws IOException {
        byte[] lua = RedisLockUtils.getResourceAsByteArray("tryLock.lua"); // 获取脚本流
        return sync.eval(lua, ScriptOutputType.BOOLEAN, new String[]{key}, value, second);      // 执行脚本
    }


    /**
     * 删除锁
     *
     * @param sync 连接
     * @param key  锁的 Key
     * @return 是否获取到锁
     * @throws IOException
     */
    public static void unlock(RedisCommands<String, String> sync, String key) throws IOException {
        byte[] lua = RedisLockUtils.getResourceAsByteArray("unlock.lua");
        boolean eval = sync.eval(lua, ScriptOutputType.BOOLEAN, new String[]{key});
    }


    public static byte[] getResourceAsByteArray(String resourceName) throws IOException {
        // 使用ClassLoader获取资源作为输入流
        try (InputStream inputStream = LuaLimitTest.class.getClassLoader().getResourceAsStream(resourceName)) {
            if (inputStream == null) {
                return null;
            }
            // 将输入流转换为字节数组
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int length;
            while ((length = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, length);
            }
            return outputStream.toByteArray();
        }
    }
}

模拟秒杀,简单测试:

java 复制代码
public class LuaLockTest {

    private static Integer stockCount = 100; // 商品库存数量
    private static String goodsId = "899632563356632489"; // 商品库存数量

    public static void main(String[] args) {
        // 创建客户端
        RedisClient redisClient = RedisClient.create("redis://:123456@127.0.0.1:6379/0");
        // 获取连接
        try (StatefulRedisConnection<String, String> connection = redisClient.connect()) {


            // 秒杀逻辑
            try {
                // 获取到锁
                if (RedisLockUtils.tryLock(connection.sync(), goodsId, "123456", "10")) {
                    // 减库存
                    if (stockCount > 0) {
                        stockCount = stockCount - 1;
                        System.out.println("减库存成功,剩余库存:" + stockCount);
                    } else {
                        System.out.println("库存不足");
                    }
                } else {
                    System.out.println("库存不足");
                }
            } finally {
                // 释放锁
                RedisLockUtils.unlock(connection.sync(), goodsId);
            }


        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            redisClient.shutdown();
        }
    }
}
相关推荐
CoderIsArt1 小时前
Redis的三种模式:主从模式,哨兵与集群模式
数据库·redis·缓存
ketil275 小时前
Redis - String 字符串
数据库·redis·缓存
红黑色的圣西罗7 小时前
Lua 怎么解决闭包内存泄漏问题
开发语言·lua
王佑辉7 小时前
【redis】延迟双删策略
redis
生命几十年3万天8 小时前
redis时间优化
数据库·redis·缓存
Shenqi Lotus9 小时前
Redis-“自动分片、一定程度的高可用性”(sharding水平拆分、failover故障转移)特性(Sentinel、Cluster)
redis·sentinel·cluster·failover·sharding·自动分片·水平拆分
java知路10 小时前
springboot 基于google 缓存,实现防重复提交
spring boot·后端·缓存
_.Switch11 小时前
Serverless架构与自动化运维
运维·python·缓存·自动化·运维开发
YMY哈12 小时前
Redis常见面试题(二)
redis
元气满满的热码式13 小时前
Redis常用的五大数据类型(列表List,集合set)
数据库·redis·缓存