如何正确使用Redisson实现分布式锁

分布式锁主要用于保证在分布式系统中，对共享资源的互斥访问，防止多个进程同时操作造成数据不一致。Redis实现分布式锁具备高性能和高可靠性的优势。接下来，我将详细描述如何在Spring Boot项目中使用Redis实现分布式锁。

常见的共享资源举例

1.用户的余额信息
2.商品的库存数量
3.你觉得两个线程同时操作会出问题的字段

依赖配置

首先，在Spring Boot项目中添加Redis相关的依赖。在pom.xml中添加以下内容：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson-spring-boot-starter</artifactId>
        <version>3.15.6</version>
    </dependency>
</dependencies>

在这个示例中，我们使用了Redisson库，这是一个较为成熟的Redis客户端，它在实现分布式锁时提供了简便的API。

Redis 配置

在application.yml或application.properties文件中配置Redis连接信息：

spring:
  redis:
    host: localhost
    port: 6379

配置Redisson客户端

创建一个配置类，用于初始化Redisson客户端：

import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.spring.starter.RedissonAutoConfiguration;
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");
        return Redisson.create(config);
    }
}

分布式锁实现

创建一个服务类，用于实现分布式锁的逻辑：

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 DistributedLockService {

    @Autowired
    private RedissonClient redissonClient;

    private static final String LOCK_NAME = "distributed-lock";

    // 尝试获取分布式锁
    public boolean acquireLock(long waitTime, long leaseTime) {
        RLock lock = redissonClient.getLock(LOCK_NAME);
        try {
            // tryLock会在waitTime内等待锁的可用性，获取到锁后会持有它leaseTime时间
            return lock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }

    // 释放分布式锁
    public void releaseLock() {
        RLock lock = redissonClient.getLock(LOCK_NAME);
        if (lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
}

使用示例

创建一个Controller，通过HTTP接口来演示分布式锁的使用：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/lock")
public class LockController {

    @Autowired
    private DistributedLockService lockService;

    @GetMapping("/acquire")
    public String acquireLock() {
        boolean acquired = lockService.acquireLock(10, 20);
        if (acquired) {
            try {
                // 执行业务逻辑，假设需要10秒钟
                Thread.sleep(10000);
                return "Lock acquired and task completed";
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return "Task was interrupted";
            } finally {
                // 释放锁
                lockService.releaseLock();
            }
        } else {
            return "Could not acquire lock";
        }
    }
}

测试分布式锁

启动Spring Boot应用，并通过以下命令测试分布式锁：

curl -X GET 'http://localhost:8080/lock/acquire'

通过查看控制台日志和返回结果，可以验证分布式锁的功能。例如，使用不同的客户端同时发送多个请求，只会有一个请求获得锁并完成业务逻辑，其它请求将无法获取锁。

注意点

1. RedissonClient配置：确保合理配置Redisson客户端，特别是在生产环境下，需要考虑到Reids集群和主从复制的配置。
2. 锁超时：合理设置锁的等待时间和持有时间，防止死锁和长时间占用资源。
3. 故障恢复：考虑锁失效或服务重启等异常情况，确保系统能够正确处理这种情况，使锁尽快释放。

小结

通过上述步骤，我们使用Redisson实现了一个简单的分布式锁。在分布式系统中，合理使用Redis提供的分布式锁机制，可以有效防止并发访问共享资源造成的数据不一致问题。Redisson的API简洁而强大，推荐在实际项目中使用。

如果对分布式锁在具体业务中的应用有更多需求，可以进一步研究Redisson提供的多种锁机制，如公平锁和读写锁，以及在复杂场景中的最佳实践。