redssion源码

最新推荐文章于 2024-08-16 23:08:28 发布
最新推荐文章于 2024-08-16 23:08:28 发布
阅读量220 收藏 1
点赞数 3
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74232531/article/details/137665098
版权 
lock.tryLock(1L, TimeUnit.SECONDS);  等待时间 /时间单位
waitTime： 锁的最大等待时长 第一次获取失败不会立刻返回 而是在等待时间内不断尝试

                        时间结束还没有返回成功 才会返回false

leasTime ： 锁自动失效释放时间

TimeUnit ： 锁的等待时间单位

一  锁的重试

public boolean tryLock(long waitTime, TimeUnit unit) throws InterruptedException {
    return this.tryLock(waitTime, -1L, unit); // 等待时间 锁失效等待时间 时间单位
}
    public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
        long time = unit.toMillis(waitTime); // 将等待时间转换毫秒
        long current = System.currentTimeMillis();  // 获取当前时间
        long threadId = Thread.currentThread().getId(); //获取线程ID  -- 锁里面的线程标识
        Long ttl = this.tryAcquire(waitTime, leaseTime, unit, threadId); // 获取锁
        if (ttl == null) {
            return true;
        } else {
            time -= System.currentTimeMillis() - current;
            if (time <= 0L) {
                this.acquireFailed(waitTime, unit, threadId);
                return false;
            } else {
                current = System.currentTimeMillis();
                RFuture<RedissonLockEntry> subscribeFuture = this.subscribe(threadId);
                if (!subscribeFuture.await(time, TimeUnit.MILLISECONDS)) {
                    if (!subscribeFuture.cancel(false)) {
                        subscribeFuture.onComplete((res, e) -> {
                            if (e == null) {
                                this.unsubscribe(subscribeFuture, threadId);
                            }

                        });
                    }

                    this.acquireFailed(waitTime, unit, threadId);
                    return false;
                } else {
                    try {
                        time -= System.currentTimeMillis() - current;
                        if (time <= 0L) {
                            this.acquireFailed(waitTime, unit, threadId);
                            boolean var20 = false;
                            return var20;
                        } else {
                            boolean var16;
                            do {
                                long currentTime = System.currentTimeMillis();
                                ttl = this.tryAcquire(waitTime, leaseTime, unit, threadId);
                                if (ttl == null) {
                                    var16 = true;
                                    return var16;
                                }

                                time -= System.currentTimeMillis() - currentTime;
                                if (time <= 0L) {
                                    this.acquireFailed(waitTime, unit, threadId);
                                    var16 = false;
                                    return var16;
                                }

                                currentTime = System.currentTimeMillis();
                                if (ttl >= 0L && ttl < time) {
                                    ((RedissonLockEntry)subscribeFuture.getNow()).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                                } else {
                                    ((RedissonLockEntry)subscribeFuture.getNow()).getLatch().tryAcquire(time, TimeUnit.MILLISECONDS);
                                }

                                time -= System.currentTimeMillis() - currentTime;
                            } while(time > 0L);

                            this.acquireFailed(waitTime, unit, threadId);
                            var16 = false;
                            return var16;
                        }
                    } finally {
                        this.unsubscribe(subscribeFuture, threadId);
                    }
                }
            }
        }
    }


    private Long tryAcquire(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
        return (Long)this.get(this.tryAcquireAsync(waitTime, leaseTime, unit, threadId));
    }

    private <T> RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
        if (leaseTime != -1L) {
            return this.tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
        } else {
            RFuture<Long> ttlRemainingFuture = this.tryLockInnerAsync(waitTime, this.commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), // 看门狗         this.lockWatchdogTimeout = 30000L;
TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
            ttlRemainingFuture.onComplete((ttlRemaining, e) -> {
                if (e == null) {
                    if (ttlRemaining == null) {
                        this.scheduleExpirationRenewal(threadId);
                    }

                }
            });
            return ttlRemainingFuture;
        

 <T> RFuture<T> tryLockInnerAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
        this.internalLockLeaseTime = unit.toMillis(leaseTime);
        return this.evalWriteAsync(this.getName(), LongCodec.INSTANCE, command, "if (redis.call('exists', KEYS[1]) == 0) then redis.call('hincrby', 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.singletonList(this.getName()), this.internalLockLeaseTime, this.getLockName(threadId));
    }

lua 脚本 大致 ： 锁是否存在 不存在  记录锁标识  次数 + 1

                                                           设置锁的有效期

                                                           返回 nil

                                                存在   判断锁是否是自己的

                                                                是     次数+1  设置有效期

                                                                返回 nil

                                               失败 执行pttl 获取key的剩余有效期 返回毫秒单位

                

   

    public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
        long time = unit.toMillis(waitTime);
        long current = System.currentTimeMillis();
        long threadId = Thread.currentThread().getId();
        Long ttl = this.tryAcquire(waitTime, leaseTime, unit, threadId);
        if (ttl == null) {
            return true;  // 获取锁成功
        } else {
            time -= System.currentTimeMillis() - current;  // 剩余时间：设置最大等待时间 - （现在时间 - 代码运行前时间） = 剩余时间：最大等待时间 - 代码运行时间
            if (time <= 0L) {                               
                this.acquireFailed(waitTime, unit, threadId);
                return false;  // 剩余时间0 直接返回false
            } else {
                current = System.currentTimeMillis();  //当前时间
                RFuture<RedissonLockEntry> subscribeFuture = this.subscribe(threadId);
//   subscribe 订阅别人释放锁的信号  
                if (!subscribeFuture.await(time, TimeUnit.MILLISECONDS)) { //订阅等待锁的最大释放时间
                    if (!subscribeFuture.cancel(false)) {
                        subscribeFuture.onComplete((res, e) -> {
                            if (e == null) {
// 取消订阅
                                this.unsubscribe(subscribeFuture, threadId);
                            }

                        });
                    }

                    this.acquireFailed(waitTime, unit, threadId);
                    return false;
                } else {
                    // 订阅成功消息
                    try {
                        time -= System.currentTimeMillis() - current;
                        if (time <= 0L) {
                            // 重试等待时间
                            this.acquireFailed(waitTime, unit, threadId);
                            boolean var20 = false;
                            return var20;
                        } else {
                            boolean var16;
                            do {
                                long currentTime = System.currentTimeMillis();
                                ttl = this.tryAcquire(waitTime, leaseTime, unit, threadId);
                                if (ttl == null) {
                                    var16 = true;
                                    return var16;
                                }

                                time -= System.currentTimeMillis() - currentTime;
                                if (time <= 0L) {
                                    /
                                    this.acquireFailed(waitTime, unit, threadId);
                                    var16 = false;
                                    return var16;
                                }

                                currentTime = System.currentTimeMillis();
                                // 锁的剩余有效期< 剩余等待时间
                                if (ttl >= 0L && ttl < time) {
                                    // 尝试订阅消息 采用getLatch方式 尝试获取等待时间
((RedissonLockEntry)subscribeFuture.getNow()).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                                } else {
                                    ((RedissonLockEntry)subscribeFuture.getNow()).getLatch().tryAcquire(time, TimeUnit.MILLISECONDS);
                                }

                                time -= System.currentTimeMillis() - currentTime;
                            } while(time > 0L);
                            
//                            重试锁
                            this.acquireFailed(waitTime, unit, threadId);
                            var16 = false;
                            return var16;
                        }
                    } finally {
                        this.unsubscribe(subscribeFuture, threadId);
                    }
                }
            }
        }
    }

           

二   锁的超时

    private <T> RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
        if (leaseTime != -1L) {
            return this.tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
        } else {
            RFuture<Long> ttlRemainingFuture = this.tryLockInnerAsync(waitTime, this.commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
            ttlRemainingFuture.onComplete((ttlRemaining, e) -> {
// 获取锁成功 
                if (e == null) {
                       // 有效期 空 自动续期
                    if (ttlRemaining == null) {
                        this.scheduleExpirationRenewal(threadId);
                    }

                }
            });
            return ttlRemainingFuture;
        }
    }

    private void scheduleExpirationRenewal(long threadId) {
        ExpirationEntry entry = new ExpirationEntry();
        ExpirationEntry oldEntry = 
(ExpirationEntry)EXPIRATION_RENEWAL_MAP.putIfAbsent(this.getEntryName(), entry); // 放进MAP里面 （）
        if (oldEntry != null) {
        // 加入到新线程 第二次进来
            oldEntry.addThreadId(threadId);
        } else {
            // 第一次进来
            entry.addThreadId(threadId);
            this.renewExpiration();
        }

    }

 了解getEntry是什么

    public RedissonLock(CommandAsyncExecutor commandExecutor, String name) {
        super(commandExecutor, name);
        this.commandExecutor = commandExecutor;
        this.id = commandExecutor.getConnectionManager().getId();
        this.internalLockLeaseTime = commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout();
// 锁的名称 ： 锁的实例
        this.entryName = this.id + ":" + name;
        this.pubSub = commandExecutor.getConnectionManager().getSubscribeService().getLockPubSub();
    }

    protected String getEntryName() {
        return this.entryName;
    }

    private void scheduleExpirationRenewal(long threadId) {
        ExpirationEntry entry = new ExpirationEntry();
        ExpirationEntry oldEntry = (ExpirationEntry)EXPIRATION_RENEWAL_MAP.putIfAbsent(this.getEntryName(), entry);
        if (oldEntry != null) {
            oldEntry.addThreadId(threadId);
        } else {
            entry.addThreadId(threadId);
            this.renewExpiration();
        }

    }

    private void renewExpiration() {
        ExpirationEntry ee = (ExpirationEntry)EXPIRATION_RENEWAL_MAP.get(this.getEntryName());
        if (ee != null) {
            Timeout task = this.commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
                public void run(Timeout timeout) throws Exception {
                    ExpirationEntry ent = (ExpirationEntry)RedissonLock.EXPIRATION_RENEWAL_MAP.get(RedissonLock.this.getEntryName());
                    if (ent != null) {
                        Long threadId = ent.getFirstThreadId();
                        if (threadId != null) {
                            RFuture<Boolean> future = RedissonLock.this.renewExpirationAsync(threadId);
                            future.onComplete((res, e) -> {
                                if (e != null) {
                                    RedissonLock.log.error("Can't update lock " + RedissonLock.this.getName() + " expiration", e);
                                } else {
                                    if (res) {
                                        RedissonLock.this.renewExpiration();
                                    }

                                }
                            });
                        }
                    }
                }
            }, this.internalLockLeaseTime / 3L, TimeUnit.MILLISECONDS);
            ee.setTimeout(task);
        }
    }

    protected RFuture<Boolean> renewExpirationAsync(long threadId) {
        return this.evalWriteAsync(this.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.singletonList(this.getName()), this.internalLockLeaseTime, this.getLockName(threadId));
    }

取消锁

    void cancelExpirationRenewal(Long threadId) {
        ExpirationEntry task = (ExpirationEntry)EXPIRATION_RENEWAL_MAP.get(this.getEntryName());
        if (task != null) {
            if (threadId != null) {
                task.removeThreadId(threadId);
            }

            if (threadId == null || task.hasNoThreads()) {
                Timeout timeout = task.getTimeout();
                if (timeout != null) {
                    timeout.cancel();
                }

                EXPIRATION_RENEWAL_MAP.remove(this.getEntryName());
            }

        }
    }

Surfing鲨鱼
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
loveyue系列源码
05-19
程序员表白程序，开放源码，不断更新（第三篇：第二弹）,这是loveyue系列的源码，详情请参照博客：http://blog.csdn.net/wuxia2001/article/details/45743641
仿京东界面源码
12-01
【仿京东界面源码】是一种用于学习和实践前端开发技术的资源，它包含了构建一个与京东网站或应用程序相似用户界面的源代码。这样的源码通常包括HTML、CSS、JavaScript等前端技术，有时也会涉及到响应式设计、框架...
Redission的tryLock源码分析
jaaccck的博客
03-28 774
其中的 scheduleExpirationRenewal()方式来更新锁超时时间。
开源项目前导 剖析Redisson源码tryLock() 看门狗续期（2）
sjisbbeksudh的博客
07-02 831
如果是重入，那么putIfAbsent函数就不会执行，返回值就是之前旧的ExpirationEntry类，也就是第一次进来创建的ExpirationEntry类。这样，如果是第一次进入的时候，这里放进去的就是一个全新的ExpirationEntry类，也就是当前锁，返回值就是null。如果获取锁返回的锁key的剩余有效期的时间为null的时候（也就是获取锁成功），就会解决最长等待剩余有效期的问题。tryAcquireAsync方法就是上面解读Redission的可重入锁的源码调用到的一个方法。
Redisson分布式锁学习
大魔王
10-22 713
redisson分布式锁 续约 LUA
Redisson源码篇
weixin_44383484的博客
07-31 3884
Redisson源码
Redisson分布式锁源码解析
TianH_legend的博客
04-14 1843
Redisson实现分布式锁源码解析 锁是在执行多线程时用于强行限制资源访问的同步机制，在分布式系统场景下，为了保证多个进程服务对共享资源的读写同步，保证数据的最终一致性，而单机服务的同步锁只能保证在单个服务中多线程的竞争数据安全性，所以需要分布式锁。 分布式锁应该具备的条件： 1、在分布式系统环境下，一个方法在同一时间只能被一个机器的一个线程执行； 2、高可用的获取锁与释放锁； 3、高性能的获取锁与释放锁； 4、具备可重入特性； 5、具备锁失效机制，防止死锁； 6、具备非阻塞锁特性，即没有获取到锁将直接返
redisson分布式锁的执行源码分析记录一下
qq_41665452的博客
03-04 349
很简单的开头 之前在项目中有使用redisson作为分布式锁的实现方式，就想着看看它的源码的执行流程，然后记录一下。 乱排版的中间 废话不多说，先看一下项目中redisson使用方法： <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.12.3</version>
Redisson源码解读-分布式锁
王谷雨的博客
11-07 907
Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。Redisson有一样功能是可重入的分布式锁。本文来讨论一下这个功能的特点以及源码分析。
redssion 延迟队列源码分析
xyw10000
11-14 2220
redssion 是个优秀的开源框架，里面实现了很多常用的redis操作。例 分布式锁及分布式延时队列，api使用操作简单，功能十分强大。 如果想进一步了解可访问https://github.com/redisson/redisson/wiki/%E7%9B%AE%E5%BD%95 本次主要研究分析延迟队列的实现，废话不多说先上个简单的demo。 package com.xuyw.redisson; import lombok.extern.slf4j.Sl...
精尽 Redisson 源码分析 —— 可靠分布式锁 RedLock
weixin_39042870的博客
03-14 435
1、客户端 A 从 Redis Master 获得到锁anylock。2、在 Redis Master 同步anylock到 Redis Slave 之前，Master 挂了。3、Redis Slave 晋升为新的4、客户端 B 从新的Redis Master 获得到锁anylock。此时，客户端 A 和 B 同时持有anylock锁，已经失效。当然，这个情况是极小概率事件。主要看业务对分布式锁可靠性的诉求。
音乐播放器源码
04-22
音乐播放器源码是开发Android应用的一个重要实例，它涵盖了多媒体处理、用户界面设计、数据管理等多个关键领域。在此，我们将深入探讨这个源码中涉及的主要知识点。 首先，"音乐播放器"涉及到的核心功能是音频播放...
四川麻将源码
03-14
很好的资源 可运行 很稀有哦 带有参考文档 架设文档 只供学习 商用后果自负
保卫萝卜源码
08-07
保卫萝卜源码，MVC框架，易于学习，带资源，模型素材 源码描述： C#保卫萝卜示例源码 点击按钮会加载游戏窗体界面，源码只是一个示例，实现了三个关卡，关卡选择，场景跳转，boss的产生，炮塔的克隆等一系列功能 ...
JAVA进阶补充
2301_80150315的博客
08-15 895
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 587
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1054
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
206套成品网站源码打包下载
这些源码可用于快速构建和定制网站，对于开发者和站长来说是宝贵的参考资料库。" 在IT行业中，网站源码是构建网页和网络应用的基础，不同的编程语言适用于不同的开发需求和场景。此资源包括了asp、php、asp.net和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值