redisson中的分布式锁解读(下)

本文涉及的产品
云数据库 Tair(兼容Redis),内存型 2GB
Redis 开源版,标准版 2GB
推荐场景:
搭建游戏排行榜
简介: redisson中的分布式锁解读(下)

添加StockController方法:

1. @GetMapping("test/read")
2. public String testRead(){
3. String msg = stockService.testRead();
4. return "测试读";
5.     }
6. @GetMapping("test/write")
7. public String testWrite(){
8. String msg = stockService.testWrite();
9. return "测试写";
10.     }

添加StockService方法:

1. public String testRead() {
2. RReadWriteLock rwLock = this.redissonClient.getReadWriteLock("rwLock");
3.     rwLock.readLock().lock(10, TimeUnit.SECONDS);
4.     System.out.println("测试读锁。。。。");
5. // rwLock.readLock().unlock();
6. return null;
7. }
8. public String testWrite() {
9. RReadWriteLock rwLock = this.redissonClient.getReadWriteLock("rwLock");
10.     rwLock.writeLock().lock(10, TimeUnit.SECONDS);
11.     System.out.println("测试写锁。。。。");
12. // rwLock.writeLock().unlock();
13. return null;
14. }

打开开两个浏览器窗口测试:

  • 同时访问写:一个写完之后,等待一会儿(约10s),另一个写开始
  • 同时访问读:不用等待
  • 先写后读:读要等待(约10s)写完成
  • 先读后写:写要等待(约10s)读完成

信号量(Semaphore)

基于Redis的Redisson的分布式信号量(Semaphore)Java对象 RSemaphore 采用了与

java.util.concurrent.Semaphore 相似的接口和用法。同时还提供了异步(Async)、反射式

(Reactive)和RxJava2标准的接口。

1. RSemaphore semaphore = redisson.getSemaphore("semaphore");
2. semaphore.acquire();
3. semaphore.release();

在StockController添加方法:

1. @GetMapping("test/semaphore")
2. public String testSemaphore(){
3. this.stockService.testSemaphore();
4. return "测试信号量";
5. }

在StockService添加方法:

1. public void testSemaphore() {
2. RSemaphore semaphore = this.redissonClient.getSemaphore("semaphore");
3.         semaphore.trySetPermits(3);
4. try {
5.             semaphore.acquire();
6.             TimeUnit.SECONDS.sleep(5);
7.             System.out.println(System.currentTimeMillis());
8.             semaphore.release();
9.         } catch (InterruptedException e) {
10.             e.printStackTrace();
11.         }
12.     }

添加测试用例:并发10次,循环一次

控制台效果:

由此可知:

  • 1606960790秒有3次请求进来:每个控制台各1次
  • 1606960795秒有3次请求进来:控制台2有1次,控制台3有2次
  • 1606960800秒有3次请求进来:控制台1有2次,控制台2有1次
  • 1606960805秒有1次请求进来:控制台1有1次

闭锁(CountDownLatch)

基于Redisson的Redisson分布式闭锁(CountDownLatch)Java对象 RCountDownLatch 采用了与

java.util.concurrent.CountDownLatch 相似的接口和用法。

1. RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
2. latch.trySetCount(1);
3. latch.await();
4. // 在其他线程或其他JVM里
5. RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
6. latch.countDown();

需要两个方法:一个等待,一个计数countDown

给StockController添加测试方法

1. @GetMapping("test/latch")
2. public String testLatch(){
3. this.stockService.testLatch();
4. return "班长锁门。。。";
5.     }
6. @GetMapping("test/countdown")
7. public String testCountDown(){
8. this.stockService.testCountDown();
9. return "出来了一位同学";
10.     }

给StockService添加测试方法

1. public void testLatch() {
2. RCountDownLatch latch = this.redissonClient.getCountDownLatch("latch");
3.         latch.trySetCount(6);
4. try {
5.             latch.await();
6.         } catch (InterruptedException e) {
7.             e.printStackTrace();
8.         }
9.     }
10. 
11. public void testCountDown() {
12. RCountDownLatch latch = this.redissonClient.getCountDownLatch("latch");
13.         latch.trySetCount(6);
14.         latch.countDown();
15.     }

重启测试,打开两个页面:当第二个请求执行6次之后,第一个请求才会执行。

总结

redisson:redis的java客户端,分布式锁

   玩法:

       1.引入依赖

       2.java配置类:RedissonConfig

           @Bean

           public RedissonClient redissonClient(){

               Config config = new Config();

               config.useSingleServer().setAddress("redis://ip:port");

               return Redisson.create(config);

           }

       3.代码使用:

           可重入锁RLock对象:CompletableFuture + lua脚本 + hash

               RLock lock = this.redissonClient.getLock("xxx");

               lock.lock()/unlock()

               

           公平锁:

               RLock lock = this.redissonClient.getFairLock("xxx");

               lock.lock()/unlock()

               

           联锁 和 红锁:

           

           读写锁:

               RReadWriteLock rwLock = this.redissonClient.getReadWriteLock("xxx");

               rwLock.readLock().lock()/unlock();

               rwLock.writeLock().lock()/unlock();

               

           信号量:

               RSemaphore semaphore = this.redissonClient.getSemaphore("xxx");

               semaphore.trySetPermits(3);

               semaphore.acquire()/release();

               

           闭锁:

               RCountDownLatch cdl = this.redissonClient.getCountDownLatch("xxx");

               cdl.trySetCount(6);

               cdl.await()/countDowntch();

相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务,基于高可靠双机热备架构及可无缝扩展的集群架构,满足高读写性能场景及容量需弹性变配的业务需求。 产品详情:https://www.aliyun.com/product/kvstore     ------------------------------------------------------------------------- 阿里云数据库体验:数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库 ECS 实例和一台目标数据库 RDS实例。跟着指引,您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接,领取免费ECS&RDS资源,30分钟完成数据库上云实战!https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
目录
打赏
0
0
0
0
65
分享
相关文章
分布式锁—3.Redisson的公平锁
Redisson公平锁(RedissonFairLock)是一种基于Redis实现的分布式锁,确保多个线程按申请顺序获取锁,从而实现公平性。其核心机制是通过队列和有序集合管理线程的排队顺序。加锁时,线程会进入队列并等待,锁释放后,队列中的第一个线程优先获取锁。RedissonFairLock支持可重入加锁,即同一线程多次加锁不会阻塞。新旧版本在排队机制上有所不同,新版本在5分钟后才会重排队列,而旧版本在5秒后就会重排。释放锁时,Redisson会移除队列中等待超时的线程,并通知下一个排队的线程获取锁。通过这种机制,RedissonFairLock确保了锁的公平性和顺序性。
【📕分布式锁通关指南 10】源码剖析redisson之MultiLock的实现
Redisson 的 MultiLock 是一种分布式锁实现,支持对多个独立的 RLock 同时加锁或解锁。它通过“整锁整放”机制确保所有锁要么全部加锁成功,要么完全回滚,避免状态不一致。适用于跨多个 Redis 实例或节点的场景,如分布式任务调度。其核心逻辑基于遍历加锁列表,失败时自动释放已获取的锁,保证原子性。解锁时亦逐一操作,降低死锁风险。MultiLock 不依赖 Lua 脚本,而是封装多锁协调,满足高一致性需求的业务场景。
63 0
【📕分布式锁通关指南 10】源码剖析redisson之MultiLock的实现
分布式锁—5.Redisson的读写锁
Redisson读写锁(RedissonReadWriteLock)是Redisson提供的一种分布式锁机制,支持读锁和写锁的互斥与并发控制。读锁允许多个线程同时获取,适用于读多写少的场景,而写锁则是独占锁,确保写操作的互斥性。Redisson通过Lua脚本实现锁的获取、释放和重入逻辑,并利用WatchDog机制自动续期锁的过期时间,防止锁因超时被误释放。 读锁的获取逻辑通过Lua脚本实现,支持读读不互斥,即多个线程可以同时获取读锁。写锁的获取逻辑则确保写写互斥和读写互斥,即同一时间只能有一个线程获取写锁,
181 17
Redisson分布式锁数据一致性解决方案
通过以上的设计和实现, Redisson能够有效地解决分布式环境下数据一致性问题。但是, 任何技术都不可能万无一失, 在使用过程中还需要根据实际业务需求进行逻辑屏障的设计和错误处理机制的建立。
204 48
分布式锁—4.Redisson的联锁和红锁
Redisson的MultiLock和RedLock机制为分布式锁提供了强大的支持。MultiLock允许一次性锁定多个资源,确保在更新这些资源时不会被其他线程干扰。它通过将多个锁合并为一个大锁,统一进行加锁和释放操作。RedissonMultiLock的实现通过遍历所有锁并尝试加锁,若在超时时间内无法获取所有锁,则释放已获取的锁并重试。 RedLock算法则基于多个Redis节点的加锁机制,确保在大多数节点上加锁成功即可。RedissonRedLock通过重载MultiLock的failedLocksLi
111 10
分布式锁—6.Redisson的同步器组件
Redisson提供了多种分布式同步工具,包括分布式锁、Semaphore和CountDownLatch。分布式锁包括可重入锁、公平锁、联锁、红锁和读写锁,适用于不同的并发控制场景。Semaphore允许多个线程同时获取锁,适用于资源池管理。CountDownLatch则用于线程间的同步,确保一组线程完成操作后再继续执行。Redisson通过Redis实现这些同步机制,提供了高可用性和高性能的分布式同步解决方案。源码剖析部分详细介绍了这些组件的初始化和操作流程,展示了Redisson如何利用Redis命令和
分布式锁—2.Redisson的可重入锁
本文主要介绍了Redisson可重入锁RedissonLock概述、可重入锁源码之创建RedissonClient实例、可重入锁源码之lua脚本加锁逻辑、可重入锁源码之WatchDog维持加锁逻辑、可重入锁源码之可重入加锁逻辑、可重入锁源码之锁的互斥阻塞逻辑、可重入锁源码之释放锁逻辑、可重入锁源码之获取锁超时与锁超时自动释放逻辑、可重入锁源码总结。
|
4月前
|
【📕分布式锁通关指南 07】源码剖析redisson利用看门狗机制异步维持客户端锁
Redisson 的看门狗机制是解决分布式锁续期问题的核心功能。当通过 `lock()` 方法加锁且未指定租约时间时,默认启用 30 秒的看门狗超时时间。其原理是在获取锁后创建一个定时任务,每隔 1/3 超时时间(默认 10 秒)通过 Lua 脚本检查锁状态并延长过期时间。续期操作异步执行,确保业务线程不被阻塞,同时仅当前持有锁的线程可成功续期。锁释放时自动清理看门狗任务,避免资源浪费。学习源码后需注意:避免使用带超时参数的加锁方法、控制业务执行时间、及时释放锁以优化性能。相比手动循环续期,Redisson 的定时任务方式更高效且安全。
214 24
【📕分布式锁通关指南 07】源码剖析redisson利用看门狗机制异步维持客户端锁
|
3月前
|
【📕分布式锁通关指南 09】源码剖析redisson之公平锁的实现
本文深入解析了 Redisson 中公平锁的实现原理。公平锁通过确保线程按请求顺序获取锁,避免“插队”现象。在 Redisson 中,`RedissonFairLock` 类的核心逻辑包含加锁与解锁两部分:加锁时,线程先尝试直接获取锁,失败则将自身信息加入 ZSet 等待队列,只有队首线程才能获取锁;解锁时,验证持有者身份并减少重入计数,最终删除锁或通知等待线程。其“公平性”源于 Lua 脚本的原子性操作:线程按时间戳排队、仅队首可尝试加锁、实时发布锁释放通知。这些设计确保了分布式环境下的线程安全与有序执行。
109 0
【📕分布式锁通关指南 09】源码剖析redisson之公平锁的实现
|
4月前
【📕分布式锁通关指南 08】源码剖析redisson可重入锁之释放及阻塞与非阻塞获取
本文深入剖析了Redisson中可重入锁的释放锁Lua脚本实现及其获取锁的两种方式(阻塞与非阻塞)。释放锁流程包括前置检查、重入计数处理、锁删除及消息发布等步骤。非阻塞获取锁(tryLock)通过有限时间等待返回布尔值,适合需快速反馈的场景;阻塞获取锁(lock)则无限等待直至成功,适用于必须获取锁的场景。两者在等待策略、返回值和中断处理上存在显著差异。本文为理解分布式锁实现提供了详实参考。
178 11
【📕分布式锁通关指南 08】源码剖析redisson可重入锁之释放及阻塞与非阻塞获取

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等