如何使用Redisson实现分布式锁？

在分布式系统中，当多个线程（或进程）同时操作同一个资源时，为了保证数据一致性问题，所以就需要一种机制来确保在同一时间只有一个线程（或进程）能够对资源进行修改，这就是分布式锁的作用。

分布式锁是一种在分布式环境下的锁实现，它允许在多个进程或服务器之间协调对共享资源的访问或操作。分布式锁的关键特性是它能够在集群内的不同节点间保持其锁定状态，使得某一时刻仅有一个客户端能够获取并持有该锁，从而确保对公共资源的原子性和一致性访问。

实现分布式锁的方式有多种，例如基于数据库、Redis、ZooKeeper 等中间件来实现，它们通常依赖于这些中间件提供的事务特性，或者命令语义来达到分布式环境下的锁效果。例如，Redis 通过 SETNX 命令配合过期时间可实现一个简单的分布式锁方案。

1.SETNX 存在的问题

虽然可以使用 SETNX 命令方便的实现分布式锁，但是 SETNX 存在以下问题：

1. 死锁问题：SETNX 如未设置过期时间，锁忘记删了或加锁线程宕机都会导致死锁，也就是分布式锁一直被占用的情况。
2. 锁误删问题：SETNX 设置了超时时间，但因为执行时间太长，所以在超时时间之内锁已经被自动释放了，但线程不知道，因此在线程执行结束之后，会把其他线程的锁误删的问题。
3. 不可重入问题：也就是说同一线程在已经获取了某个锁的情况下，如果再次请求获取该锁，则请求会失败（因为只有在第一次能加锁成功）。也就是说，一个线程不能对自己已持有的锁进行重复锁定。
4. 无法自动续期：线程在持有锁期间，任务未能执行完成，锁可能会因为超时而自动释放。SETNX 无法自动根据任务的执行情况，设置新的超时实现，以延长锁的时间。

那么如何解决以上这些问题呢？这就是今天要讲的重点 Redisson，使用 Redisson 框架就可以解决以上这些问题了。

2.什么是 Redisson？

Redisson 是一个开源的用于操作 Redis 的 Java 框架。与 Jedis 和 Lettuce 等轻量级的 Redis 框架不同，它提供了更高级且功能丰富的 Redis 客户端。它提供了许多简化 Redis 操作的高级 API，并支持分布式对象、分布式锁、分布式集合等特性。

Redisson 官网：https://redisson.org/

源码：https://github.com/redisson/redisson

3.Redisson 特性说明

1. Redisson 可以设置分布式锁的过期时间，从而避免锁一直被占用而导致的死锁问题。
2. Redisson 在为每个锁关联一个线程 ID 和重入次数（递增计数器）作为分布锁 value 的一部分存储在 Redis 中，这样就避免了锁误删和不可重入的问题。
3. Redisson 还提供了自动续期的功能，通过定时任务（看门狗）定期延长锁的有效期，确保在业务未完成前，锁不会被其他线程获取。

4.Redisson 使用分布式锁

① 添加 Redisson 框架支持

如果是 Spring Boot 项目，直接添加 Redisson 为 Spring Boot 写的如下依赖：

<!-- Redisson -->
<!-- https://mvnrepository.com/artifact/org.redisson/redisson-spring-boot-starter -->
<dependency>
  <groupId>org.redisson</groupId>
  <artifactId>redisson-spring-boot-starter</artifactId>
  <version>3.25.2</version> <!-- 请根据实际情况使用最新版本 -->
</dependency>

其他项目，访问 https://mvnrepository.com/search?q=Redisson 获取具体依赖配置。

② 配置 RedissonClient 对象

将 RedissonClient 重写，存放到 IoC 容器，并且配置连接的 Redis 服务器信息。

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RedissonConfig {
   
    @Bean
    public RedissonClient redissonClient() {
   
        Config config = new Config();
        // 也可以将 redis 配置信息保存到配置文件
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        return Redisson.create(config);
    }
}

③ 创建分布式锁

Redisson 分布式锁的操作和 Java 中的 ReentrantLock（可重入锁）的操作很像，都是先使用 tryLock 尝试获取（非公平）锁，最后再通过 unlock 释放锁，具体实现如下：

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.TimeUnit;
@RestController
public class LockController {
   
    @Autowired
    private RedissonClient redissonClient;
    @GetMapping("/lock")
    public String lockResource() throws InterruptedException {
   
        String lockKey = "myLock";
        // 获取 RLock 对象
        RLock lock = redissonClient.getLock(lockKey);
        try {
   
            // 尝试获取锁（尝试加锁）（锁超时时间是 30 秒）
            boolean isLocked = lock.tryLock(30, TimeUnit.SECONDS);
            if (isLocked) {
   
                // 成功获取到锁
                try {
   
                    // 模拟业务处理
                    TimeUnit.SECONDS.sleep(5);
                    return "成功获取锁，并执行业务代码";
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                } finally {
   
                    // 释放锁
                    lock.unlock();
                }
            } else {
   
                // 获取锁失败
                return "获取锁失败";
            }
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        return "获取锁成功";
    }
}

a.实现公平锁

Redisson 默认创建的分布式锁是非公平锁（出于性能的考虑），想要把它变成公平锁可使用以下代码实现：

RLock lock = redissonClient.getFairLock(lockKey);  // 获取公平锁

b.实现读写锁

Redisson 还可以创建读写锁，如下代码所示：

RReadWriteLock lock = redissonClient.getReadWriteLock(lockKey); // 获取读写锁
lock.readLock();  // 读锁
lock.writeLock(); // 写锁

读写锁的特点就是并发性能高，它是允许多个线程同时获取读锁进行读操作的，也就是说在没有写锁的情况下，读取操作可以并发执行，提高了系统的并行度。但写锁则是独占式的，同一时间只有一个线程可以获得写锁，无论是读还是写都无法与写锁并存，这样就确保了数据修改时的数据一致性。

c.实现联锁

Redisson 也支持联锁，也叫分布式多锁 MultiLock，它允许客户端一次性获取多个独立资源（RLock）上的锁，这些资源可能是不同的键或同一键的不同锁。当所有指定的锁都被成功获取后，才会认为整个操作成功锁定。这样能够确保在分布式环境下进行跨资源的并发控制。
联锁的实现示例如下：

// 获取需要加锁的资源
RLock lock1 = redisson.getLock("lock1");
RLock lock2 = redisson.getLock("lock2");
// 联锁
RedissonMultiLock multiLock = new RedissonMultiLock(lock1, lock2);
try {
   
    // 一次性尝试获取所有锁
    if (multiLock.tryLock()) {
   
        // 获取锁成功...
    }
} finally {
   
    // 释放所有锁
    multiLock.unlock();
}

课后思考

以上 Redisson 只是对 Redis 单节点加锁实现分布式锁的，但分布式环境中的 Redis 一定采用的是多机部署（主从、哨兵或集群），那么在多机环境下以上代码实现分布式锁还能用吗？如果不能用，那该如何处理呢？

本文已收录到我的面试小站 www.javacn.site，其中包含的内容有：Redis、JVM、并发、并发、MySQL、Spring、Spring MVC、Spring Boot、Spring Cloud、MyBatis、设计模式、消息队列等模块。