引言

在分布式系统中，经常需要对共享资源进行并发访问控制，以确保数据的一致性和完整性。分布式锁是一种用于在分布式环境中控制对共享资源访问的机制，它可以保证在同一时刻只有一个客户端能够访问某些特定资源。

1. Redisson概述

1.1 Redisson的基本概念

Redisson是一个基于Redis的Java客户端，它不仅提供了对Redis的基础操作支持，还封装了许多高级功能，如分布式锁、分布式集合、分布式队列等。Redisson的设计目标是简化分布式系统的开发，提高开发效率和系统的可维护性。

1.2 Redisson的主要功能

1. 分布式锁：支持可重入锁、公平锁、读写锁、红锁等多种分布式锁机制，保证分布式环境下的资源访问控制。比如：在电商系统中，防止超卖现象；在订单系统中，防止同一订单被多次处理。
2. 分布式集合：提供分布式Set、List、Map等集合类型，支持高并发环境下的数据操作。
3. 分布式队列：支持分布式阻塞队列、延迟队列等，适用于任务调度和消息传递场景。
4. 分布式对象：提供分布式AtomicLong、AtomicDouble、CountDownLatch、Semaphore等对象，简化分布式系统的开发。
5. 分布式服务：支持分布式执行器、分布式调度器等服务，增强分布式系统的功能。

1.3 Redisson的优点

Redisson是一个基于Redis的Java客户端，提供了许多高级特性和分布式数据结构。相比其他Redis客户端，Redisson的优势在于：

• 简洁易用：提供了丰富的API，简化了分布式编程的复杂性。
• 高可用性：支持多种Redis部署模式，包括单节点、主从复制和集群模式。
• 分布式对象：提供了分布式锁、分布式集合、分布式队列等高级数据结构，便于在分布式环境中使用。
• 自动续期：Redisson的Watchdog机制可以自动续期分布式锁，避免锁超时问题。

2. 开发环境

• JDK版本：JDK 17
• Spring Boot版本：Spring Boot 3.2.2
• Redis版本：5.0.14.1
• 构建工具：Maven

3. Redisson的安装与配置

3.1 添加依赖

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

3.2 配置Redisson

配置参考文档：2. Configuration · redisson/redisson Wiki (github.com)

添加配置类RedissonConfig：

/*** Redisson配置类，用于配置Redisson客户端。*/
@Configuration
public class RedissonConfig {/*** 创建并配置RedissonClient Bean。* * @return 配置好的RedissonClient实例*/@Beanpublic RedissonClient redissonClient() {// 创建Redisson配置对象Config config = new Config();// 配置单节点模式config.useSingleServer()// 设置Redis服务器地址.setAddress("redis://127.0.0.1:6379")// 设置Redis服务器密码.setPassword("123321")// 设置连接池大小.setConnectionPoolSize(64)// 设置最小空闲连接数.setConnectionMinimumIdleSize(24)// 设置空闲连接超时时间（毫秒）.setIdleConnectionTimeout(10000)// 设置连接超时时间（毫秒）.setConnectTimeout(10000)// 设置命令等待超时时间（毫秒）.setTimeout(3000)// 设置命令重试次数.setRetryAttempts(3)// 设置命令重试间隔时间（毫秒）.setRetryInterval(1500);// 创建并返回RedissonClient实例return Redisson.create(config);}
}

4. 使用Redisson

官方wiki文档：8. Distributed locks and synchronizers · redisson/redisson Wiki (github.com)

中文版wiki文档（已经有5年没有更新了，不建议看）：8. 分布式锁和同步器 · redisson/redisson Wiki (github.com)

4.1 可重入锁

4.1.1 可重入锁的概念

可重入锁（Reentrant Lock）是一种允许同一个线程多次获取同一把锁的锁机制。也就是说，当一个线程已经持有某个锁时，它可以再次获取该锁而不会被阻塞。这种锁机制能够避免死锁问题，并简化锁的使用。

可重入锁的主要特点是：

• 同一线程可多次获取：同一个线程可以多次获取同一把锁，而不会被阻塞。
• 计数器维护：可重入锁内部维护一个计数器，每次获取锁时计数器加1，每次释放锁时计数器减1，当计数器为0时，锁才真正被释放。

4.1.2 可重入锁的实现原理

可重入锁的实现通常依赖于一个计数器和一个持有锁的线程标识。当一个线程第一次获取锁时，计数器加1，并记录持有锁的线程标识。当同一个线程再次获取锁时，只需将计数器加1，而不会阻塞线程。当线程释放锁时，计数器减1，当计数器为0时，锁才真正被释放，并允许其他线程获取锁。

在Redisson中，可重入锁的实现基于Redis的原子操作和Lua脚本。Redisson通过维护一个计数器和持有锁的线程标识，实现了可重入锁的功能。

4.1.3 简单使用

import lombok.RequiredArgsConstructor;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Service;import java.util.concurrent.TimeUnit;/*** 服务类示例*/
@RequiredArgsConstructor
@Service
public class XXXXService {private final RedissonClient redissonClient; /*** 使用 Redisson 可重入锁执行任务*/public void performTaskWithLock() {// 获取可重入锁对象，指定锁的名称RLock lock = redissonClient.getLock("myLock"); try {// 尝试获取锁，参数分别是：获取锁的最大等待时间，锁自动释放时间，时间单位，返回值为是否获取锁成功boolean isLock = lock.tryLock(1, 10, TimeUnit.SECONDS); // 判断获取锁成功if (isLock) { try {System.out.println("执行业务"); // 在这里编写需要进行锁保护的业务逻辑} finally {// 释放锁lock.unlock(); }} else {// 获取锁失败，可以进行相应的处理，例如记录日志或返回错误信息System.err.println("获取锁失败！"); }} catch (InterruptedException e) {// 处理中断异常throw new RuntimeException(e); }}
}

在上述代码中，我们使用redissonClient.getLock("myLock")获取一个分布式锁对象，然后使用lock.tryLock()方法尝试获取锁，并在任务完成后释放锁。

锁的获取和释放

• 获取锁：使用RLock对象的tryLock()或lock()方法来获取锁。tryLock()方法允许设置等待时间和锁的自动释放时间。
• 释放锁：使用RLock对象的unlock()方法来释放锁。确保在finally块中释放锁，以避免死锁。

4.2 公平锁

4.2.1 公平锁的概念

公平锁（Fair Lock）是一种确保锁的获取顺序与请求顺序相同的锁机制。即先请求锁的线程优先获取锁，后请求的线程只能在前面的线程释放锁后才能获取锁。这种机制可以避免“饥饿”现象，确保每个线程都能公平地获取锁。

4.2.2 公平锁的实现原理

公平锁的实现通常依赖于一个队列来记录请求锁的顺序。每次有线程请求锁时，会将其添加到队列中，当锁被释放时，从队列中按照请求顺序依次唤醒等待的线程。

在Redisson中，公平锁的实现基于Redis的有序集合（Sorted Set）和Lua脚本。每次请求锁时，线程会被添加到一个有序集合中，并按照时间戳排序。当锁被释放时，按照有序集合中的顺序依次唤醒等待的线程。

4.2.3 简单使用

public void performTaskWithFairLock() {// 1. 获取公平锁对象RLock fairLock = redissonClient.getFairLock("myFairLock");try {// 2. 尝试获取锁boolean isLock = fairLock.tryLock(1, 10, TimeUnit.SECONDS); // 3. 判断是否获取到锁if (isLock) { try {System.out.println("获得公平锁，正在执行任务...");// 执行任务} finally {// 4. 释放锁fairLock.unlock(); System.out.println("释放公平锁。");}} else {System.out.println("无法获取公平锁。");}} catch (InterruptedException e) {e.printStackTrace();}
}

4.3 读写锁

4.3.1 读写锁的概念

读写锁（Read-Write Lock）是一种允许多个读操作同时进行，但写操作必须独占的锁机制。读写锁分为两种锁：读锁和写锁。

• 读锁：允许多个线程同时获取读锁，只要没有线程持有写锁。读锁之间是共享的。
• 写锁：只允许一个线程获取写锁，并且在写锁持有期间，其他线程不能获取读锁或写锁。写锁是独占的。

读写锁的主要目的是提高并发性和性能。在读多写少的场景下，读写锁可以显著提高系统的并发处理能力。

4.3.2 读写锁的实现原理

读写锁的实现通常依赖于两个锁：一个读锁和一个写锁。读锁允许多个线程同时获取，而写锁只允许一个线程获取。在获取写锁时，需要确保没有线程持有读锁或写锁。

在Redisson中，读写锁的实现基于Redis的原子操作和Lua脚本。Redisson通过两个键来分别控制读锁和写锁，并使用Lua脚本确保锁操作的原子性。

4.3.3 简单使用

public void performTaskWithReadWriteLock() {// 1. 获取读写锁对象RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("myReadWriteLock");// 2. 从读写锁对象中分别获取读锁和写锁RLock readLock = readWriteLock.readLock();RLock writeLock = readWriteLock.writeLock();try {// 3. 尝试获取读锁if (readLock.tryLock(10, 60, TimeUnit.SECONDS)) { try {System.out.println("获取读锁，正在执行读任务...");// 执行读任务} finally {// 4. 释放读锁readLock.unlock(); System.out.println("释放读锁。");}}// 5. 尝试获取写锁if (writeLock.tryLock(10, 60, TimeUnit.SECONDS)) { try {System.out.println("获取写锁，正在执行写任务...");// 执行写任务} finally {// 6. 释放写锁writeLock.unlock();System.out.println("释放写锁。");}}} catch (InterruptedException e) {e.printStackTrace();}
}

4.4 联锁

4.4.1 联锁的概念

联锁（MultiLock）是一种允许将多个锁关联在一起，实现“全部获取”或“全部释放”的锁机制。

• 全部获取: 只有当所有参与联锁的锁都被成功获取后，才算成功获取联锁。
• 全部释放: 释放联锁时，会自动释放所有参与联锁的锁。

联锁适用于需要同时获取多个资源的场景，例如分布式事务中需要锁定多个数据表。

4.4.2 联锁的实现原理

Redisson 的联锁基于 RedissonMultiLock 对象实现。RedissonMultiLock 对象可以将多个 RLock 对象关联在一起，并提供 tryLock() 和 unlock() 方法来统一管理这些锁。

在调用 tryLock() 方法时，RedissonMultiLock 会尝试依次获取所有参与联锁的锁。如果所有锁都获取成功，则返回 true，否则释放已经获取到的锁，并返回 false。

在调用 unlock() 方法时，RedissonMultiLock 会自动释放所有参与联锁的锁，无论这些锁是否被当前线程持有。

4.4.3 简单使用

public void performTaskWithMultiLock() {// 获取多个锁对象RLock lock1 = redissonClient.getLock("lock1");RLock lock2 = redissonClient.getLock("lock2");RLock lock3 = redissonClient.getLock("lock3");// 创建联锁对象RLock multiLock = redissonClient.getMultiLock(lock1, lock2, lock3);try {// 尝试获取联锁，等待 10 秒if (multiLock.tryLock(10, TimeUnit.SECONDS)) {try {System.out.println("获取联锁成功，正在执行任务...");// 执行需要所有锁的任务} finally {// 释放联锁multiLock.unlock();System.out.println("释放联锁。");}} else {System.out.println("获取联锁失败。");}} catch (InterruptedException e) {e.printStackTrace();}
}

代码分析：

1. 获取多个锁对象: 首先，获取需要参与联锁的多个 RLock 对象。
2. 创建联锁对象: 使用 redissonClient.getMultiLock(lock1, lock2, lock3) 创建一个 RLock 对象，并将之前获取的多个锁对象作为参数传入。
3. 尝试获取联锁: 调用 multiLock.tryLock(10, TimeUnit.SECONDS) 尝试获取联锁，最多等待 10 秒。
4. 执行任务: 如果成功获取联锁，则执行需要所有锁保护的任务。
5. 释放联锁: 最后，在 finally 块中调用 multiLock.unlock() 释放联锁，这会自动释放所有参与联锁的锁。

5. WatchDog机制

想象一下，我们正在进行一场激烈的拔河比赛。我们队好不容易抓住了绳子，眼看就要赢了，结果突然有人手滑，绳子就被对方抢走了！

在分布式系统中，获取锁就好像抓住这根拔河绳。Redisson 分布式锁的租约时间就好像我们抓住绳子的时间。如果在租约时间内，我们没有完成任务，锁就自动释放了，其他线程就有机会获取锁，这就像拔河比赛中我们手滑绳子被抢走一样，可能会导致数据不一致的问题。

为了避免这种情况发生，Redisson 提供了 Watch Dog 机制，就像我们队伍里安排了一个“观察员”。这位观察员会每隔一段时间关注我们是否还抓着绳子，如果发现我们快坚持不住了，就会及时提醒我们，让我们重新握紧绳子，并延长我们抓住绳子的时间。

具体来说，Redisson 的Watch Dog 机制会在 Redisson 实例被关闭前，不断的延长锁的有效期，也就是说，如果一个拿到锁的线程一直没有完成逻辑，那么看门狗会帮助线程不断的延长锁超时时间，锁不会因为超时而被释放。

**开启方式：**在获取锁的时候，不能指定leaseTime或者只能将leaseTime设置为-1，这样才能开启看门狗机制。

public void test() throws Exception {RLock lock = redissonClient.getLock("myLock");// 方式一: 不停重试，直到获取锁成功，具有 Watch Dog 自动延期机制，默认续约时间为 30 秒lock.lock(); // 方式二: 尝试获取锁 10 秒，获取成功返回 true，否则返回 false，具有 Watch Dog 自动延期机制，默认续约时间为 30 秒boolean res1 = lock.tryLock(10, TimeUnit.SECONDS); // 方式三:  尝试获取锁 10 秒，如果获取成功，则持有锁，否则抛出异常，leaseTime 为 10 秒，不会自动续约try {lock.lock(10, TimeUnit.SECONDS); } catch (InterruptedException e) {// 处理异常}// 方式四: 尝试获取锁 100 秒，如果获取成功，则持有锁 10 秒，leaseTime 为 10 秒，不会自动续约boolean res2 = lock.tryLock(100, 10, TimeUnit.SECONDS); Thread.sleep(40000L);lock.unlock();
}

6. 总结

在本文中，我们简要介绍了Redisson及其优势，介绍了如何在Spring Boot项目中集成Redisson。通过代码示例展示了基本的分布式锁用法，以及高级用法如公平锁、可重入锁、读写锁和联锁。除此之外我们还简要介绍了Redisson 的Watch Dog 机制，希望本文对大家有所帮助😊。