SpringBoot项目中实现Redis分布式锁的方法与最佳实践
作者：IT橘子皮
在 Spring Boot 项目中实现 Redis 分布式锁,主要有手动实现和使用 Redisson 两种主流方式,下面我来为你详细解释这两种方式的原理、实现方法和最佳实践,需要的朋友可以参考下
引言
在 Spring Boot 项目中实现 Redis 分布式锁，主要有手动实现和使用 Redisson 两种主流方式。下面我来为你详细解释这两种方式的原理、实现方法和最佳实践。
| 特性维度 | 手动实现 (RedisTemplate) | Redisson (推荐) |
|---|---|---|
| 实现复杂度 | 较高，需处理所有细节 | 低，开箱即用，API 简洁 |
| 可重入性 | 需自行实现 | 原生支持 |
| 锁续期(Watchdog) | 需自行实现 | 原生支持 |
| 超时与等待 | 需自行实现 | 原生支持多种加锁策略 |
| 公平锁/读写锁 | 不支持 | 支持 |
| 集群支持(RedLock) | 实现复杂 | 原生支持 |
| 可靠性 | 一般，需自行规避各种边界问题 | 高，久经考验 |
手动实现基于 RedisTemplate
这种方式让你更接近底层原理，但需要自己处理锁续期、可重入等复杂问题。
添加依赖
在 pom.xml中添加 Spring Data Redis 依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
配置 Redis 连接
在 application.yml中配置：
spring:
redis:
host: localhost
port: 6379
# password: yourpassword # 如果设置了密码
分布式锁工具类
核心是使用 SET key value NX EX seconds命令原子性地获取锁，并用 Lua 脚本保证释放锁的原子性（判断值再删除）。
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 脚本：释放锁时，判断值和删除必须是原子操作，否则可能误删其他客户端的锁。
在业务中使用
@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 客户端，它提供了直接可用的分布式锁实现，解决了手动实现的所有痛点，如可重入锁、锁续期、等待机制等。
添加依赖
在 pom.xml中添加 Redisson 依赖：
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.27.0</version> <!-- 请使用最新稳定版本 -->
</dependency>
基本配置 (application.yml)
spring:
redis:
host: localhost
port: 6379
# Redisson 通常会自动使用Spring Redis的配置
使用 Redisson 的 RLock
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）、读写锁等。
注意事项与最佳实践
锁的粒度：锁的 Key 要精确，例如 "order:123"比 "order"更好，减少竞争，提升并发度。
超时时间：手动实现时，过期时间不宜过短或过长。过短可能导致业务未完成锁就释放；过长则故障恢复慢。Redisson 的看门狗机制能很好地解决这个问题。
务必释放锁：释放锁必须放在 finally代码块中执行，确保即使业务异常也能释放锁。
Redis 模式：
- 单机/主从模式：上述方法适用，但主从异步复制下，主节点宕机可能导致锁失效（从节点可能无锁数据）。
- 红锁 (RedLock)：为解决上述问题，可在多个独立的 Redis 主节点上尝试获取锁，超过半数成功才算真正获取。Redisson 提供了红锁实现，但更复杂，通常用于对一致性要求极高的场景。
总结
对于大多数 Spring Boot 项目，我强烈推荐直接使用 Redisson。它功能完善、久经考验，能让你远离分布式锁的各种复杂细节，更专注于业务逻辑开发。如果你是为了学习底层原理或实现一个非常简单的锁，那么可以尝试手动实现的方式。
以上就是SpringBoot项目中实现Redis分布式锁的方法与最佳实践的详细内容，更多关于SpringBoot实现Redis分布式锁的资料请关注脚本之家其它相关文章！