Redisson分布式锁原理解析

最新推荐文章于 2024-06-18 19:45:17 发布
最新推荐文章于 2024-06-18 19:45:17 发布
阅读量1.2k 收藏 13
点赞数 34
文章标签： redis redisson java spring 锁 分布式 lock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28911061/article/details/139535632
版权

前言

首先Redis执行命令是单线程的，所以可以利用Redis实现分布式锁，而对于Redis单线程的问题，是其线程模型的问题，本篇重点是对目前流行的工具Redisson怎么去实现的分布式锁进行深入理解；开始之前，我们可以下你思考一个问题，Redisson的实现方式有何不同？为什么？

使用

引入依赖

 <dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.25.0</version>
</dependency>

添加配置

    @Autowired
    private RedisProperties redisProperties;

    @Bean
    public RedissonClient redisClient() {
        Config config = new Config();
        config.setTransportMode(TransportMode.NIO);
        SingleServerConfig singleServerConfig = config.useSingleServer();
        singleServerConfig.setAddress(String.format("redis://%s:%s", redisProperties.getHost(), redisProperties.getPort()));
        singleServerConfig.setPassword(redisProperties.getPassword());
        return Redisson.create(config);
    }

加锁

private final RedissonClient redissonClient;


public void lock() throws Exception {
    RLock lock = redissonClient.getLock(PRODUCT_LOCK_KEY + id);
    if (lock.tryLock(100, TimeUnit.MILLISECONDS)) {
        // 业务
    } else {
        // 业务
    }
}

如上使用是最简单的方式，Redission它底层封装了很多逻辑，但如果说要redis客户端实现，你要怎么实现？

Redis中本就有支持分布式锁的命令：setnx，对应RedisTemplate中，使用如下：

redisTemplate.opsForValue().setIfAbsent("lockkey", "", 1, TimeUnit.SECONDS);

使用Redis实现分布式锁需要注意的是不要产生死锁，所以使用Redis实现分布式锁有两种方式：

  1. setnx命令
  2. lua脚本

两种方式都是一个操作完成key，value的设置以及过期时间的设置，你是否有相关，他们的实现是否都一样，或者说，这个实现可以有其他实现方式？

源码

原理

  1. lua脚本保证多个命令的原子性；
  2. 采用hash数据结构，key为锁的名称，field是线程对应的名称，也因为这个数据结构，也支持可重入锁；
  3. 定时延时的操作避免死锁（看门狗）；

lock()

我们先看lock()方法，tryLock()和lock()底层是一样的，所以我们只看lock方法；

   @Override
    public void lock() {
        try {
            lock(-1, null, false);
        } catch (InterruptedException e) {
            throw new IllegalStateException();
        }
    }

位置：org.redisson.RedissonLock#lock(long, java.util.concurrent.TimeUnit, boolean)

传参是：(-1, null, false)

image-20240402175531643

/**
leaseTime： 过期时间
unit：过期时间单位
interruptibly： 信号量，是否打断线程
*/
private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException {
    // 取线程ID，后面作为锁的一个标志
        long threadId = Thread.currentThread().getId();
    // 加锁
    // 两个步骤：
    // 1. 利用lua脚本设置锁与过期时间（原子操作），过期时间lockWatchdogTimeout = 30 * 1000 = 30秒
    // 2. 执行过期时间刷新（这里的刷新时利用回调的方式 + 延迟执行实现的定时任务），lockWatchdogTimeout/3 = 10秒
        Long ttl = tryAcquire(-1, leaseTime, unit, threadId);
        // lua脚本中，加锁成功返回nil，对应redis中是null，加锁失败，则返回的是已存在的锁的过期时间
    // 所以这里返回null，就是加锁成功了，就不再往下走了
        if (ttl == null) {
            return;
        }
	// 加锁成功的在上面就已经结束了，所以下面的都是加锁失败时走的
    // 这里它订阅了一个channel，参数threadId无用，别被误导了，它订阅的名称时固定的
    // 为什么这里要订阅？可以思考一下
        CompletableFuture<RedissonLockEntry> future = subscribe(threadId);
    // 检查是否超时
        pubSub.timeout(future);
        RedissonLockEntry entry;
    // 这里的interruptibly应该时程序一次时，是否结束，而不是一直在执行中
        if (interruptibly) {
            entry = commandExecutor.getInterrupted(future);
        } else {
            entry = commandExecutor.get(future);
        }

        try {
            // 这里就是一个自旋 + 加锁
            while (true) {
                // 每次循环都进行加锁操作
                ttl = tryAcquire(-1, leaseTime, unit, threadId);
                // 同样，如果这里时null，那么就是加锁成功了
                if (ttl == null) {
                    break;
                }

                // 加锁失败：返回了锁的过期时间
                if (ttl >= 0) {
                    try {
                        // 信号量 + unsafe.park 
                        // 信号量：本地更改线程共享变量状态达到加锁的目的
                        // unsafe.park：利用park方法将加锁失败（信号量更改失败）的线程进行挂起
                        // 为什么要挂起，这个问题应该不用多说
                        entry.getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                    } catch (InterruptedException e) {
                        if (interruptibly) {
                            throw e;
                        }
                        entry.getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                    }
                } else {
                    // 这个分支时ttl < 0，也就是过期时间为负数，也就是锁失效了
                    // 对本地加锁，之后在下一次循环redis加锁
                    if (interruptibly) {
                        entry.getLatch().acquire();
                    } else {
                        entry.getLatch().acquireUninterruptibly();
                    }
                }
            }
        } finally {
            unsubscribe(future, threadId);
        }
//        get(lockAsync(leaseTime, unit));
    }

上面的步骤就是Redisson大致逻辑：

  1. lua脚本加锁，记录线程id，防止非本线程解锁
  2. 成功则退出
  3. 添加订阅对应的channel（这里的订阅是异步的）
    1. 唤醒：当收到channel的通知后，也就是上一个锁解锁了
    2. 从第6步醒来
  4. 自旋
  5. lua脚本加锁（与第一步一样），存在订阅后，上一个锁解锁了，就不用再挂起线程
  6. 失败挂起：unsafe.park
  7. 加锁成功后，取消订阅

lua脚本加锁

image-20240402175746999image-20240402175814387

image-20240403103101607

简单说一下这个脚本做了什么（lua脚本类似js）：

redis.call是调用redis命令，第一个参数是redis的命令，第二个参数是参数；

它先是exists判断了key，以及hash数据结构了的field是否存在，

如果存在，对field递增，为什么要递增？思考一下；并设置过期时间，返回返回nil；

如果不存在，调用redis命令pttl，获取key的过期时间，并返回；

那如果我们自己写lua脚本呢？

redis 2.6之后支持lua脚本，一个脚本，执行这个脚本是原子性的，所以脚本里的多个命令是原子性的。

如果说要执行批量的命令，可以使用piple，但是管道的话，它并不是原子性的，他只是一次性把批量的命令发给了redis。

LUA脚本格式：

eval "脚本 KEYS[1...N] ARGV[1...N]" count key[1...N] argv[1...N]

KEYS[1…N]：key的展位符，多个时，序号递增，从1开始

ARGV[1…N]：value的展位符，多个时，序号递增，从1开始

count：是对应key输入的个数

key[1…N]：对应KEYS[0…N]的key

argv[1…N]：对应ARGV[0…N]的value

这里就大概简单的说明了一下，使得看本篇的朋友能够理解，详细的还请百度；

看门狗

使用过Redisson的朋友应该都听过“看门狗”，为什么Redisson加锁要看门狗呢？

如果我们使用lock()方法，不设置过期时间，那么应该是永不过期；

好，如果说，加锁成功，在解锁时出了意外，如服务异常退出，或宕机，导致没有解锁，那么这个锁就需要人工干预了，这是有问题的。

所以，在Redisson中，它并不是永不过期，当我们使用lock()方法时，它的参数时-1，但在最终执行lua脚本时传入了默认参数：

位置：org.redisson.RedissonLock#tryAcquireAsync

image-20240402205409341

过期时间时：internalLockLeaseTime；

image-20240402205832964image-20240402205846003

image-20240402205902393

可以看到在初始化时，它便赋予了该值一个默认的30秒；

它并没有将锁设置为无限时间，而是30秒，又怎么保证锁的有效？

所以它还有一个续约的操作，对未使用unlock的锁进行时间延迟，这一操作是为了保证未来某一时刻如果出现服务或其他问题导致解锁失败，产生死锁这样的一个情况。

来看代码：

 private RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
        RFuture<Long> ttlRemainingFuture;
     // leaseTime=-1表示永不过期
        if (leaseTime > 0) {
            // 对应方法：tryLock(过期时间, 时间单位)
            ttlRemainingFuture = tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
        } else {
            // 对应方法：lock()
            // 注意它达到参数是：internalLockLeaseTime，上面说了他是30秒
            // internalLockLeaseTime = lockWatchdogTimeout = 30 * 1000;
            ttlRemainingFuture = tryLockInnerAsync(waitTime, internalLockLeaseTime,
                    TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
        }
     
     // 这里是上面ttlRemainingFuture回调结果处理，
     // 如果出现异常，就unlock解锁
        CompletionStage<Long> s = handleNoSync(threadId, ttlRemainingFuture);
        ttlRemainingFuture = new CompletableFutureWrapper<>(s);
// 这里是定时刷新任务
        CompletionStage<Long> f = ttlRemainingFuture.thenApply(ttlRemaining -> {
            // 执行成功返回的时null，所以这里以null为加锁成功的标志
            if (ttlRemaining == null) {
                if (leaseTime > 0) {
                    internalLockLeaseTime = unit.toMillis(leaseTime);
                } else {
                    scheduleExpirationRenewal(threadId);
                }
            }
            return ttlRemaining;
        });
        return new CompletableFutureWrapper<>(f);
    }

image-20240403105722608

image-20240403105635897

handleNoSync它只是针对异常做了处理，正常情况下只是进行了封装，而unlocakInnerAysnc也是在异常时的一个回调；

return是结果封装；

image-20240403105756315

再回到刷新的部分：

它是在加锁完后的一个回调方法，ttlRemaining它就是上面执行的结果，null或者是过期时间，

image-20240403110155068

 private RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
        RFuture<Long> ttlRemainingFuture;
     // leaseTime=-1表示永不过期
        if (leaseTime > 0) {
            // 对应方法：tryLock(过期时间, 时间单位)
            ttlRemainingFuture = tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
        } else {
            // 对应方法：lock()
            // 注意它达到参数是：internalLockLeaseTime，上面说了他是30秒
            // internalLockLeaseTime = lockWatchdogTimeout = 30 * 1000;
            ttlRemainingFuture = tryLockInnerAsync(waitTime, internalLockLeaseTime,
                    TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
        }
     
     // 这里是上面ttlRemainingFuture回调结果处理，
     // 如果出现异常，就unlock解锁
        CompletionStage<Long> s = handleNoSync(threadId, ttlRemainingFuture);
        ttlRemainingFuture = new CompletableFutureWrapper<>(s);
// 这里是定时刷新任务
        CompletionStage<Long> f = ttlRemainingFuture.thenApply(ttlRemaining -> {
            // 执行成功返回的时null，所以这里以null为加锁成功的标志
            if (ttlRemaining == null) {
                if (leaseTime > 0) {
                    // leaseTime > 0 表示加锁时设置了过期时间
                    // 而ternalLockLeaseTime存在默认值，这里就是取消了默认值
                    internalLockLeaseTime = unit.toMillis(leaseTime);
                } else {
                    // 那，这里执行 过期时间的定时刷新
                    scheduleExpirationRenewal(threadId);
                }
            }
            return ttlRemaining;
        });
        return new CompletableFutureWrapper<>(f);
    }

image-20240403144946555

过期时间刷新的步骤：

  1. 创建ExpirationEntry，可以看作时一个上下文对象，他是延时的标识
  2. 原子操作，添加上下文ExpirationEntry
  3. 设置当前线程id到上下文
  4. 创建Timeout延时任务，延时10秒
  5. 延时任务执行（异步）：
    1. 根据客户端id和锁获取上下文
    2. 通过上下文获取到线程id
    3. 异步执行延时lua脚本
    4. 执行回调：成功，回调本身，回调第四步，失败，移除上下文，取消延时
 protected void scheduleExpirationRenewal(long threadId) {
     // 1. 创建ExpirationEntry，可以看作时一个上下文对象，他是延时的标识
        ExpirationEntry entry = new ExpirationEntry();
     // 2. 原子操作，添加上下文ExpirationEntry
     // 要进行过期时间刷新，就要先添加这个对象，可以理解为一个刷新的标志
        ExpirationEntry oldEntry = EXPIRATION_RENEWAL_MAP.putIfAbsent(getEntryName(), entry);
     // 3. 设置当前线程id到上下文
        if (oldEntry != null) {
            // 不为空，说明这个对象已经存在，已经有其他线程执行了过期刷新
            oldEntry.addThreadId(threadId);
        } else {
            // 为空，则是不存在该映射对象（锁不存在）
            entry.addThreadId(threadId);
            try {
                // 执行过期时间刷新
                // 4. 创建Timeout延时任务，延时10秒
                // 5. 延时任务执行（异步）：
                //    5.1 根据客户端id和锁获取上下文
                //    5.2 通过上下文获取到线程id
                //    5.3 异步执行延时lua脚本
                //    5.4 执行回调：成功，回调本身，回调第四步，失败，移除上下文，取消延时
                renewExpiration();
            } finally {
                if (Thread.currentThread().isInterrupted()) {
                    cancelExpirationRenewal(threadId);
                }
            }
        }
    }

下面我们进入renewExpiration方法：

 private void renewExpiration() {
     // EXPIRATION_RENEWAL_MAP 在上一层方法中添加了刷新的上下文标志
        ExpirationEntry ee = EXPIRATION_RENEWAL_MAP.get(getEntryName());
        if (ee == null) {
            // 如果这里为null，就说明已经有其他线程移除了，那么就是不需要刷新，锁不存在了
            return;
        }
        // 4. 创建Timeout延时任务，延时10秒
     
     	// 注意这里的时间： internalLockLeaseTime / 3
     	// 之前说过：internalLockLeaseTime = lockWatchdogTimeout = 30 * 1000;
     	// 所以这里是延迟10秒
        Timeout task = getServiceManager().newTimeout(new TimerTask() {
			// 5. 延时任务执行（异步）
            @Override
            public void run(Timeout timeout) throws Exception {
                // 5.1 根据客户端id和锁获取上下文
                // entryName是客户端id+线程id
                // 每次执行都要检查，刷新的标志存在，就说明锁还在，需要执行
                ExpirationEntry ent = EXPIRATION_RENEWAL_MAP.get(getEntryName());
                if (ent == null) {
                    return;
                }
                // 5.2 通过上下文获取到线程id
                Long threadId = ent.getFirstThreadId();
                if (threadId == null) {
                    return;
                }
                // 5.3 异步执行延时lua脚本
                CompletionStage<Boolean> future = renewExpirationAsync(threadId);
                // 当延时完成后，执行这个方法，也是个回调
                future.whenComplete((res, e) -> {
                    if (e != null) {
                        log.error("Can't update lock {} expiration", getRawName(), e);
                        // 异常时，移除刷新的标志
                        // 也是避免死锁的一个方式
                        EXPIRATION_RENEWAL_MAP.remove(getEntryName());
                        return;
                    }
                    // 5.4 成功：回调本身，回调第四步，失败：移除上下文，取消延时
                    if (res) {
                        // 延时成功，回调当前这个方法，以实现定时任务
                        renewExpiration();
                    } else {
                        // 没有成功，也是移除刷新的标志
                        // 这里没有成功的情况，是锁已经不存在了，对应的定时任务就应该停止；
                        // 两个步骤：
                        // 1. task.cancel()：通过上下文获取到任务，然后取消
                        // 2. EXPIRATION_RENEWAL_MAP.remove(getEntryName());
                        cancelExpirationRenewal(null);
                    }
                });
            }
        }, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);
        // 将定时任务放到entry中，也就是放到了定时任务的上下文中
     // 在下一次时，通过上下文获取到这个定时任务
        ee.setTimeout(task);
    }

其实他延时的逻辑也是一个lua脚本：

image-20240403154502286

漏了一点：

由Redisson实现JDK的Timeout类，加回调完成的一个定时任务；当当前任务执行完后，又执行本身方法，创建一个延迟任务，也就实现了一个定时任务

用针戳左手中指指头
关注
  • 34
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Redisson分布式锁源码解析
08-27
Redisson分布式锁源码解析 Redisson分布式锁是一种基于Redis的分布式锁实现，继承了Reentrant Lock的特性，具有超时、重试、中断等功能，并且由于Redis的分布式特性，非常适合用来做Java中的分布式锁。本文将对...
redisson实现分布式锁原理
08-31
Redisson 是一个流行的 Java 客户端，用于与 Redis 数据库进行交互，它提供了丰富的数据结构和服务，包括分布式锁的实现。在本文中，我们将深入探讨 Redisson 如何实现分布式锁，以及其特点和机制。 分布式锁是多...
Redisson分布式锁原理浅析
qq_34826261的博客
08-05 4154
Redisson锁是我们常用的分布式锁，其核心方法就是获取锁对象（getLock）、加锁（lock、tryLock）和释放锁（unlock），下面从锁的初始化、加锁和释放锁三部分分析Redisson锁的原理。
Redisson分布式锁全解析：从基础到红锁，锁定高并发解决方案
逆流的小鱼
05-09 1624
可重入锁是指同一个线程可以多次获得同一把锁。这种类型的锁可以避免死锁的发生，因为它允许同一线程在没有释放锁的情况下多次获得锁。这在递归函数或者一系列相互调用的函数需要访问同一个资源时特别有用。可过期性信号量是一种特殊类型的信号量，它允许线程在一定时间内持有许可，当指定时间过后，许可会自动失效。这对于需要限时访问的资源来说是非常实用的。
Redisson分布式锁详解
抽象的螺旋
08-14 2818
Redission知识总结
超详细的Redisson实现分布式锁原理解析_1
guntun8987的博客
05-28 3376
超详细的Redisson原理解析
Spring Boot 集成 Redisson分布式锁（注解版）
热门推荐
Ascend1977的博客
06-09 1万+
在 Spring Boot 应用程序中使用 Redisson 可以方便地实现分布式应用程序的某些方面，例如分布式锁、分布式集合、分布式事件发布和订阅等。本篇是一个使用 Redisson 实现分布式锁的详细示例，在这个示例中，我们定义了DistributedLock注解，它可以标注在方法上，配合DistributedLockAspect切面以及IDistributedLock分布式锁封装的接口，来实现redisson 分布式锁的 API 调用。
Redisson 分布式锁详解
Java是世界上最好的语言
11-24 1525
简单使用 下面通过 Redisson 框架封装的分布式锁机制，来演示一下分布式锁的实现。 引入依赖 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.16.0</version> </dependency> 测试 public class RedisL
Redis系列（二）Redisson分布式锁源码解析
CountryLord的博客
10-16 3112
Redisson分布式锁源码解析
Redisson分布式锁
weixin_42383680的博客
05-25 682
为什么使用分布式锁 为了保证一个方法在高并发情况下的同一时间只能被同一个线程执行，在传统单体应用单机部署的情况下，可以使用Java并发处理相关的API(如ReentrantLcok或synchronized)进行互斥控制。但是，随着业务发展的需要，原单体单机部署的系统被演化成分布式系统后，由于分布式系统多线程、多进程并且分布在不同机器上，这将使原单机部署情况下的并发控制锁策略失效，为了解决这个问题就需要一种跨JVM的互斥机制来控制共享资源的访问，这就是分布式锁要解决的问题。 使用Redis分布式锁 .
Redisson分布式锁使用以及源码解析
weixin_46066386的博客
10-31 82
Redisson分布式锁
Java使用Redisson分布式锁实现原理
08-26
Java 使用 Redisson 分布式锁实现原理 Java 使用 Redisson 分布式锁实现原理是基于 Redis 的分布式锁实现，通过使用 Redisson 客户端来实现分布式锁的加锁和解锁操作。本文将详细介绍 Java 使用 Redisson 分布式锁...
Java redisson实现分布式锁原理详解
08-24
Java Redisson 实现分布式锁原理详解 分布式锁的重要性 在分布式系统中，锁机制是非常重要的，它可以防止多个节点同时访问共享资源，避免数据不一致和错误。 Java Redisson 是一个流行的分布式锁实现，它提供了一...
RedissonDemo:Redisson分布式锁简单使用教程
05-13
RedissonClient redisson = Redisson.create(config); // 3. 获得锁对象 RLock lock = redisson.getLock("myLock"); // 4. 上锁 lock.lock(); // 做你想做的。。。。 // 5.解锁 lock.unlock(); 依赖 <groupId>org....
缓存技术实战[一文讲透!](Redis、Ecache等常用缓存原理介绍及实战)
愿你有前程可奔赴，亦有青春可回顾
06-15 474
缓存（Cache）是一种存储技术，用于临时存放从原始数据源（如硬盘、数据库或网络）获取的数据副本，目的是加快数据的访问速度，减少不必要的重复处理，进而提升系统整体的性能和响应效率。它是计算机科学中“空间换时间”策略的一个典型应用，即通过牺牲少量的存储空间来换取数据访问速度的显著提升。简而言之，缓存就是存储数据副本或计算结果的组件，以便后续可以更快地访问。Redis是我们平常开发中最常用到的缓存中间件了！
笔记-Python—redis
java2508的博客
06-18 358
这使得Redis可执行单层树复制。默认，每个Redis实例都会维护一个自己的连接池。redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。redis-py提供两个类Redis和StrictRedis用于实现Redis的命令，StrictRedis用于实现大部分官方的命令，并使用官方的语法和命令，Redis是StrictRedis的子类。
【Go】十四、图形验证码、短信验证码、注册接口与redis的简单使用
最新发布
weixin_41365204的博客
06-18 403
如何嵌入图形验证码工作：这里选择使用captcha 开源库进行验证码设计：选用下面的地址进行验证码开发工作。
【Redis】内存回收和内存淘汰机制
LCN29的博客
06-18 1135
存储在 Redis 中的基本都是键值对, 而这种键值对存储, 同时可以通过 key 快速查询到对应的 value, 最合适的实现就是 HashTable 了。而实现 HashTable 的底层结构，基本就是一个数组或者链表, 同时为了解决 hash 冲突, 数组或链表的每个节点定义为一个链表。Redis 中对 HashTable 的实现也是如此, 大体如下Redis 中实现的 HastTable 叫做 dictht (Dictionary Hash Table)// 存放节点的数组。
Redisson分布式锁原理
03-31
Redisson分布式锁是基于Redis实现的一种分布式锁，其原理如下： 1. 获取锁时，使用Redis的setnx命令设置一个指定名称的键值对，如果该键不存在，则设置成功，返回1；如果该键已存在，则设置失败，返回0。 2. 获取锁后，设置一个过期时间，防止锁一直被持有导致死锁。 3. 释放锁时，使用Redis的del命令删除该键值对，释放锁资源。 4. 为了避免误删其他线程的锁，Redisson使用了Lua脚本来确保删除锁的原子性。 5. Redisson还提供了可重入锁、公平锁、红锁等多种锁实现方式，可以根据实际需求进行选择。 总的来说，Redisson分布式锁的实现原理就是利用Redis的原子性操作来实现分布式锁，通过设置过期时间和使用Lua脚本保证锁的正确释放和防止误删其他线程的锁。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值