Redis+lua脚本实现分布式锁

已于 2025-04-14 11:28:14 修改
阅读量1.2k 收藏 31
点赞数 29
文章标签： redis lua 分布式
于 2025-03-31 22:46:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42945407/article/details/146802755
版权

文章目录

概念

分布式锁是一种在分布式系统中协调多个进程或线程对共享资源进行访问的同步机制。它的主要作用是保证在分布式环境下，对共享资源的访问具有互斥性，即同一时刻只有一个客户端能够获取到锁并访问共享资源，其他客户端需要等待锁释放后才能继续尝试获取锁

特点

  1. 互斥性：这是分布式锁最核心的特性，同一时刻只能有一个客户端持有锁，确保对共享资源的访问是排他的，避免多个客户端同时修改共享资源导致的数据不一致问题。
  2. 可重入性：允许同一个客户端在持有锁的情况下，再次获取该锁而不会被阻塞。这在一些递归调用或者嵌套操作的场景中非常有用，可以避免死锁的发生。
  3. 高可用性：分布式系统可能会面临各种故障，如网络故障、服务器故障等。因此，分布式锁需要具备高可用性，即使部分节点出现故障，仍然能够正常工作，保证系统的稳定性。
  4. 容错性：在出现异常情况（如客户端崩溃、网络中断等）时，分布式锁应该能够自动释放，避免出现死锁的情况，确保系统能够继续正常运行。
    高性能：由于分布式锁的获取和释放操作通常会频繁进行，因此需要具备较高的性能，以减少对系统性能的影响

为什么使用Lua脚本

通过使用Lua脚本和Redis的原子操作，可以有效地实现分布式锁，以确保在分布式系统中数据的一致性和互斥访问。
Lua脚本在Redis中的执行是原子性的，即Redis会将整个脚本作为一个不可分割的整体执行，中间不会被其他命令插入。这意味着，通过Lua脚本可以将多个操作组合成一个原子操作，这对于分布式锁的实现至关重要。例如，释放锁的操作需要检查当前的锁是否属于当前线程，并在是的情况下删除锁，这两个操作必须是原子性的，否则可能会导致锁被错误释放。

实现原理

  1. 加锁原理
SET lock_key unique_value NX PX expire_time

加锁操作主要利用 Redis 的 SET 命令，并结合 NX（仅在键不存在时设置）和 PX（设置过期时间）。

  • lock_key：代表锁的键名，多个客户端竞争的就是这个锁。
  • unique_value：是客户端生成的唯一值，用于标识该客户端，确保只有持有该锁的客户端才能释放锁。
  • NX：保证只有当 lock_key 不存在时，才能设置成功，也就是只有一个客户端能获取到锁。
  • PX：用于设置锁的过期时间（单位为毫秒），防止客户端在持有锁期间出现异常，导致锁无法释放。
  1. 解锁原理
if redis.call('get', KEYS[1]) == ARGV[1] then
	return redis.call('del', KEYS[1])
else
	return 0
end

以上是一个简单的Lua脚本示例，用于释放分布式锁。这段脚本的逻辑是：首先检查给定的key（KEYS[1]）对应的值是否等于提供的ARGV[1]（通常是一个唯一标识符，如UUID），如果是，则删除这个key来释放锁（通过DEL命令）；如果不是，或者key不存在，则返回0表示释放锁失败。

Redis+Lua的优点

1.实现简单

借助 Redis 的基本命令和 Lua 脚本的简单语法，就能轻松实现分布式锁的核心逻辑。开发者无需引入复杂的分布式协调系统，降低了开发和维护的难度。

2.性能高效

Redis 本身是基于内存的高性能键值存储系统，响应速度极快。而且 Lua 脚本在 Redis 中的执行是在服务器端完成的，减少了客户端与服务器之间的多次通信开销，提升了加锁和解锁操作的性能。

3. 保证原子性

Lua 脚本在 Redis 中是原子执行的，这意味着在执行脚本期间，Redis 不会执行其他命令。在分布式锁场景中，像加锁和解锁这类操作可以通过 Lua 脚本封装成一个原子操作，避免了多个命令执行过程中出现竞态条件。

4.过期机制

Redis 的 SET 命令可以设置键的过期时间，在加锁时可以同时指定锁的过期时间。这样即使持有锁的客户端发生故障，锁也会在过期时间后自动释放，避免了死锁的发生。

5.可扩展性

Redis 支持集群和分布式部署，能够通过增加节点来扩展系统的处理能力。基于 Redis 实现的分布式锁可以很方便地在不同的环境中进行扩展，以满足高并发场景的需求。

Redis+Lua的缺点

1.时钟漂移问题

在 Redis 的过期机制中，依赖系统时钟来判断锁是否过期。如果不同节点之间的时钟存在漂移，可能会导致锁提前或延迟释放，从而引发并发问题。

2.不适合长事务

由于 Redis 锁的过期时间是固定的，如果业务逻辑中的事务执行时间过长，可能会导致锁提前过期，从而引发并发问题 。
解决方式： 可以使用redisson（看门狗机制）

3.锁释放的可靠性

尽管使用 Lua 脚本可以保证解锁操作的原子性，但在某些极端情况下，如客户端崩溃或网络中断，可能会导致锁无法正常释放。虽然可以通过设置过期时间来解决部分问题，但在过期时间内，其他客户端仍然无法获取到锁。

4.单点故障风险

如果 Redis 采用单节点部署，一旦该节点出现故障，整个分布式锁系统将无法正常工作，导致业务受到影响。

5.网络延迟影响

虽然 Redis 本身性能很高，但客户端与 Redis 服务器之间的网络延迟可能会影响锁的获取和释放操作。在高并发场景下，网络延迟可能会导致锁的竞争加剧，降低系统的性能。

代码实现

自定义注解 （DistributedLockAnnotation）

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义注解，用于标记需要加分布式锁的方法
 */
@Target(ElementType.METHOD) // 该注解可以应用于方法上
@Retention(RetentionPolicy.RUNTIME) // 注解在运行时可见
public @interface DistributedLockAnnotation {
    /**
     * 锁的键名，必须由使用该注解的地方指定
     * @return 锁的键名
     */
    String lockKey();

    /**
     * 锁的过期时间，默认值为 5000 毫秒
     * @return 锁的过期时间
     */
    int expireTime() default 5000;
}

分布式锁切面类（DistributedLockAspect）

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.lang.reflect.Method;

/**
 * 分布式锁切面类，用于处理使用 DistributedLockAnnotation 注解的方法
 */
@Aspect // 标记该类为切面类
@Component
public class DistributedLockAspect {

    // 定义 Jedis 连接池对象
    private final JedisPool jedisPool;

    /**
     * 构造函数，初始化 Jedis 连接池
     */
    public DistributedLockAspect() {
        // 创建 Jedis 连接池配置对象
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        // 初始化 Jedis 连接池，连接到本地 Redis 服务器，端口为 6379
        this.jedisPool = new JedisPool(poolConfig, "localhost", 6379);
    }

    /**
     * 环绕通知，拦截所有使用 DistributedLockAnnotation 注解的方法
     * @param joinPoint 连接点对象，包含被拦截方法的信息
     * @return 被拦截方法的返回值
     * @throws Throwable 可能抛出的异常
     */
    @Around("@annotation(com.platform.toolsplatform.common.lock.DistributedLockAnnotation)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取方法签名
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        // 获取被拦截的方法
        Method method = signature.getMethod();
        // 获取方法上的 DistributedLockAnnotation 注解
        DistributedLockAnnotation annotation = method.getAnnotation(DistributedLockAnnotation.class);
        // 获取注解中指定的锁的键名
        String lockKey = annotation.lockKey();
        // 获取注解中指定的锁的过期时间
        int expireTime = annotation.expireTime();

        // 创建分布式锁对象
        DistributedLock lock = new DistributedLock(jedisPool, lockKey, expireTime);
        // 尝试获取锁
        if (lock.acquire()) {
            try {
                // 执行被拦截的方法
                return joinPoint.proceed();
            } finally {
                // 释放锁
                lock.release();
            }
        } else {
            // 输出未能获取到锁的信息
            System.out.println("未能获取到锁");
            return null;
        }
    }
}

分布式类实现（DistributedLock）

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.util.Collections;
import java.util.UUID;

/**
 * 分布式锁类，利用 Redis 和 Lua 脚本来实现分布式锁功能
 */
public class DistributedLock {

    // 定义设置锁成功时 Redis 返回的结果
    private static final String LOCK_SUCCESS = "OK";
    // 定义 Redis SET 命令的 NX 选项，仅在键不存在时设置
    private static final String SET_IF_NOT_EXIST = "NX";
    // 定义 Redis SET 命令的 PX 选项，用于设置键的过期时间（单位：毫秒）
    private static final String SET_WITH_EXPIRE_TIME = "PX";
    // 定义释放锁成功时 Lua 脚本的返回值
    private static final Long RELEASE_SUCCESS = 1L;

    // 定义用于解锁的 Lua 脚本
    private static final String UNLOCK_LUA;

    // 静态代码块，用于初始化解锁的 Lua 脚本
    static {
        // 创建一个 StringBuilder 对象，用于构建 Lua 脚本
        StringBuilder sb = new StringBuilder();
        // 检查锁的值是否与当前客户端的标识一致
        sb.append("if redis.call(\"get\", KEYS[1]) == ARGV[1] ");
        // 如果一致，则删除该锁
        sb.append("then ");
        sb.append("    return redis.call(\"del\", KEYS[1]) ");
        // 如果不一致，则返回 0
        sb.append("else ");
        sb.append("    return 0 ");
        sb.append("end ");
        // 将 StringBuilder 中的内容转换为字符串并赋值给 UNLOCK_LUA
        UNLOCK_LUA = sb.toString();
    }

    // 定义 Jedis 连接池对象
    private final JedisPool jedisPool;
    // 定义锁的键名
    private final String lockKey;
    // 定义客户端的唯一标识
    private final String clientId;
    // 定义锁的过期时间（单位：毫秒）
    private final int expireTime;

    /**
     * 构造函数，初始化分布式锁对象
     * @param jedisPool Jedis 连接池对象
     * @param lockKey 锁的键名
     * @param expireTime 锁的过期时间（单位：毫秒）
     */
    public DistributedLock(JedisPool jedisPool, String lockKey, int expireTime) {
        this.jedisPool = jedisPool;
        this.lockKey = lockKey;
        this.clientId = UUID.randomUUID().toString();
        this.expireTime = expireTime;
    }

    /**
     * 尝试获取锁
     * @return 如果获取锁成功返回 true，否则返回 false
     */
    public boolean acquire() {
        // 使用 try-with-resources 语句确保 Jedis 连接在使用后自动关闭
        try (Jedis jedis = jedisPool.getResource()) {
            // 调用 Jedis 的 set 方法尝试获取锁，设置 NX 和 PX 选项
            String result = jedis.set(lockKey, clientId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);
            // 判断是否设置成功
            return LOCK_SUCCESS.equals(result);
        }
    }

    /**
     * 释放锁
     * @return 如果释放锁成功返回 true，否则返回 false
     */
    public boolean release() {
        // 使用 try-with-resources 语句确保 Jedis 连接在使用后自动关闭
        try (Jedis jedis = jedisPool.getResource()) {
            // 执行 Lua 脚本释放锁，传入锁的键名和客户端标识
            Object result = jedis.eval(UNLOCK_LUA, Collections.singletonList(lockKey), Collections.singletonList(clientId));
            // 判断是否释放成功
            return RELEASE_SUCCESS.equals(result);
        }
    }
}

使用教程

import org.springframework.stereotype.Service;

/**
 * 测试类，演示如何使用 DistributedLockAnnotation 注解
 */
@Service // 标记该类为服务组件
public class TestClass {

    /**
     * 测试方法，使用 DistributedLockAnnotation 注解加分布式锁
     */
    @DistributedLockAnnotation(lockKey = "my_lock")
    public void testMethod() {
        // 输出获取锁成功的信息
        System.out.println("成功获取到锁，开始执行临界区代码");
        // 模拟临界区代码执行
    }
}

扩展

通过以上知识获取锁，释放锁的逻辑 可以延展出 Redis+Lua脚本可以实现限流的业务场景实现。
通过文献查阅得知：是可以稳定达到对上亿级别的高并发流量进行限流的

搬砖小匠
关注
Redis + Lua 脚本实现分布式锁：从原理到实战，万字详解！
Leaton的博客
02-21 815
Redis凭借其高性能、高可用性和原子操作特性，成为了分布式锁的事实标准。而结合Lua脚本，则可以进一步提升锁的性能和安全性。通过这篇文章，你已经掌握了 Redis + Lua 脚本实现分布式锁的核心技能。这篇文章将手把手教你如何利用Redis和Lua脚本实现高效、可靠的分布式锁！Lua 是 Redis 的内置脚本语言，支持在服务端执行复杂逻辑。A1：Lua 脚本可以在 Redis 服务端执行复杂逻辑，保证操作的原子性，避免竞态条件。分布式锁是一种基于分布式存储系统的锁机制，用于控制对共享资源的访问。
使用redis+lua脚本实现分布式锁
不能说的秘密的博客
04-15 6350
分布式锁的应用场景 当多个机器（多个进程）会对同一条数据进行修改时，并且要求这个修改是原子性的。这里有两个限定： 多个进程之间的竞争，意味着JDK自带的锁失效； 原子性修改，意味着数据是有状态的，修改前后有依赖。 本文将先介绍Redis的实现方式，后面笔者会介绍分布式锁的其他实现。 在学习Redis实现分布式锁的过程中，笔者首先参考了Redis的官方文档实现Red...
使用 Redis 和 Lua 实现分布式锁
BXA
06-10 4324
分布式锁是一种用于多台服务器上处理同一资源的并发访问的锁机制。它用于协调分布式系统中的各个节点，确保它们的操作不会相互干扰。Redis （Remote Dictionary Server）是一种使用 C 语言编写的，开源的 in-memory 数据库系统，支持多种数据结构类型，如字符串、哈希表、列表、集合等。由于其可高效地存储键值对，并且具有多种灵活的使用方式，因此经常被用作缓存、会话存储和消息队列等场景。
基于redis+lua脚本的分布式锁实现
weixin_50336269的博客
08-27 498
基于lua脚本的分布式锁实现
分布式锁2：基于redis实现分布式锁 setnx+lua脚本
健康平安的活着的专栏
10-11 2592
redis中setnx+expire是非原子操作, 除了用LUA脚本保证实现原子操作, 其实可以直接使用redis自带的set方法直接实现.setnx+expire+del 命令实现redis的分布式锁；其中 setnx 不存在则新增；给锁设置一个过期时间，防止锁忘记了释放。来抢锁，如果抢到之后，再用。
基于Redis+lua实现的分布式锁
ybobob_的博客
06-26 532
【代码】基于Redis+lua实现的分布式锁。
【redis+lua实现分布式锁】
zishuijing_dd的博客
12-26 434
使用Lua原因 轻量 脚本执行原子化，这对于多线程或者多进程的环境中很重要。 使用常用的EVAL 命令： EVAL script numkeys key [key …] arg [rg …] 加锁 localhost:0>eval "if redis.call('EXISTS', KEYS[1]) == 0 then redis.call('set', KEYS[1], ARGV[1]) redis.call('expire', KEYS[1], ARGV[2]) return 1 else retu
基于redis和lua脚本的分布式锁的实现
01-08
“基于Redis和Lua脚本的分布式锁的实现” 基于Redis和Lua脚本的分布式锁的实现是使用Redis和Lua脚本来实现分布式锁的技术。分布式锁是指在分布式系统中，多个节点之间需要协调和同步的机制，以避免同时访问共享资源...
基于Redis+Lua脚本实现分布式限流组件封装的方法
12-14
本篇文章将探讨如何基于Redis和Lua脚本实现一个分布式限流组件的封装，以便在Spring Boot应用中优雅地控制请求速率。 首先，我们需要在`pom.xml`文件中引入必要的依赖。这里引入了`spring-boot-starter-data-redis`...
基于 Redis + Lua 脚本实现分布式锁，确保操作的原子性
热门推荐
Java Punk
12-16 1万+
Lua脚本是高并发、高性能的必备脚本语言，大部分的开源框架（如：redission）中的分布式锁组件，都是用纯lua脚本实现的。
java+redis+lua实现重复提交操作拦截.zip
05-18
- 用户发起请求，服务端接收到请求后，首先通过Redis Lua脚本尝试获取锁。 - 如果获取成功，执行业务逻辑，然后在完成操作后释放锁。 - 如果获取失败，说明有其他请求正在执行相同操作，此时可以直接返回错误信息...
Redis+Lua实现分布式锁
sinat_27548257的博客
01-16 4353
Redis+lua实现分布式锁 Lua 脚本功能是 Reids 2.6 版本的最大亮点， 通过内嵌对 Lua 环境的支持， Redis 解决了长久以来不能高效地处理 CAS （check-and-set）命令的缺点， 并且可以通过组合使用多个命令， 轻松实现以前很难实现或者不能高效实现的模式。 1. lua脚本在redis交互大致如下： 交互过程：redis 客户端发送一段lua脚本到redis...
redis脚本lua实现分布式锁,分布式锁
LMC技术人生专栏
12-12 3916
项目是基于springboot开发，前提要把redis环境配置好 使用一个中心化的锁服务 首先，我们需要一个所有线程都可以访问到的地方来存储锁。这个锁只能存在于一个地方，从而保证只有一个权威的地方可以定义锁的建立和释放。 Redis是实现锁的一个理想的候选方案。作为一个轻量级的内存数据库，快速，事务性和一致性是选择redis所为锁服务的主要原因。 设计锁 锁本身是很简单的，......
LUA脚本改造redis分布式锁
hguhbh的博客
07-29 1136
因为存在这样情况：线程一获取锁，去执行逻辑，过程中遇到网络动荡，线程一卡住了，然后一段时间后，线程一获取的锁的过期时间到了，线程一的锁自动释放。然后线程二来获取锁，线程二获取成功，去执行逻辑，而在这个过程中线程一的网络动荡恢复了，线程一继续执行，线程一先于线程二执行完，线程一去释放锁，但此时线程一创建的锁已经因超时而自动释放了，所以此时线程一会去错误的释放线程二的锁，所以我们要把线程id存入加以判断，防止误删其他线程的id。并不是一步一步的执行，所以只能用乐观锁但不建议用乐观锁，推荐用lua脚本。
lua脚本实现的分布式锁
weixin_43458072的博客
02-23 2335
用lua脚本实现的分布式锁 lua脚本的概念什么的网上一堆就不说了，简单说下这里就是利用了redis对于lua脚本会原子性执行的特性来保证我们可以连续对一个键值对进行操作而不用担心冲突。 脚本内容： 加锁：“if redis.call(‘get’,KEYS[1])==false then return redis.call(‘set’,KEYS[1],ARGV[1],‘NX’,‘PX’,”+LOCK_HOLD_TIME+") elseif redis.call(‘get’,KEYS[1])==ARGV[1]
Redis实现分布式锁
落日的博客
04-13 516
Redis+lua脚本实现分布式锁 Redission
使用Redis+Lua脚本实现分布式锁
Cure The World的博客
05-09 2374
1.1加锁 // 1. 从redis中获取锁,set k1 v1 px 20000 nx String uuid = UUID.randomUUID().toString(); Boolean lock = this.redisTemplate.opsForValue().setIfAbsent("lock", uuid, 2, TimeUnit.SECONDS); 使用Lua释放锁 // 2. 释放锁 del String script = "if redis.call('get', KEYS[1])
Redis+lua实现分布式锁（非重入锁）
sinat_34842630的博客
08-13 294
流程图： 代码 public class LockRedis { private static final Logger logger = LoggerFactory.getLogger(LockRedis.class); @Autowired private RedisTemplate<String, Object> redisTemplate; private ThreadLocal<String> lockFlag = new .
redis 使用lua脚本实现分布式锁
最新发布
10-13
Redis通过Lua脚本实现了分布式锁的功能，主要是利用了其强一致性的特点以及剧本（Scripting）特性。 Lua脚本在Redis服务器上执行，可以避免网络延迟带来的竞争条件问题，从而保证分布式环境下的线程安全。 以下是使用Lua脚本实现分布式锁的基本步骤： 1. **设置锁key**：创建一个特定的键（如`my_lock`），作为锁标识。 2. **原子操作**：编写一个Lua脚本，该脚本通常包含两个关键操作：尝试获取锁（如果锁未被其他客户端持有则设置一个过期时间）和释放锁（删除键）。例如： ```lua if redis.call("GET", KEYS[1]) == nil then local expiration = tonumber ARGV[1] -- 过期时间 redis.call("SET", KEYS[1], EXPIRE, KEYS[1], expiration) -- 设置锁并设置过期时间 return "locked" -- 锁成功获取 else return "already_locked" -- 锁已被占用 end ``` 3. **原子提交**：客户端调用Redis的`EVALSHA`或`EVAL`命令，将上述脚本、所需参数（如锁的过期时间）和锁的key作为输入。因为Redis的scripting引擎会作为一个事务执行整个脚本，所以不会发生并发冲突。 4. **解锁**：当需要释放锁时，只需调用`DEL`命令移除锁的key即可，由于之前已经设置了过期时间，在超时后会自动解锁。 5. **错误处理**：需要考虑脚本执行失败的情况，比如内存溢出等，并确保正确的异常处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值