Spring Boot项目中如何实现Redis分布式锁

间彧2025-09-19 15:22

在 Spring Boot 项目中实现 Redis 分布式锁，主要有手动实现和使用 ​Redisson​ 两种主流方式。下面我来为你详细解释这两种方式的原理、实现方法和最佳实践。

特性维度 手动实现 (RedisTemplate) Redisson (推荐)
​实现复杂度​ 较高，需处理所有细节 低，开箱即用，API 简洁
​可重入性​ 需自行实现 ​原生支持​
​锁续期(Watchdog)​​ 需自行实现 ​原生支持​
​超时与等待​ 需自行实现 ​原生支持多种加锁策略
​公平锁/读写锁​ 不支持 ​支持​
​集群支持(RedLock)​​ 实现复杂 ​原生支持​
​可靠性​ 一般，需自行规避各种边界问题 ​高，久经考验

⚙️ 手动实现基于 RedisTemplate

这种方式让你更接近底层原理，但需要自己处理锁续期、可重入等复杂问题。

  1. ​添加依赖​

    在 pom.xml中添加 Spring Data Redis 依赖：

    xml 复制代码 
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

  2. ​配置 Redis 连接​

    在 application.yml中配置：

    yaml 复制代码 
    spring:
  redis:
    host: localhost
    port: 6379
    # password: yourpassword # 如果设置了密码

  3. ​分布式锁工具类​

    核心是使用 SET key value NX EX seconds命令原子性地获取锁，并用 Lua 脚本保证释放锁的原子性（判断值再删除）。

    java 复制代码 
    import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.concurrent.TimeUnit;

@Component
public class RedisDistributedLock {

    @Autowired
    private StringRedisTemplate redisTemplate;

    private static final String LOCK_PREFIX = "lock:";

    /**
     * 尝试获取分布式锁
     * @param lockKey 锁的业务Key，如 "order:123"
     * @param requestId 请求标识（可用UUID），用于安全释放锁
     * @param expireTime 锁的过期时间(毫秒)
     * @param waitTime 获取锁的最大等待时间(毫秒)
     * @return 是否获取成功
     */
    public boolean tryLock(String lockKey, String requestId, long expireTime, long waitTime) throws InterruptedException {
        String fullKey = LOCK_PREFIX + lockKey;
        long end = System.currentTimeMillis() + waitTime;

        while (System.currentTimeMillis() < end) { // 在等待时间内循环尝试
            // 使用 SET NX EX 命令原子性地尝试获取锁
            Boolean success = redisTemplate.opsForValue()
                    .setIfAbsent(fullKey, requestId, expireTime, TimeUnit.MILLISECONDS);
            if (Boolean.TRUE.equals(success)) {
                return true; // 获取锁成功
            }
            Thread.sleep(50); // 短暂休眠，避免活锁和CPU空转
        }
        return false; // 超时仍未获取到锁
    }

    /**
     * 释放分布式锁 (使用Lua脚本保证原子性)
     * @param lockKey 锁的业务Key
     * @param requestId 请求标识，必须与加锁时一致
     * @return 是否释放成功
     */
    public boolean unlock(String lockKey, String requestId) {
        String fullKey = LOCK_PREFIX + lockKey;
        // Lua脚本：如果键存在且值与预期相符，则删除它
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);
        Long result = redisTemplate.execute(redisScript, Collections.singletonList(fullKey), requestId);
        return result != null && result == 1;
    }
}

    ​关键点：​​

    • NX (Not eXists)​：确保只有锁不存在时才能设置成功，实现互斥。
    • EX (Expire)​ ：设置过期时间，这是防止死锁的关键。即使客户端崩溃，锁也会自动释放。
    • 唯一值 (requestId)​ ：使用唯一值（如UUID）标识锁的持有者，确保只能由加锁的客户端来解锁，防止误释锁。
    • Lua 脚本：释放锁时，判断值和删除必须是原子操作，否则可能误删其他客户端的锁。

  4. ​在业务中使用​

    typescript 复制代码 
    @Service
public class OrderService {
    @Autowired
    private RedisDistributedLock redisLock;

    public void createOrder(String orderId) {
        String lockKey = "order_create:" + orderId;
        String requestId = UUID.randomUUID().toString(); // 生成唯一请求ID

        boolean locked = false;
        try {
            // 尝试获取锁，等待5秒，锁过期时间10秒
            locked = redisLock.tryLock(lockKey, requestId, 10000, 5000);
            if (locked) {
                // 成功获取锁，执行核心业务逻辑
                System.out.println("成功获取锁，执行订单创建逻辑...");
                // ... (你的业务代码)
            } else {
                // 获取锁失败，处理异常或重试
                throw new RuntimeException("系统繁忙，请稍后再试");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("获取锁被中断", e);
        } finally {
            // 释放锁，务必放在finally块中确保执行
            if (locked) {
                redisLock.unlock(lockKey, requestId);
            }
        }
    }
}

🚀 使用 Redisson（推荐）

Redisson 是一个强大的 Redis Java 客户端，它提供了直接可用的分布式锁实现，解决了手动实现的所有痛点，如可重入锁、锁续期、等待机制等。

  1. ​添加依赖​

    在 pom.xml中添加 Redisson 依赖：

    xml 复制代码 
    <dependency>
    <groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.27.0</version> <!-- 请使用最新稳定版本 -->
</dependency>

  2. ​基本配置 (application.yml)​​

    yaml 复制代码 
    spring:
  redis:
    host: localhost
    port: 6379
# Redisson 通常会自动使用Spring Redis的配置

  3. ​使用 Redisson 的 RLock​

    java 复制代码 
    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 OrderServiceRedisson {

    @Autowired
    private RedissonClient redissonClient; // 直接注入RedissonClient

    public void createOrder(String orderId) {
        String lockKey = "order:lock:" + orderId;
        RLock lock = redissonClient.getLock(lockKey); // 获取RLock对象

        try {
            // 尝试加锁，最多等待5秒，锁持有时间10秒后自动解锁
            // boolean isLocked = lock.tryLock(5, 10, TimeUnit.SECONDS);

            // 更常用的方式是设置等待时间，但让看门狗自动续期（lockTime传入-1或使用无参lock()）
            boolean isLocked = lock.tryLock(5, TimeUnit.SECONDS);
            if (isLocked) {
                try {
                    // 成功获取锁，执行业务逻辑
                    System.out.println("Redisson锁获取成功，执行逻辑...");
                    // ... (你的业务逻辑，看门狗会为没有显式设置leaseTime的锁自动续期)
                } finally {
                    // 释放锁
                    if (lock.isHeldByCurrentThread()) {
                        lock.unlock();
                    }
                }
            } else {
                throw new RuntimeException("系统繁忙，请稍后再试");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("获取锁被中断", e);
        }
    }
}

    ​Redisson 核心优势：​​

    • 看门狗机制 (Watchdog)​ ：如果你没有显式指定 leaseTime（锁持有时间），Redisson 会启动一个看门狗线程，在业务执行期间自动定期续期锁，防止业务执行时间超时导致锁意外释放。这是手动实现非常容易忽略且难以正确实现的一点。
    • 可重入：同一个线程可以多次获取同一把锁。
    • 丰富的锁类型：支持可重入锁、公平锁、联锁、红锁（RedLock）、读写锁等。

⚠️ 注意事项与最佳实践

  1. ​锁的粒度 ​：锁的 Key 要精确，例如 "order:123"比 "order"更好，减少竞争，提升并发度。

  2. ​超时时间​：手动实现时，过期时间不宜过短或过长。过短可能导致业务未完成锁就释放；过长则故障恢复慢。Redisson 的看门狗机制能很好地解决这个问题。

  3. ​务必释放锁 ​：释放锁必须放在 finally代码块中执行，确保即使业务异常也能释放锁。

  4. ​Redis 模式​：

    • 单机/主从模式：上述方法适用，但主从异步复制下，主节点宕机可能导致锁失效（从节点可能无锁数据）。
    • 红锁 (RedLock)​：为解决上述问题，可在多个独立的 Redis 主节点上尝试获取锁，超过半数成功才算真正获取。Redisson 提供了红锁实现，但更复杂，通常用于对一致性要求极高的场景。

💎 总结

对于大多数 Spring Boot 项目，​我强烈推荐直接使用 Redisson。它功能完善、久经考验，能让你远离分布式锁的各种复杂细节，更专注于业务逻辑开发。如果你是为了学习底层原理或实现一个非常简单的锁，那么可以尝试手动实现的方式。

相关推荐
掘金安东尼2 小时前
AI 应用落地谈起 ,免费试用 Amazon Bedrock 的最佳时机
java·架构
杨杨杨大侠2 小时前
案例03-附件E-部署运维
java·docker·github
杨杨杨大侠2 小时前
案例03-附件B-映射器实现
java·开源·github
杨杨杨大侠2 小时前
案例03-附件A-订单实体设计
java·开源·github
杨杨杨大侠2 小时前
案例03-附件C-性能优化
java·开源·github
杨杨杨大侠2 小时前
案例03-附件D-监控系统
java·开源·github
华仔啊6 小时前
主线程存了用户信息，子线程居然拿不到？ThreadLocal 背锅
java·后端
间彧6 小时前
Spring Boot项目中，Redis 如何同时执行多条命令
java·redis
召摇7 小时前
如何避免写垃圾代码：Java篇
java·后端·代码规范
热门推荐
01UV 工具安装与国内镜像源配置指南02GitHub 镜像站点0346个Nano-banana 精选提示词，持续更新中04UV安装并设置国内源05保姆级教程：手把手教你用Dify实现完美多轮对话（附Chatflow和提示词）06Claude Code 平替：OpenAI发布 Codex CLI ，GPT-5 国内直接使用07Spec-Kit 使用指南08A股预测还能更准？开源大模型Kronos带你跑通预测+回测全流程09智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践10KGG转MP3工具|非KGM文件|解密音频