Redisson 分布式锁的使用详解

一、分布式锁的概述

1.1 分布式锁的背景

在单机系统中，Java 提供了 synchronized 和 Lock 等锁机制来确保并发情况下的线程安全。然而，在分布式系统中，多个服务实例运行在不同的物理或虚拟机上，无法直接使用这些本地的锁机制来控制对共享资源的访问。

为了在分布式环境中控制对共享资源的访问，就需要引入一种能够跨多台服务器实例的锁机制，这就是分布式锁。Redis 作为一种高性能的内存数据库，提供了基于 Redis 的分布式锁实现。Redisson 基于 Redis 对分布式锁进行了封装，提供了简洁易用的 API 来管理分布式锁。

1.2 分布式锁的特性

一个完整的分布式锁需要具备以下几个特性：

互斥性：同一时刻只能有一个客户端能获得锁，其他客户端必须等待锁被释放后才能继续操作。
容错性：如果持有锁的客户端因为网络或系统故障而没有主动释放锁，锁应当能够被安全地释放。
高可用性：锁的请求和释放过程应该是高效的，且在 Redis 节点出现故障时，系统依然能够正常工作。

二、Redisson 分布式锁的原理

Redisson 分布式锁基于 Redis 的 SETNX (set if not exists) 命令实现。基本的原理如下：

加锁：客户端请求加锁时，会向 Redis 发送一个 SETNX 命令，如果返回值为 1，表示加锁成功。如果返回 0，则说明锁已经被其他客户端持有，当前客户端需要等待。
自动过期：为了防止客户端因故障而无法释放锁，锁的持有是有过期时间的。通过 Redis 的 EXPIRE 命令，锁在加锁时同时设置过期时间，到期后锁将自动释放。
解锁：锁持有者执行完任务后，主动向 Redis 发送命令删除锁的 key，从而释放锁，其他等待的客户端才能继续加锁。

Redisson 通过封装 Redis 的这些基础命令，提供了 RLock 接口来方便地实现分布式锁。

三、Redisson 分布式锁的使用

3.1 引入 Redisson 依赖

在项目中使用 Redisson，首先需要在 pom.xml 文件中引入 Redisson 的依赖：

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

3.2 Redisson 配置

为了使用 Redisson 分布式锁，首先需要配置 Redisson 客户端。Redisson 支持单节点模式、主从模式、集群模式和哨兵模式等多种 Redis 部署模式。这里我们以单节点模式为例：

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

public class RedissonConfig {

    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        return Redisson.create(config);
    }
}

3.3 使用分布式锁

在配置好 Redisson 客户端后，可以通过 RedissonClient 来获取 RLock 对象，进行分布式加锁和解锁操作。下面是一个简单的使用示例：

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;

public class DistributedLockExample {

    private final RedissonClient redissonClient;

    public DistributedLockExample(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    public void executeWithLock() {
        // 获取锁对象
        RLock lock = redissonClient.getLock("myLock");

        try {
            // 加锁
            lock.lock();
            System.out.println("获得锁，执行临界区代码");

            // 模拟业务逻辑
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
            System.out.println("释放锁");
        }
    }
}

在上面的示例中，我们通过 redissonClient.getLock("myLock") 获取一个名为 myLock 的锁对象，并在执行完任务后通过 lock.unlock() 主动释放锁。

3.4 设置锁的超时时间

为了防止因异常情况导致锁无法释放，Redisson 提供了设置锁超时时间的功能。在获取锁时，可以通过 lock.lock(long leaseTime, TimeUnit unit) 方法指定锁的持有时间。例如，下面的代码将设置锁的持有时间为 10 秒：

public void executeWithTimeoutLock() {
    RLock lock = redissonClient.getLock("myLock");

    try {
        // 加锁并设置超时时间为10秒
        lock.lock(10, TimeUnit.SECONDS);
        System.out.println("获得锁，执行临界区代码");

        // 模拟业务逻辑
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        // 无需主动解锁，锁会在10秒后自动释放
        if (lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
        System.out.println("释放锁");
    }
}

四、Redisson 分布式锁的应用场景

4.1 控制并发访问

在电商、抢购等高并发场景中，多个用户同时发起对同一商品的抢购请求，此时需要使用分布式锁来控制对库存资源的并发访问，防止超卖或重复购买。

public void purchase(String productId) {
    RLock lock = redissonClient.getLock("product:" + productId);

    try {
        // 尝试获取锁
        if (lock.tryLock(5, 10, TimeUnit.SECONDS)) {
            // 执行购买逻辑
            System.out.println("购买成功");
        } else {
            System.out.println("获取锁失败，购买失败");
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        if (lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
}

4.2 分布式任务调度

在分布式系统中，任务调度器往往有多个实例在同时运行。如果多个实例同时执行相同的任务，可能会导致数据重复处理或任务冲突。此时可以通过 Redisson 分布式锁确保同一时刻只有一个实例能够执行任务。

public void scheduleTask() {
    RLock lock = redissonClient.getLock("taskLock");

    try {
        if (lock.tryLock(1, TimeUnit.MINUTES)) {
            System.out.println("获得锁，执行调度任务");
            // 执行定时任务
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        if (lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
}