你有没有过这样的经历？在互联网大厂后端开发工作中，面对高并发场景时，为了保证数据的一致性和操作的原子性，需要使用分布式锁。而在 Spring Boot 项目里，选择用 Redis 来实现自定义分布式锁，却遇到了一堆难题：锁怎么正确获取和释放？如何避免锁的误释放、死锁等问题？别担心，今天咱们就来好好聊聊这些事儿！

在如今互联网应用高并发的大背景下，分布式系统已经成为主流架构。当多个服务实例同时访问共享资源时，就需要分布式锁来协调访问顺序，保证数据的准确性。Spring Boot 凭借其快速开发、高度集成的特性，深受后端开发者喜爱；Redis 则以其高性能、丰富的数据结构和原子操作能力，成为实现分布式锁的热门选择。二者结合，能为高并发场景下的资源访问控制提供强大的解决方案。但在实际设计和使用分布式锁的过程中，却隐藏着诸多需要考虑的问题。

设计分布式锁需要考虑的问题

单点故障

如果 Redis 是单节点部署，一旦这个节点宕机，那么分布式锁就无法正常使用，整个依赖分布式锁的业务流程都会受到影响，导致服务不可用。

锁误释放

在高并发场景下，可能会出现 A 客户端获取了锁，还未执行完业务逻辑，锁就被 B 客户端误释放的情况。比如，A 客户端设置的锁过期时间到了，此时 B 客户端获取到了锁，而 A 客户端后续操作完成后，在不知情的情况下释放了锁，导致 B 客户端的锁提前被释放。

锁的唯一性

在分布式系统中，多个服务实例可能会同时尝试获取锁，必须保证每个锁的唯一性，否则不同业务场景下可能会出现锁的混淆和错误使用，影响业务逻辑的正常执行。

合理设置过期时间

过期时间设置过短，可能会导致业务还未执行完，锁就被释放，出现多个实例同时访问共享资源的情况；过期时间设置过长，又会导致资源长时间被占用，其他实例无法获取锁，降低系统的并发性能。

避免死锁

如果在获取锁或释放锁的过程中出现异常，没有正确释放锁，就会导致死锁。例如，获取锁后，服务器突然宕机，锁无法正常释放，其他实例永远无法获取到该锁。

锁续期

对于一些长时间运行的任务，如果不进行锁续期，锁可能会在任务执行过程中过期释放，导致任务执行出现问题。

如何解决这些问题

解决单点故障

采用 Redis 集群（如 Redis Cluster）或主从复制架构。Redis Cluster 通过将数据分片存储在多个节点上，实现高可用性和扩展性；主从复制则可以在主节点宕机时，通过手动或自动故障转移，让从节点升级为主节点，保证服务的可用性，从而避免因单点故障导致分布式锁无法使用。

防止锁误释放

在获取锁时，为每个锁设置一个唯一的客户端 ID（例如使用 UUID）作为锁的 value。在释放锁时，通过 Lua 脚本判断当前锁的 value 是否与自己的客户端 ID 一致，只有一致时才允许释放锁。这样就能确保只有持有锁的客户端才能释放锁，避免锁被其他客户端误释放。

保证锁的唯一性

在生成锁的 key 时，结合业务场景和资源标识，确保每个锁的 key 都是唯一的。例如，对于某个订单处理业务，锁的 key 可以设计为 “order:lock:{orderId}”，其中 {orderId} 是具体的订单编号，这样就能保证不同订单的锁相互独立，不会混淆。

合理设置过期时间

根据业务执行的平均时间，结合一定的缓冲时间来设置过期时间。可以通过性能测试和监控，统计业务操作的耗时分布，然后在此基础上增加一定的安全时间，作为锁的过期时间。同时，也可以考虑使用 Redis 的可续约机制，在任务执行过程中，定期检查任务是否还在执行，如果还在执行，就延长锁的过期时间。

避免死锁

在加锁和解锁的代码逻辑中，使用 try - finally 块，确保无论是否出现异常，锁都能被正确释放。例如，在获取锁后，如果发生异常，在 finally 块中执行释放锁的操作。同时，也可以设置锁的最大持有时间，当超过这个时间后，自动释放锁，避免死锁的发生。

实现锁续期

可以使用 Redis 的发布 / 订阅功能，在获取锁时，启动一个守护线程，定期向 Redis 发送续约请求。当业务执行完成后，停止守护线程，不再续约。另外，也可以使用 Redis 的 setex 命令（设置键值对并指定过期时间），在任务执行过程中，通过原子操作更新锁的过期时间，实现锁的续期。

在 Spring Boot 中结合 Redis 实现自定义分布式锁的具体步骤

添加依赖

在 Spring Boot 项目的 pom.xml 文件中，添加 Spring Data Redis 依赖：

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

配置 Redis 连接

在 application.yml 文件中，配置 Redis 的连接信息，例如：

	spring:
  redis:
    host: localhost
    port: 6379
    password: 
    database: 0

创建 Redis 配置类

创建一个 Redis 配置类，用于配置 Redis 连接工厂等相关信息：

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.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        // 设置key的序列化方式
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 设置value的序列化方式
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        return redisTemplate;
    }
}

创建 RedisLock 类

创建一个 RedisLock 类，用于实现获取锁和释放锁的逻辑：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

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

@Component
public class RedisLock {

    private static final String LOCK_SUCCESS = "OK";
    private static final String SET_IF_NOT_EXIST = "NX";
    private static final String SET_WITH_EXPIRE_TIME = "EX";
    private static final String RELEASE_SUCCESS = "1";
    private static final String RELEASE_LUA;

    static {
        StringBuilder sb = new StringBuilder();
        sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
        sb.append("then ");
        sb.append("    return redis.call(\"del\",KEYS[1]) ");
        sb.append("else ");
        sb.append("    return 0 ");
        sb.append("end ");
        RELEASE_LUA = sb.toString();
    }

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private String clientId;

    public RedisLock() {
        this.clientId = UUID.randomUUID().toString();
    }

    // 获取锁
    public boolean tryLock(String key, long timeout, TimeUnit unit) {
        String result = redisTemplate.opsForValue().set(key, clientId, timeout, unit, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME);
        return LOCK_SUCCESS.equals(result);
    }

    // 释放锁
    public boolean releaseLock(String key) {
        Object result = redisTemplate.execute(
                (connection) -> connection.eval(
                        RELEASE_LUA.getBytes(),
                        org.springframework.data.redis.connection.RedisStringCommands.LuaScript.KEEP_SCRIPT,
                        1,
                        key.getBytes(),
                        clientId.getBytes()
                )
        );
        return RELEASE_SUCCESS.equals(result);
    }
}

使用 RedisLock

在业务代码中，使用 RedisLock 来获取锁和释放锁：

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

@RestController
public class TestController {

    @Autowired
    private RedisLock redisLock;

    private static final String LOCK_KEY = "test_lock";

    @GetMapping("/test")
    public String test() {
        boolean locked = redisLock.tryLock(LOCK_KEY, 10, TimeUnit.SECONDS);
        if (locked) {
            try {
                // 执行业务逻辑
                Thread.sleep(5000);
                return "业务逻辑执行完成，锁已释放";
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                redisLock.releaseLock(LOCK_KEY);
            }
        } else {
            return "获取锁失败，请稍后重试";
        }
        return "操作异常";
    }
}

总结

以上就是在 Spring Boot 中结合 Redis 实现自定义分布式锁，以及解决设计分布式锁过程中常见问题的详细内容。希望这篇文章能帮助你在后端开发工作中，更好地运用分布式锁，提升系统的稳定性和并发性能。如果你在实际操作过程中还有其他问题，欢迎在评论区留言讨论，也别忘了点赞、分享给其他有需要的小伙伴！