分布式锁的实现方式：使用 Redisson 实现分布式锁（ Spring Boot ）

发布于：2025-07-03 ⋅ 阅读:(29) ⋅ 点赞:(0)

Redisson提供了分布式和可扩展的Java数据结构，包括分布式锁的实现。

1. 添加依赖

在pom.xml中添加Redisson依赖：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.16.4</version> <!-- 根据需要选择最新稳定版本 -->
</dependency>
2. 配置Redisson客户端

创建Redisson配置类：

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();
        config.useSingleServer()
              .setAddress("redis://localhost:6379")
              .setPassword("yourPassword") // 如果有密码
              .setDatabase(0);
        
        // 集群模式配置示例
        /*
        config.useClusterServers()
              .addNodeAddress("redis://node1:7000", "redis://node2:7001")
              .setPassword("password")
              .setScanInterval(2000); // 集群状态扫描间隔
        */
        
        return Redisson.create(config);
    }
}
3. 使用Redisson分布式锁

以下是几种常见的锁使用方式：

3.1 可重入锁（Reentrant Lock）
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class OrderService {

    @Autowired
    private RedissonClient redissonClient;

    public void createOrder(String orderId) {
        String lockName = "order-lock:" + orderId;
        RLock lock = redissonClient.getLock(lockName);
        
        try {
            // 方式1：阻塞式获取锁（默认30秒自动释放）
            lock.lock();
            
            // 方式2：带超时的获取锁（等待100秒，自动释放时间30秒）
            // boolean isLocked = lock.tryLock(100, 30, TimeUnit.SECONDS);
            // if (isLocked) { ... }
            
            // 执行业务逻辑
            System.out.println("获取锁成功，处理订单: " + orderId);
            Thread.sleep(2000);
            
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            // 释放锁
            lock.unlock();
        }
    }
}
3.2 公平锁（Fair Lock）
public void createOrderFair(String orderId) {
    String lockName = "fair-order-lock:" + orderId;
    // 获取公平锁
    RLock fairLock = redissonClient.getFairLock(lockName);
    
    try {
        fairLock.lock();
        // 执行业务逻辑
    } finally {
        fairLock.unlock();
    }
}
3.3 读写锁（ReadWriteLock）
import org.redisson.api.RReadWriteLock;

public void updateProductStock(String productId) {
    String lockName = "product-rw-lock:" + productId;
    RReadWriteLock rwLock = redissonClient.getReadWriteLock(lockName);
    
    // 写锁（互斥）
    try {
        rwLock.writeLock().lock();
        // 执行写操作，如更新库存
    } finally {
        rwLock.writeLock().unlock();
    }
    
    // 读锁（共享）
    try {
        rwLock.readLock().lock();
        // 执行读操作，如查询库存
    } finally {
        rwLock.readLock().unlock();
    }
}
4. Redisson分布式锁的特性

  1. 自动续约（WatchDog机制）
    当获取锁时未指定释放时间，Redisson会自动延长锁的过期时间，防止业务执行时间过长导致锁提前释放。

  2. 可重入性
    同一线程可以多次获取同一把锁而不会死锁，需要相应次数的释放。

  3. 异常处理
    Redisson的锁释放操作在finally块中执行，确保即使发生异常也能释放锁。

  4. 异步和响应式支持
    支持异步获取锁和响应式编程模型：

    // 异步获取锁
CompletableFuture<Boolean> future = lock.tryLockAsync(100, 30, TimeUnit.SECONDS);
5. RedLock算法实现（多节点模式）

RedLock用于在多个Redis节点上实现更高可靠性的分布式锁：

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

public void redLockExample() {
    // 创建多个Redisson客户端连接不同节点
    RedissonClient client1 = Redisson.create(...);
    RedissonClient client2 = Redisson.create(...);
    RedissonClient client3 = Redisson.create(...);
    
    RLock lock1 = client1.getLock("lock1");
    RLock lock2 = client2.getLock("lock2");
    RLock lock3 = client3.getLock("lock3");
    
    // 创建RedLock
    org.redisson.api.RedLock redLock = new org.redisson.api.RedLock(lock1, lock2, lock3);
    
    try {
        // 尝试获取锁（多数节点成功才算成功）
        boolean isLocked = redLock.tryLock(100, 30, TimeUnit.SECONDS);
        if (isLocked) {
            // 执行业务逻辑
        }
    } finally {
        redLock.unlock();
    }
}

6.可重入锁示例

6.1示例背景及需求

在很多实际业务场景中，我们执行的操作可能由于各种临时原因（比如网络抖动、资源暂时不可用等）而失败，此时往往希望能够进行重试，以增加操作最终成功的概率。同时，为了保证在重试过程中对共享资源的访问是互斥的（避免多个线程同时操作造成数据不一致等问题），就需要使用可重入锁来进行控制。

6.2详细代码示例
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class RetryableOperationService {

    @Autowired
    private RedissonClient redissonClient;

    // 定义最大重试次数
    private static final int MAX_ATTEMPTS = 3;

    // 定义重试间隔时间（单位：毫秒）
    private static final long RETRY_INTERVAL = 100;

    public void retryableOperation(String key) {
        String lockName = "retry-lock:" + key;
        RLock lock = redissonClient.getLock(lockName);
        lock.lock();
        try {
            int attempts = 0;
            while (attempts < MAX_ATTEMPTS) {
                try {
                    // 这里是具体要执行的可能失败的业务操作，比如调用外部接口获取数据、更新数据库等
                    System.out.println("正在执行第 " + (attempts + 1) + " 次尝试操作...");
                    // 模拟业务操作可能出现的异常情况，这里简单地通过抛异常来表示操作失败
                    if (attempts == 1) {
                        throw new RuntimeException("模拟操作失败");
                    }
                    // 如果操作成功，直接返回，不再进行重试
                    return;
                } catch (Exception e) {
                    attempts++;
                    System.out.println("操作失败，第 " + attempts + " 次重试，等待 " + RETRY_INTERVAL + " 毫秒后再次尝试...");
                    // 线程休眠一段时间，等待后再次尝试
                    Thread.sleep(RETRY_INTERVAL);
                }
            }
            System.out.println("达到最大重试次数，操作最终失败");
        } catch (InterruptedException ex) {
            Thread.currentThread().interrupt();
            System.out.println("线程被中断，操作终止");
        } finally {
            // 无论操作最终是否成功，都要释放锁，确保其他线程可以获取锁来执行操作
            lock.unlock();
        }
    }
}
6.3代码执行流程说明

  1. 获取锁：
    首先，根据传入的 key 生成对应的锁名称（retry-lock:具体的key值），然后通过 RedissonClient 获取可重入锁 lock，并调用 lock() 方法获取锁，这一步保证了在同一时刻只有一个线程能够执行后续的重试操作，避免并发冲突。

  2. 执行操作与重试逻辑：
    进入 while 循环，开始尝试执行具体的业务操作。在每次循环中：

    • 尝试执行业务操作：这里只是简单地模拟了业务操作，通过抛异常来表示操作失败（实际应用中可能是调用外部接口返回错误码、数据库更新失败等情况）。如果操作成功（没有抛出异常），则直接通过 return 语句结束方法，不再进行重试。
    • 处理操作失败情况：当操作抛出异常时，表示此次尝试失败。attempts 变量记录当前的重试次数，每次失败后将其加1，并输出相应的重试提示信息，然后让线程休眠 RETRY_INTERVAL（100毫秒）时间，等待一段时间后再次进行下一次尝试。

  3. 重试次数限制与最终结果处理：
    while 循环的条件是 attempts < MAX_ATTEMPTS，也就是最多只会重试 MAX_ATTEMPTS（定义为3次）次。当达到最大重试次数后，如果操作还是没有成功，就会输出操作最终失败的提示信息。

  4. 释放锁：
    无论操作最终是成功还是达到最大重试次数失败，都会进入 finally 块释放锁。这一步非常关键，确保了锁资源能够被正确释放，使得其他等待获取该锁的线程有机会执行相应的操作。

6.4适用场景举例

  1. 网络请求重试：
    比如在一个微服务架构中，服务A需要调用服务B的接口获取数据来更新本地数据库。由于网络环境不稳定，可能出现调用失败的情况。此时，服务A就可以使用上述带有可重入锁的重试机制，在获取到锁后，多次尝试调用服务B的接口，保证在重试过程中不会有其他线程同时进行相同的调用操作，避免数据不一致等问题。

  2. 数据库更新重试：
    当向数据库插入或更新一条重要记录时，可能因为数据库临时负载过高、事务冲突等原因导致操作失败。通过使用这种带可重入锁的重试机制，可以在一定次数内反复尝试更新操作，同时保证在整个重试期间，其他线程不会干扰该记录的更新，确保数据的完整性和一致性。

6.5总结

可重入锁主要用于以下方面：

  1. 确保操作的互斥性
    在整个 retryableOperation 方法执行期间，从获取锁开始到最终释放锁，只有获取到锁的那个线程能够执行后续的业务操作以及重试逻辑。例如，假设有多个线程同时调用 retryableOperation 方法并传入相同的 key，由于锁的存在，只有最先成功获取到锁（锁名为 retry-lock:具体的key值）的线程能够进入到方法内部开始执行可能失败的业务操作以及重试流程，其他线程会被阻塞等待锁释放，从而保证了针对同一 key 对应的操作在同一时刻是互斥执行的，避免了多个线程同时操作造成的数据不一致、资源竞争等问题。
  2. 支持重试过程中的再次进入
    因为是可重入锁，在重试逻辑中（while 循环内），当业务操作失败后线程进行休眠，然后再次尝试执行业务操作时，同一线程能够再次获取到已经持有的这把锁（无需等待锁释放后重新竞争获取），可以顺利进入循环体继续执行后续的操作，不会出现因为锁的限制而导致自己阻塞自己的情况。如果使用的是不可重入锁，那么在重试时线程再次尝试获取锁就会被阻塞，因为它自己已经持有这把锁了，这样就无法完成重试逻辑，会陷入死锁状态。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布