分布式锁框架--Redisson

最新推荐文章于 2025-05-31 16:17:26 发布
原创 最新推荐文章于 2025-05-31 16:17:26 发布 · 729 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#redisson

本文详细介绍了Redisson分布式锁框架在实现可重入锁、公平锁和读写锁的应用，包括原理、代码示例和实战场景。同时涵盖了信号量和闭锁的使用，以及与JUC类库的对比。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

分布式锁框架--Redisson

Redisson的github地址
Redisson的github的文档
官网地址

一.Redisson简介

1. redisson概述

redisson概述

2.整合Redisson

1).依赖

依赖

<!--使用redisson作为所有分布式锁，分布式对象等功能性框架-->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.12.0</version>
</dependency>

2).Redisson配置

a.配置方法
在这里插入图片描述
b.第三方框架整合
在这里插入图片描述

c. 单Redis节点模式 --redis不是集群
单Redis节点模式
在这里插入图片描述

2.1）redisson配置文件

在这里插入图片描述

@Configuration
public class MyRedissonConfig {

    //所有对Redisson的使用，都是RedissonClient对象
    @Bean(destroyMethod = "shutdown")
   public RedissonClient redisson() throws IOException {
        //错误： Redis url should start with redis:// or rediss:// (for SSL connection)
        //1.创建配置
        Config config = new Config();
        //设置单节点模式
        config.useSingleServer().setAddress("redis://192.168.56.10:6379");
        //2.根据Config创建出RedissonClient实例
        RedissonClient redissonClient = Redisson.create(config);
        return redissonClient;
    }
}

二、Redisson完成分布式锁功能

分布式对象
分布式集合
分布式锁和同步器

1.分布式锁和同步器

1.1. 可重入锁（Reentrant Lock）*

基于Redis的Redisson分布式 可重入锁RLock
Java对象实现了java.util.concurrent.locks.Lock接口。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。

RLock lock = redisson.getLock(“anyLock”); // 最常见的使用方法 lock.lock();
解锁
另外Redisson还通过加锁的方法提供了leaseTime的参数来指定加锁的时间。超过这个时间后锁便自动解开了。
// 加锁以后10秒钟自动解锁
// 无需调用unlock方法手动解锁
lock.lock(10, TimeUnit.SECONDS);
// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
try {
…
} finally {
lock.unlock();
}
}

1).测试-分布式–lock

分布式测试product，启动10000,10001
http://localhost:10000/hello，
http://localhost:10001/hello
在这里插入图片描述

    @ResponseBody
    @GetMapping("/hello")
    private String hello() {
        //1.获取一把锁，只要锁名一样，就是同一把锁
        RLock lock = redisson.getLock("my-lock");
        //2.加锁（默认过期时间30s）
        lock.lock();//阻塞式等待
        //1).锁的自动续期（如果业务超长，会自动给锁加上30s。防止业务时间长，锁自动过期被删除）
        //2).加锁业务只要运行完成，不会给当前锁续期；若不解锁，锁默认30s后自动解锁
        try {
            System.out.println("加锁成功,执行业务 "+Thread.currentThread().getId());
            Thread.sleep(10000);
        } catch (Exception e) {

        } finally {
            //3.解锁--假如解锁异常，redis会不会死锁？
            System.out.println("释放锁，"+Thread.currentThread().getId());
            lock.unlock();
        }
        return "hello";
    }
a.优点：自动续期、自动解锁
b.手动设置 锁的过期时间

问题：

如果过期时间小于业务执行时间，会出现异常（因为解锁的不是自己的锁）

attempt to unlock lock, not locked by current thread by node id: 1e679a77-58f9-4e9a-a3ad-8007086d665d thread-id: 105

原理：
在这里插入图片描述

c.最佳实践

在这里插入图片描述

设置时间30秒

2）trylock
// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
   try {
     ...
   } finally {
       lock.unlock();
   }
}

1.2 公平锁（Fair Lock）

RLock fairLock = redisson.getFairLock("anyLock");
// 最常见的使用方法
fairLock.lock();

1.3 读写锁（ReadWriteLock）*

读写锁（ReadWriteLock）

1).原理： 读好像无锁，写有锁
2).介绍

基于Redis的Redisson分布式可重入读写锁RReadWriteLock
Java对象实现了java.util.concurrent.locks.ReadWriteLock接口。其中读锁和写锁都继承了RLock接口。

分布式可重入读写锁允许同时有多个读锁和一个写锁处于加锁状态。

RReadWriteLock rwlock = redisson.getReadWriteLock("anyRWLock");
// 最常见的使用方法
rwlock.readLock().lock();
// 或
rwlock.writeLock().lock();

指定加锁的时间。超过这个时间后锁便自动解开了。

// 10秒钟以后自动解锁
// 无需调用unlock方法手动解锁
rwlock.readLock().lock(10, TimeUnit.SECONDS);
// 或
rwlock.writeLock().lock(10, TimeUnit.SECONDS);

// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = rwlock.readLock().tryLock(100, 10, TimeUnit.SECONDS);
// 或
boolean res = rwlock.writeLock().tryLock(100, 10, TimeUnit.SECONDS);
...
lock.unlock();
3).代码–写锁、读锁
a.写锁

在这里插入图片描述

    //读写锁（ReadWriteLock）--允许同时有多个读锁和一个写锁处于加锁状态。
    @ResponseBody
    @GetMapping("/write")
    public String writeValue() {
        //1.写操作，加写锁
        RReadWriteLock lock = redisson.getReadWriteLock("rw-lock");
        RLock rLock = lock.writeLock();//写锁
        String s = null;
        try {
           //写锁
            rLock.lock();
            s = UUID.randomUUID().toString();
            Thread.sleep(10000);
            redisTemplate.opsForValue().set("writeValue",s);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //释放锁
            rLock.unlock();
        }
        return s;
    }
b.读锁

在这里插入图片描述

	@ResponseBody
    @GetMapping("/read")
    public String readValue() {
        //1.读操作，加读锁
        RReadWriteLock lock = redisson.getReadWriteLock("rw-lock");
        RLock rLock = lock.readLock();//读锁
        //加读锁
        rLock.lock();
        String s =null;
        try {
            s= (String) redisTemplate.opsForValue().get("writeValue");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //释放锁
            rLock.unlock();
        }
        return s;
    }
优点：一定能读到最新数据修改期间，写锁是排它锁（互斥锁、独享锁），读锁是共享锁。写锁没释放，读锁必须对待
4).场景模拟

在这里插入图片描述

a.读+读

相当于无锁，并发读，只会在redis记录所有当前读锁，他们会同时加锁成功
直接访问2个读

b.写+读，必须等待写锁完成

读锁必须在写锁完成，才能读
先访问写操作，再访问读操作

c.写+写，阻塞状态

写锁是阻塞状态，写+写还是阻塞状态
先访问一个写，再访问一个写操作

d.读+写。有读锁，写锁需等待

先访问读操作，再访问写操作

总结：只要有写锁，必须等待（读锁是共享锁，写锁是互斥锁）

1.4 信号量（Semaphore）*

信号量（Semaphore）

1).原理: 释放release后，才能获得acquire
2).介绍

基于Redis的Redisson的分布式信号量（Semaphore）Java对象RSemaphore采用了与java.util.concurrent.Semaphore相似的接口和用法。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。

RSemaphore semaphore = redisson.getSemaphore("semaphore");
semaphore.acquire();//阻塞队列
//或
semaphore.acquireAsync();
semaphore.acquire(23);
semaphore.tryAcquire();//非阻塞队列
//或
semaphore.tryAcquireAsync();
semaphore.tryAcquire(23, TimeUnit.SECONDS);
//或
semaphore.tryAcquireAsync(23, TimeUnit.SECONDS);
semaphore.release(10);
semaphore.release();
//或
semaphore.releaseAsync();
3) 场景 车辆入库、出库

车辆出库，车位才可以入库 没有出库，没有车位，入库失败

4) 代码

在这里插入图片描述

     //信号量
    /**
     * 停车入库
     * 3号位
     * 信号量可以作为分布式限流
     */
    @ResponseBody
    @GetMapping("/park")
    //停车（车辆入库）
    public String park() {
        RSemaphore park = redisson.getSemaphore("park");
//        try {
//            park.acquire();//获取一个信号，获取一个值，占一个车位 （阻塞队列）
//            System.out.println("车辆入库成功。。。");
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }

        boolean b = park.tryAcquire();//非阻塞队列
        if (b) {
            //执行业务
            System.out.println("车辆入库成功。。。");
        } else {
            System.out.println("车辆入库失败。。。");
            return "error";
        }
        return "ok=>" + b;
//        return "ok";
    }
    //开走车
    @ResponseBody
    @GetMapping("/go")
    //车辆出库
    public String go() {
        RSemaphore park = redisson.getSemaphore("park");
        //释放一个车位
        park.release();
        System.out.println("释放车位成功。。。");
        return "ok";
    }

1.5 闭锁（CountDownLatch）

1).原理： 计数器为0，才闭锁
2).介绍

基于Redisson的Redisson分布式闭锁（CountDownLatch）Java对象RCountDownLatch采用了与java.util.concurrent.CountDownLatch相似的接口和用法。

RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
latch.trySetCount(1);
latch.await();

// 在其他线程或其他JVM里
RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
latch.countDown();
3). 场景-学校锁门

只有全部班级走，才能锁门

4).代码

在这里插入图片描述

    // 闭锁（CountDownLatch）
    /*
    * 放假，锁门
    *1班没人了
    * 5个班全部走完，才能锁门
    * */
    @ResponseBody
    @GetMapping("/lockDoor")
    //场景：
    public String lockDoor() {
        RCountDownLatch door = redisson.getCountDownLatch("door");
        door.trySetCount(5);
        try {
            door.await();//等待闭锁完成
            System.out.println("放假了。。。");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "放假了。。。";
    }
    @ResponseBody
    @GetMapping("/gogo/{id}")
    public String gogo(@PathVariable("id") Long id){
        RCountDownLatch door = redisson.getCountDownLatch("door");
        door.countDown();//计数减一
        System.out.println(id+" 班的人都走了。。。");
        return id+" 班的人都走了。。。";
    }
5).测试

http://localhost:10000/lockDoor
http://localhost:10000/gogo/1
http://localhost:10000/gogo/2
http://localhost:10000/gogo/3
http://localhost:10000/gogo/4
http://localhost:10000/gogo/5

6).总结： 闭锁，必须在计数为0，才闭锁

1.6 使用JUC也可以实现以上逻辑

在这里插入图片描述

实现分布式锁框架分析
AI天才研究院
09-10 8953
分布式锁实现方式一、数据库锁一般很少使用数据库锁，性能不好并且容易产生死锁。1. 基于MySQL锁表该实现方式完全依靠数据库唯一索引来实现，当想要获得锁时，即向数据库中插...
实现分布式锁,分布式锁框架
m0_54828003的博客
08-25 493
该子节点可以是唯一的，并且依赖于表示每个服务实例的唯一标识符的用户服务，例如Order-Service，通过父节点User-Service将所有User-Service子节点节点获取并获取子节点的数据后，Order-Service将对其进行缓存，并拦截客户端上的此用户- service目录，以便即使新节点加入或退出，Order-Service也是如此这将使Order-Service重新获取所有子节点并更新数据。这样就可以直接获得所需的服务，在这种情况下，可以定义统一的名称，如用户服务。已经有人在读数据了。.
基于Redis实现分布式锁-Redisson使用及源码分析
热门推荐
马猴烧酒└(┐卍^o^)卍ﾄﾞｩﾙﾙﾙ~楪詩月「YUZURIHA SHIZUKI」
04-14 3万+
在分布式场景下，有很多种情况都需要实现最终一致性。在设计远程上下文的领域事件的时候，为了保证最终一致性，在通过领域事件进行通讯的方式中，可以共享存储（领域模型和消息的持久化数据源），或者做全局XA事务（两阶段提交，数据源可分开），也可以借助消息中间件（消费者处理需要能幂等）。通过Observer模式来发布领域事件可以提供很好的高并发性能，并且事件存储也能追溯更小粒度的事件数据，使各个应用系统拥有更好
分布式锁框架
worn_xiao的博客
12-16 646
为什么要用分布式锁 1 怎么保证分布式系统中唯一中主键的生成 2 分布式环境下怎么保证，在高并发的情况下数据的唯一性问题 3 分布式环境下怎么保证数据并发写入的时候 不重复的问题 如上所列举的这些问题，在分布式环境下都是可以分布式锁来解决的，关键在于分布式锁要怎么实现呢 这里就有好几种实现方案了 1.使用数据库实现分布式锁 ...
Redis实战-基于redis和lua脚本实现分布式锁以及Redission源码解析【万字长文】
a6543665的博客
05-31 1900
分布式锁是一种在分布式系统中用于协调多个节点或进程对共享资源进行互斥访问的机制。它的核心目标是确保在分布式环境下，同一时间只有一个节点能够执行关键操作（如修改共享数据、访问数据库等），避免并发导致的数据不一致问题。分布式锁是在分布式系统中协调多个节点对共享资源访问的一种同步机制。同俗一点解释就是，只能管住自己JVM里的线程，而Redis分布式锁相当于一个"全局管理员"，能管住所有JVM的线程，让它们在集群里排队用资源。就好比单机游戏（只能在本机内存档）和网游游戏的区别（所有电脑都可以读取存档）
Redisson—分布式锁框架
许久
01-07 853
一、 Redisson介绍 Redisson在基于NIO的Netty框架上，充分的利用了Redis键值数据库提供的⼀系列优势，为使用者提供了⼀系列具有分布式特性的常用⼯具类。 一款基于Redis+看门狗机制的分布式锁框架 二、 Redisson工作原理 看门狗机制 三、 Redisson使用 添加依赖 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson&lt
缓存-分布式锁框架-Redisson
qq_53374893的博客
07-13 736
Redisson 是 Redis Java 客户端和实时数据平台。它提供了更方便、最简单的 Redis 工作方式。Redisson 对象提供了关注点分离，允许您专注于数据建模和应用程序逻辑。
分布式锁框架-Redisson
Roc的博客
06-01 1461
Redisson是架设在Redis基础上的一个Java驻内存数据网格（In-Memory Data Grid）。Redisson在基于NIO的Netty框架上，充分的利用了Redis键值数据库提供的一系列优势，在Java实用工具包中常用接口的基础上，为使用者提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工具包获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式系统的难度。同时结合各富特色的分布式服务，更进一步简化了分布式环境中程序相互之间的协作。
基于Redis的分布式高并发电商平台-SpringBoot-MyBatisPlus-Redis-MySQL-Nginx-Lua-Redisson-分布式锁-消息队列-缓存优化-短信.zip
最新发布
07-14
Redisson作为一个在Redis基础上实现的Java驻留网络框架，它提供了分布式对象和服务，特别适合用于实现分布式锁等同步机制。 在分布式系统中，锁的管理是一个复杂的问题。为了保证数据的一致性和防止并发问题，...
Java 分布式锁：Redisson、Zookeeper、Spring 提供的 Redis 分布式锁封装详解
空
01-07 1300
Java 分布式锁：Redisson、Zookeeper、Spring 提供的 Redis 分布式锁封装详解
分布式锁框架分析
weixin_33739523的博客
12-06 398
2019独角兽企业重金招聘Python工程师标准>>> ...
框架篇：分布式锁
潜行前行的专栏
06-21 226
前言 java有synchronize和Lock，mysql 修改类的sql也带有锁。锁定数据状态，让数据状态在并发场景，按我们预想逻辑进行状态转移，然而在分布式，集群的情况下，怎么去锁定数据状态呢 数据库的分布式锁方案 基于redis实现分布式锁 基于zookeeper实现分布式锁 关注公众号，一起交流，微信搜一搜: 潜行前行 数据库的分布式锁方案 数据库分布锁的难点 单点故障？ 数据库可以多搞个数据库备份 没有失效时间？ 每次加锁时，插入一个期待的有效时间；A：定时任务，隔一段时间清理时间失效锁。
开源：Taurus.DistributedLock 分布式锁框架，支持 .Net 和 .Net Core 双系列版本
路过秋天 - 理想很美好，现实很残酷，坚持在路上，只因初心仍存
02-23 1326
在经过漫长的技术沉淀，终于又为 .Net 及 .Net Core 的微服务系列框架贡献当中的一个重要组件。Taurus.DistributedLock is a distributed lock for .net or .net core.【支持：Redis、MemCache、Database、Local、File 五类锁】Taurus.DTC 分布式事务框架Taurus.DTS 分布式任务框架中需要用到分布式锁。
分布式锁的简单实现
TINY框架
06-09 144
分布式锁在分布式应用当中是要经常用到的，主要是解决分布式资源访问冲突的问题。一开始考虑采用ReentrantLock来实现，但是实际上去实现的时候，是有问题的，ReentrantLock的lock和unlock要求必须是在同一线程进行，而分布式应用中，lock和unlock是两次不相关的请求，因此肯定不是同一线程，因此导致无法使用ReentrantLock。 接下来就考虑采用自己做个状态来进...
分布式锁以及分布式锁框架Redisson
qq_60796259的博客
07-18 1067
1、乐观锁与悲观锁乐观锁悲观锁2、可重入锁和非可重入锁可重入锁：当在一个线程中第一次成功获取锁之后，在此线程中就可以再次获取非可重入锁3、公平锁和非公平锁公平锁：按照线程的先后顺序获取锁非公平锁：多个线程随机获取锁4、阻塞锁和非阻塞锁阻塞锁：不断尝试获取锁，直到获取到锁为止非阻塞锁：如果获取不到锁就放弃，但可以支持在一定时间段内的重试​ ——在一段时间内如果没有获取到锁就放弃。
《自己动手写框架4》：分布式锁的简单实现
柏图
06-04 2522
分布式锁在分布式应用当中是要经常用到的，主要是解决分布式资源访问冲突的问题。  一开始考虑采用ReentrantLock来实现，但是实际上去实现的时候，是有问题的，ReentrantLock的lock和unlock要求必须是在同一线程进行，而分布式应用中，lock和unlock是两次不相关的请求，因此肯定不是同一线程，因此导致无法使用ReentrantLock。 接下来就考虑采用自己做个状态来进行
redisson分布式锁的实现
ningshuaichen的专栏
11-13 972
最近由于工作很忙，很长时间没有更新博客了，今天为大家带来一篇有关Redisson实现分布式锁的文章，好了，不多说了，直接进入主题。 1. 可重入锁（Reentrant Lock） Redisson的分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口，同时还支持自动过期解锁。 [java] view
Redisson分布式锁
qq_36987489的博客
03-25 606
这里写自定义目录标题什么是RedissonJedis与Redisson常用功能分布式锁限流器话题(订阅分发）事务队列分布式服务布隆过滤器配置方式单Redis节点模式spring boot配置案例讲解帮助文档 什么是Redisson Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。 它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。包括Queue、Lock、AtomicLong、CountDownLatch、Publish
分布式锁（redis/zookeeper)
orecle_littleboy的博客
09-19 625
现在面试，一般都会聊聊分布式系统这块的东西。通常面试官都会从服务框架(Spring Cloud、Dubbo)聊起，一路聊到分布式事务、分布式锁、ZooKeeper 等知识。 所以咱们就来聊聊分布式锁这块的知识，先具体的来看看 Redis 分布式锁的实现原理。 说实话，如果在公司里落地生产环境用分布式锁的时候，一定是会用开源类库的，比如 Redis 分布式锁，一般就是用 Redisson 框架就...
基于Redisson 实现 Redis 分布式锁操作--最优实现
04-04
Redisson是基于Redis实现的Java驻留内存数据网格的开源框架，提供了丰富的分布式锁实现方式。下面介绍基于Redisson的最优实现。 1. 初始化Redisson客户端 ```java Config config = new Config(); config.useSingleServer().setAddress("redis://127.0.0.1:6379"); RedissonClient redisson = Redisson.create(config); ``` 2. 获取分布式锁 ```java RLock lock = redisson.getLock("myLock"); lock.lock(); try { // 业务逻辑 } finally { lock.unlock(); } ``` 3. 设置加锁超时时间和释放锁时限制 ```java RLock lock = redisson.getLock("myLock"); boolean locked = lock.tryLock(10, 60, TimeUnit.SECONDS); try { if (locked) { // 业务逻辑 } else { // 获取锁失败 } } finally { if (locked) { lock.unlock(); } } ``` 4. 实现可重入锁 ```java RLock lock = redisson.getLock("myLock"); lock.lock(); try { lock.lock(); try { // 业务逻辑 } finally { lock.unlock(); } } finally { lock.unlock(); } ``` 5. 实现公平锁 ```java RLock lock = redisson.getFairLock("myFairLock"); lock.lock(); try { // 业务逻辑 } finally { lock.unlock(); } ``` 6. 实现读写锁 ```java RReadWriteLock rwlock = redisson.getReadWriteLock("myReadWriteLock"); rwlock.readLock().lock(); try { // 读操作业务逻辑 } finally { rwlock.readLock().unlock(); } rwlock.writeLock().lock(); try { // 写操作业务逻辑 } finally { rwlock.writeLock().unlock(); } ``` 以上就是基于Redisson实现Redis分布式锁的最优实现。Redisson提供了丰富的分布式锁实现，可以根据业务需求选择合适的锁类型。同时，Redisson还提供了许多其他功能，如分布式对象、分布式限流等，可以方便地实现分布式应用程序。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值