聊聊redisson的分布式锁

最新推荐文章于 2024-08-12 23:43:16 发布
最新推荐文章于 2024-08-12 23:43:16 发布
阅读量164 收藏
点赞数
文章标签： 数据库 lua java
原文链接：https://segmentfault.com/a/1190000016486352
版权

序

本文主要研究一下redisson的分布式锁

maven

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

实例

    @Test
    public void testDistributedLock(){
        Config config = new Config();
//        config.setTransportMode(TransportMode.EPOLL);
        config.useSingleServer()
                .setAddress("redis://192.168.99.100:6379");
        RedissonClient redisson = Redisson.create(config);


        IntStream.rangeClosed(1,5)
                .parallel()
                .forEach(i -> {
                    executeLock(redisson);
                });

        executeLock(redisson);
    }

    public void executeLock(RedissonClient redisson){
        RLock lock = redisson.getLock("myLock");
        boolean locked = false;
        try{
            LOGGER.info("try lock");
            locked = lock.tryLock();
//            locked = lock.tryLock(1,2,TimeUnit.MINUTES);
            LOGGER.info("get lock result:{}",locked);
            if(locked){
                TimeUnit.HOURS.sleep(1);
                LOGGER.info("get lock and finish");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            LOGGER.info("enter unlock");
            if(locked){
                lock.unlock();
            }
        }
    }

源码解析

RedissonLock.tryLock

redisson-3.8.1-sources.jar!/org/redisson/RedissonLock.java

    @Override
    public boolean tryLock() {
        return get(tryLockAsync());
    }

    @Override
    public RFuture<Boolean> tryLockAsync() {
        return tryLockAsync(Thread.currentThread().getId());
    }

    @Override
    public RFuture<Boolean> tryLockAsync(long threadId) {
        return tryAcquireOnceAsync(-1, null, threadId);
    }

    private RFuture<Boolean> tryAcquireOnceAsync(long leaseTime, TimeUnit unit, final long threadId) {
        if (leaseTime != -1) {
            return tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_NULL_BOOLEAN);
        }
        RFuture<Boolean> ttlRemainingFuture = tryLockInnerAsync(commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_NULL_BOOLEAN);
        ttlRemainingFuture.addListener(new FutureListener<Boolean>() {
            @Override
            public void operationComplete(Future<Boolean> future) throws Exception {
                if (!future.isSuccess()) {
                    return;
                }

                Boolean ttlRemaining = future.getNow();
                // lock acquired
                if (ttlRemaining) {
                    scheduleExpirationRenewal(threadId);
                }
            }
        });
        return ttlRemainingFuture;
    }

    <T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
        internalLockLeaseTime = unit.toMillis(leaseTime);

        return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
                  "if (redis.call('exists', KEYS[1]) == 0) then " +
                      "redis.call('hset', KEYS[1], ARGV[2], 1); " +
                      "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                      "return nil; " +
                  "end; " +
                  "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                      "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                      "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                      "return nil; " +
                  "end; " +
                  "return redis.call('pttl', KEYS[1]);",
                    Collections.<Object>singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
    }

    protected String getLockName(long threadId) {
        return id + ":" + threadId;
    }

    private void scheduleExpirationRenewal(final long threadId) {
        if (expirationRenewalMap.containsKey(getEntryName())) {
            return;
        }

        Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
            @Override
            public void run(Timeout timeout) throws Exception {
                
                RFuture<Boolean> future = renewExpirationAsync(threadId);
                
                future.addListener(new FutureListener<Boolean>() {
                    @Override
                    public void operationComplete(Future<Boolean> future) throws Exception {
                        expirationRenewalMap.remove(getEntryName());
                        if (!future.isSuccess()) {
                            log.error("Can't update lock " + getName() + " expiration", future.cause());
                            return;
                        }
                        
                        if (future.getNow()) {
                            // reschedule itself
                            scheduleExpirationRenewal(threadId);
                        }
                    }
                });
            }

        }, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);

        if (expirationRenewalMap.putIfAbsent(getEntryName(), new ExpirationEntry(threadId, task)) != null) {
            task.cancel();
        }
    }

    protected RFuture<Boolean> renewExpirationAsync(long threadId) {
        return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                    "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                    "return 1; " +
                "end; " +
                "return 0;",
            Collections.<Object>singletonList(getName()), 
            internalLockLeaseTime, getLockName(threadId));
    }

    private <T> RFuture<Long> tryAcquireAsync(long leaseTime, TimeUnit unit, final long threadId) {
        if (leaseTime != -1) {
            return tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
        }
        RFuture<Long> ttlRemainingFuture = tryLockInnerAsync(commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
        ttlRemainingFuture.addListener(new FutureListener<Long>() {
            @Override
            public void operationComplete(Future<Long> future) throws Exception {
                if (!future.isSuccess()) {
                    return;
                }

                Long ttlRemaining = future.getNow();
                // lock acquired
                if (ttlRemaining == null) {
                    scheduleExpirationRenewal(threadId);
                }
            }
        });
        return ttlRemainingFuture;
    }
  • 这里leaseTime没有设置的话，默认是-1，使用的是commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout()，默认为30秒
  • tryLockInnerAsync使用的是一段lua脚本，该脚本有3个参数，第一个参数为KEYS数组，后面几个参数为ARGV数组的元素
  • 这里key的值为调用方指定的这个redissonLock的名称，两个变量，第一个为leaseTime，第二个为锁的名称，使用redissonLock的id+线程id
  • lua脚本第一个方法判断redissonLock的hashmap是否存在，如果不存在则创建，该hashmap有一个entry的key为锁名称，valude为1，之后设置该hashmap失效时间为leaseTime
  • lua脚本第二个方法是在redissonLock的hashmap存在的情况下，将该锁名的value增1，同时设置失效时间为leaseTime
  • 最后返回该redissonLock名称的key的ttl
  • 执行成功之后判断ttl是否还有值，有的话则调用scheduleExpirationRenewal，防止lock未执行完就失效
  • scheduleExpirationRenewal是注册一个延时任务，在internalLockLeaseTime / 3的时候触发，执行的方法是renewExpirationAsync，将该锁失效时间重置回internalLockLeaseTime
  • scheduleExpirationRenewal里头给scheduleExpirationRenewal任务增加listener，如果设置成功之后还会再次递归调用scheduleExpirationRenewal重新注册延时任务
  • tryAcquireAsync(long leaseTime, TimeUnit unit, final long threadId)方法是指定自动解锁时间时调用的方法，它与tryAcquireOnceAsync的区别在于，它对ttl的方回值采用long值来判断，如果是null，才执行延长失效时间的定时任务，而tryAcquireOnceAsync方法采用的是BooleanNullReplayConvertor，只要返回不是null，则返回true

RedissonLock.unlock

redisson-3.8.1-sources.jar!/org/redisson/RedissonLock.java

    @Override
    public void unlock() {
        try {
            get(unlockAsync(Thread.currentThread().getId()));
        } catch (RedisException e) {
            if (e.getCause() instanceof IllegalMonitorStateException) {
                throw (IllegalMonitorStateException)e.getCause();
            } else {
                throw e;
            }
        }
        
//        Future<Void> future = unlockAsync();
//        future.awaitUninterruptibly();
//        if (future.isSuccess()) {
//            return;
//        }
//        if (future.cause() instanceof IllegalMonitorStateException) {
//            throw (IllegalMonitorStateException)future.cause();
//        }
//        throw commandExecutor.convertException(future);
    }

    @Override
    public RFuture<Void> unlockAsync(final long threadId) {
        final RPromise<Void> result = new RedissonPromise<Void>();
        RFuture<Boolean> future = unlockInnerAsync(threadId);

        future.addListener(new FutureListener<Boolean>() {
            @Override
            public void operationComplete(Future<Boolean> future) throws Exception {
                if (!future.isSuccess()) {
                    cancelExpirationRenewal(threadId);
                    result.tryFailure(future.cause());
                    return;
                }

                Boolean opStatus = future.getNow();
                if (opStatus == null) {
                    IllegalMonitorStateException cause = new IllegalMonitorStateException("attempt to unlock lock, not locked by current thread by node id: "
                            + id + " thread-id: " + threadId);
                    result.tryFailure(cause);
                    return;
                }
                if (opStatus) {
                    cancelExpirationRenewal(null);
                }
                result.trySuccess(null);
            }
        });

        return result;
    }

    protected RFuture<Boolean> unlockInnerAsync(long threadId) {
        return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                "if (redis.call('exists', KEYS[1]) == 0) then " +
                    "redis.call('publish', KEYS[2], ARGV[1]); " +
                    "return 1; " +
                "end;" +
                "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then " +
                    "return nil;" +
                "end; " +
                "local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " +
                "if (counter > 0) then " +
                    "redis.call('pexpire', KEYS[1], ARGV[2]); " +
                    "return 0; " +
                "else " +
                    "redis.call('del', KEYS[1]); " +
                    "redis.call('publish', KEYS[2], ARGV[1]); " +
                    "return 1; "+
                "end; " +
                "return nil;",
                Arrays.<Object>asList(getName(), getChannelName()), LockPubSub.unlockMessage, internalLockLeaseTime, getLockName(threadId));

    }

    String getChannelName() {
        return prefixName("redisson_lock__channel", getName());
    }

    void cancelExpirationRenewal(Long threadId) {
        ExpirationEntry task = expirationRenewalMap.get(getEntryName());
        if (task != null && (threadId == null || task.getThreadId() == threadId)) {
            expirationRenewalMap.remove(getEntryName());
            task.getTimeout().cancel();
        }
    }
  • unlockInnerAsync通过lua脚本来释放锁，该lua使用两个key，一个是redissonLock名称，一个是channelName
  • 该lua使用的变量有三个，一个是pubSub的unlockMessage，默认为0，一个是internalLockLeaseTime，默认为commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout()，一个是锁名称
  • 如果该redissonLock不存在，则直接发布unlock消息返回1；如果该锁不存在则返回nil；
  • 如果该锁存在则将其计数-1，如果counter大于0，则重置下失效时间，返回0；如果counter不大于0，则删除该redissonLock锁，发布unlockMessage，返回1；如果上面条件都没有命中返回nil
  • unlockAsync里头对unlockInnerAsync注册了FutureListener，主要是调用cancelExpirationRenewal，取消掉scheduleExpirationRenewal任务

LockPubSub

redisson-3.8.1-sources.jar!/org/redisson/pubsub/LockPubSub.java

public class LockPubSub extends PublishSubscribe<RedissonLockEntry> {

    public static final Long unlockMessage = 0L;

    @Override
    protected RedissonLockEntry createEntry(RPromise<RedissonLockEntry> newPromise) {
        return new RedissonLockEntry(newPromise);
    }

    @Override
    protected void onMessage(RedissonLockEntry value, Long message) {
        if (message.equals(unlockMessage)) {
            Runnable runnableToExecute = value.getListeners().poll();
            if (runnableToExecute != null) {
                runnableToExecute.run();
            }

            value.getLatch().release();
        }
    }

}
  • 接收到unlockMessage的时候，会调用RedissonLockEntry的listener，然后触发latch的release
  • tryAcquireOnceAsync这个方法默认没有创建LockPubSub，而且没有指定自动解锁时间，则定时任务会一直延长失效时间，这个可能存在锁一直没释放的风险

小结

加锁有如下注意事项：

  • 加锁需要设置超时时间，防止出现死锁
  • 加锁以及设置超时时间的时候，需要保证两个操作的原子性，因而最好使用lua脚本或者使用支持NX以及EX的set方法
  • 加锁的时候需要把加锁的调用方信息，比如线程id给记录下来，这个在解锁的时候需要使用
  • 对于加锁时长不确定的任务，为防止任务未执行完导致超时被释放，需要对尚未运行完的任务延长失效时间

解锁有如下注意事项：

  • 解锁一系列操作(判断key是否存在，存在的话删除key等)需要保证原子性，因而最好使用lua脚本
  • 解锁需要判断调用方是否与加锁时记录的是否一致，防止锁被误删
  • 如果有延续失效时间的延时任务，在解锁的时候，需要终止掉该任务

doc

weixin_33757911
关注
一文掌握 Redisson 分布式锁的原理（值得收藏）
m0_67645544的博客
04-01 3638
Redisson 可以直接查看 Github Redisson官网 介绍, 没有了解过的小伙伴, 看一下 Redisson 的 WIKI 目录, 仔细瞅瞅 Redis 是如何被 Redisson 武装到牙齿的 这里先过一下和文章有关的一部分内容 通过项目简介可以看出来, 写这个项目介绍的人水平非常哇塞哈, 从第一段咱们就知道了两个问题 Redisson 是什么 Redisson 是架设在Redis 基础上的一个 Java驻内存数据网格框架, 充分利.
聊聊分布式锁——Redis和Redisson的方式
m0_53462955的博客
09-17 3327
聊聊分布式锁——Redis和Redisson的方式 一、什么是分布式锁 分布式~~锁，要这么念，首先得是『分布式』，然后才是『锁』 分布式：这里的分布式指的是分布式系统，涉及到好多技术和理论，包括CAP 理论、分布式存储、分布式事务、分布式锁… 分布式系统是由一组通过网络进行通信、为了完成共同的任务而协调工作的计算机节点组成的系统。 分布式系统的出现是为了用廉价的、普通的机器完成单个计算机无法完成的计算、存储任务。其目的是利用更多的机器，处理更多的数据。 锁：对对，就是你想的那个，Javer 学的第一个锁应
Redisson分布式锁源码解析
08-27
给大家分享了关于Redisson分布式锁源码相关的知识点内容，有兴趣的朋友们可以参考学习下。
redisson之分布式锁源码解读
vaidiy的博客
04-14 1310
基于源码了解redisson的加锁过程
[Redis] Redisson分布式锁原理及源码分析
最新发布
qq_45061342的博客
08-12 1004
使用 Redis 的 SETNX 命令（Set if Not Exists）来确保只有一个客户端可以成功创建一个锁键。使用 EXPIRE 命令设置键的过期时间，防止死锁。 如果客户端成功设置了锁键，它就获得了锁；如果失败，则表示锁已被其他客户端占用。 为了解决锁失效或客户端故障问题，可以使用 Redisson 或者实现 Redlock 算法来增强锁的可靠性。
看懂Redisson分布式锁源码，其实并不难
02-24 1975
前言 上一篇文章写了Redis分布式锁的原理和缺陷，觉得有些不过瘾，只是简单的介绍了下Redisson这个框架，具体的原理什么的还没说过呢。趁年前项目忙的差不多了，反正闲着也是闲着，不如把Redisson的源码也学习一遍好了。 虽说是一时兴起，但仔细研究之后发现Redisson的源码解读工作量还是挺大的，其中用到了大量的Java并发类，并且引用了Netty作为通信工具，实现与Redis组件的远程调用，这些知识点如果要全部讲解的话不太现实，本文的重点主要是关于Redisson分布式锁的实现原理，所以网络通信和
Redis第14讲——Redis实现分布式锁（Redission源码解析）
让~学习~成为一种习惯（橡 皮 人の技术博客）
04-25 2133
在多线程环境下，为了保证数据的线程安全，我们通常用加锁的方式，使同一时刻只有一个线程可以对这个共享资源进行操作，在单服务系统我们常用JVM锁——Synchronized、ReentrantLock等。然而在多台服务系统的情况下，JVM锁就无法在多个服务器之间生效了，这时候我们就需要用分布式锁来解决线程安全的问题。分布式锁的实现方式有很多，主流的就是基于数据库、zookeeper以及redis，当然使用redis的居多，由于篇幅原因，本节就详细介绍一下使用redis实现分布式锁的几种方式。
基于Redis实现分布式锁-Redisson使用及源码分析
热门推荐
马猴烧酒└(┐卍^o^)卍ﾄﾞｩﾙﾙﾙ~楪詩月「YUZURIHA SHIZUKI」
04-14 3万+
在分布式场景下，有很多种情况都需要实现最终一致性。在设计远程上下文的领域事件的时候，为了保证最终一致性，在通过领域事件进行通讯的方式中，可以共享存储（领域模型和消息的持久化数据源），或者做全局XA事务（两阶段提交，数据源可分开），也可以借助消息中间件（消费者处理需要能幂等）。通过Observer模式来发布领域事件可以提供很好的高并发性能，并且事件存储也能追溯更小粒度的事件数据，使各个应用系统拥有更好
聊聊分布式锁
java_beautiful的博客
07-16 999
为了效率(efficiency)，协调各个客户端避免做重复的工作。即使锁偶尔失效了，只是可能把某些操作多做一遍而已，不会产生其它的不良后果。比如重复发送了一封同样的 email（当然这取决于业务应用的容忍度）。 为了正确性(correctness)。在任何情况下都不允许锁失效的情况发生，因为一旦发生，就可能意味着数据不一致(inconsistency)，数据丢失，文件损坏，订单重复，超卖或者其它严重的问题。...
阿里Java二面：如何用Redis实现分布式锁的？
Cr1556648487的博客
10-14 563
为什么需要分布式锁在聊分布式锁之前，有必要先解释一下，为什么需要分布式锁。与分布式锁相对就的是单机锁，我们在写多线程程序时，避免同时操作一个共享变量产生数据问题，通常会使用一把锁来互斥以保证共享变量的正确性，其使用范围是在同一个进程中。如果换做是多个进程，需要同时操作一个共享资源，如何互斥呢？现在的业务应用通常是微服务架构，这也意味着一个应用会部署多个进程，多个进程如果需要修改MySQL中的同一行记录，为了避免操作乱序导致脏数据，此时就需要引入分布式锁了。
分布式锁Redisson详解（重点）
Java后端技术栈
12-25 5911
一、为什么需要分布式锁？ 在单体web应用的时候，如果多个线程要访问共享资源的时候，我们通常线程间加锁的机制，在某一个时刻，只有一个线程可以对这个资源进行操作，其他线程需要等待锁的释放，Java中也有一些处理锁的机制，比如synchronized。 而到了分布式的环境中，当某个资源可以被多个系统访问使用到的时候，为了保证大家访问这个数据是一致性的，那么就要求再同一个时刻，只能被一个系统使用，这时候线程之间的锁机制就无法起到作用了，因为分布式环境中，系统是会部署到不同的机器上面的，那么就需要【
Redisson分布式锁源码解读
青鸟飞鱼
07-20 627
加锁 & 解锁流程串起来上面结合 Lua 脚本和源码，分别分析了加锁流程和解锁流程。下面升级下挑战难度，模拟下多个线程争抢锁会是怎样的流程。示意图如下，比较关键的三处已用红色字体标注。概括下整个流程1、线程 A 和线程 B 两个线程同时争抢锁。线程 A 很幸运，最先抢到了锁。线程 B 在获取锁失败后，并未放弃希望，而是主动订阅了解锁消息，然后再尝试获取锁，顺便看看没有抢到的这把锁还有多久就过期，线程 B 就按需阻塞等锁释放。
Redission分布式锁-源码解析（手把手解析）
weixin_46028606的博客
07-06 900
Redission分布式锁-源码解析（手把手解析）
Redisson分布式锁 --- 源码分析
白银の王二
04-25 1049
getEntryName() = UUID+lockName ---> abb26a86-01bb-4cc1-945c-d274ae2fd454:订单lock。如果获取锁失败，返回的结果是这个key的剩余有效期，如果获取锁成功，则返回null。redis.pexpire 命令用于设置键(key)的有效期限(以毫秒为单位)redis.pttl 命令以毫秒为单位返回 key 的剩余过期时间。若 key 存在返回 1 ，否则返回 0。命令用于查看哈希表的指定字段是否存在。key 不存在或设置失败，返回 0。
Redisson分布式锁-源码分析
李玉志的博客
06-26 408
尝试获取分布式锁，获取到分布式锁后，开启一个开门狗，为分布式锁续期。为获取到分布式锁，返回分布式锁剩余的过期时间，毫秒为单位。
Redission实现分布式锁之源码解析
me_1984的博客
05-11 779
接上篇Redis分布式锁原理之实现秒杀抢优惠卷业务重入问题：重入问题是指 获得锁的线程可以再次进入到相同的锁的代码块中，可重入锁的意义在于防止死锁，比如HashTable这样的代码中，他的方法都是使用synchronized修饰的，假如他在一个方法内，调用另一个方法，那么此时如果是不可重入的，不就死锁了吗？所以可重入锁他的主要意义是防止死锁，我们的synchronized和Lock锁都是可重入的。不可重试：是指目前的分布式只能尝试一次，我们认为合理的情况是：当线程在获得锁失败后，他应该能再次尝试获得锁。
Redisson分布式锁的源码分析
huchao_lingo的博客
04-02 1694
Redisson分布式锁的源码分析 Redisson 分布式锁实现思路 锁标识：Hash 数据结构，key 为锁的名字，filed 当前竞争锁成功线程的唯一标识，value 重入次数 队列：所有竞争锁失败的线程，会订阅当前锁的解锁事件，利用 Semaphore 实现线程的挂起和唤醒 源码分析 基于redisson3.11.5版本 加锁流程图 解锁核心源码：tryLockInnerAsync ...
Redisson分布式锁源码浅析
qq_39666711的博客
07-23 93
总结：在调用lock（）方法时，我们可以传入自定义的超时时间，也可以不传，如果不传那么将会使用Redisson默认的看门狗时间30s，需要注意的是，如果我们使用了自定义超时时间，那么Redisson不会自动为我们的锁续期，而不传时间Redisson会使用默认30s超时时间并且会自动为我们的锁进行续期。进入tryAcquire（）→ tryAcquireAsync（）方法，该方法首先会判断释放时间是否为-1，如果为-1则代表我们在前面没有传入超时时间，根据这个判断结果将会走两条不同的路。
redisson 分布式锁
10-18
Redisson分布式锁的实现原理是：利用Redis的单线程特性，在Redis中创建一个key，作为锁的标识，当多个线程同时请求获取锁时，只有一个线程能够成功获取到锁，其他线程则需要等待。当获取到锁的线程执行完任务后，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值