Redis学习（12）｜使用Redis在Spring Boot中实现分布式锁

使用场景

分布式锁在分布式系统中非常重要，常见的使用场景包括：

1. 保证数据一致性：在多个服务实例同时操作共享资源时，使用分布式锁可以避免数据冲突，确保数据一致性。
2. 限流控制：限制高并发情况下对某一资源的访问频率，避免资源过载。
3. 任务调度：确保同一时间只有一个服务实例执行特定任务，避免重复执行。

优缺点

优点

1. 简单易用：Redis提供了丰富的API，可以轻松实现分布式锁。
2. 高性能：Redis的高性能和低延迟确保了分布式锁的高效性。
3. 丰富的特性：支持过期时间，自动释放锁，避免死锁。

缺点

1. 单点故障：如果Redis节点宕机，分布式锁将不可用。可以通过Redis集群或主从复制来解决这一问题。
2. 锁误释放：在某些极端情况下，可能会误释放其他客户端持有的锁，需谨慎设计和使用。

注意事项

1. 锁的唯一性：锁的key必须是唯一的，以防止不同的业务场景混用同一个锁。
2. 合理设置过期时间：过期时间应比业务逻辑执行时间略长，避免锁的过期时间太短导致锁过早释放。
3. 避免死锁：应确保在任何情况下都能释放锁，避免出现死锁。
4. 锁续期：在某些长时间业务场景中，需要实现锁的续期机制。

实现步骤

1. 添加依赖

在pom.xml文件中添加Spring Data Redis的依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
</dependency>

2. 配置Redis连接

在application.properties文件中配置Redis连接信息。

spring.redis.host=localhost
spring.redis.port=6379

3. 实现分布式锁逻辑

3.1 创建Redis配置类

用于配置RedisTemplate和StringRedisTemplate。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        return template;
    }

    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
        return new StringRedisTemplate(factory);
    }
}

3.2 创建RedisLock类

用于实现分布式锁的逻辑。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

@Component
public class RedisLock {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public boolean lock(String key, String value, long timeout, TimeUnit unit) {
        Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(key, value, timeout, unit);
        return success != null && success;
    }

    public void unlock(String key, String value) {
        String currentValue = stringRedisTemplate.opsForValue().get(key);
        if (value.equals(currentValue)) {
            stringRedisTemplate.delete(key);
        }
    }
}

3.3 使用RedisLock实现分布式锁

在控制器中使用RedisLock来加锁和解锁。

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

import java.util.UUID;
import java.util.concurrent.TimeUnit;

@RestController
public class TestController {

    @Autowired
    private RedisLock redisLock;

    @GetMapping("/testLock")
    public String testLock() {
        String key = "lockKey";
        String value = UUID.randomUUID().toString();
        try {
            // 尝试加锁
            boolean isLocked = redisLock.lock(key, value, 10, TimeUnit.SECONDS);
            if (isLocked) {
                // 执行业务逻辑
                return "Lock acquired and business logic executed";
            } else {
                return "Failed to acquire lock";
            }
        } finally {
            // 释放锁
            redisLock.unlock(key, value);
        }
    }
}

最佳实践

1. 使用唯一ID：锁的value应使用唯一ID，如UUID，以区分不同客户端的锁。
2. 合理设置过期时间：根据业务需求设置合理的过期时间，避免锁的过期时间过短或过长。
3. 异常处理：在加锁和解锁时处理可能的异常，确保锁能够正确释放。
4. 锁续期机制：在长时间任务中，可以引入锁续期机制，确保任务执行过程中锁不会过期。
5. 分布式锁中间件：对于复杂的分布式锁需求，可以考虑使用成熟的分布式锁中间件，如Redisson。

通过以上步骤和最佳实践，可以在Spring Boot中使用Redis实现高效可靠的分布式锁，确保分布式系统中共享资源的安全访问。