【Redis分布式锁实现】基于 Redis 单节点保姆级教程（Spring Boot 示例）

下面我将详细介绍基于 Redis 单节点实现分布式锁的原理，并提供一个完整的 Spring Boot 实现示例。

实现原理

核心机制

1. 原子获取锁

   ：使用 SET key unique_value NX PX milliseconds 命令
   • NX：仅当 key 不存在时设置值
   • PX：设置过期时间（毫秒）
   • unique_value：唯一标识客户端（防止误删其他客户端的锁）

2. 安全释放锁

   ：使用 Lua 脚本保证原子性

   if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end 

3. 锁续期机制

   ：可选的看门狗（Watchdog）机制，定期延长锁的有效期

关键特性

• 互斥性

  ：同一时刻只有一个客户端能持有锁

• 防死锁

  ：自动过期机制确保锁最终释放

• 容错性

  ：客户端崩溃后锁会自动释放

• 安全性

  ：只有锁的持有者才能释放锁

Spring Boot 实现示例

1. 添加依赖 (pom.xml)

<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> </dependency> </dependencies> 

2. 配置 Redis (application.yml)

spring: redis: host: localhost port: 6379 password: lettuce: pool: max-active: 8 max-idle: 8 min-idle: 0 max-wait: -1ms 

3. Redis 分布式锁工具类

import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.core.script.DefaultRedisScript; import org.springframework.data.redis.core.script.RedisScript; import org.springframework.stereotype.Component; import java.util.Collections; import java.util.UUID; import java.util.concurrent.TimeUnit; @Component public class RedisDistributedLock { private final RedisTemplate<String, String> redisTemplate; // 锁键前缀 private static final String LOCK_PREFIX = "lock:"; // 解锁Lua脚本 private static final String UNLOCK_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then " + " return redis.call('del', KEYS[1]) " + "else " + " return 0 " + "end"; // 续期Lua脚本 private static final String RENEW_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then " + " return redis.call('pexpire', KEYS[1], ARGV[2]) " + "else " + " return 0 " + "end"; public RedisDistributedLock(RedisTemplate<String, String> redisTemplate) { this.redisTemplate = redisTemplate; } /** * 尝试获取分布式锁 * * @param lockKey 锁的key * @param requestId 请求标识（可使用UUID） * @param expireTime 锁的过期时间(毫秒) * @param waitTime 等待时间(毫秒) * @return 是否获取成功 */ public boolean tryLock(String lockKey, String requestId, long expireTime, long waitTime) { String fullKey = LOCK_PREFIX + lockKey; long end = System.currentTimeMillis() + waitTime; while (System.currentTimeMillis() < end) { // 尝试获取锁 Boolean success = redisTemplate.opsForValue() .setIfAbsent(fullKey, requestId, expireTime, TimeUnit.MILLISECONDS); if (Boolean.TRUE.equals(success)) { return true; } // 等待随机时间后重试，避免活锁 try { Thread.sleep(50 + (long) (Math.random() * 100)); } catch (InterruptedException e) { Thread.currentThread().interrupt(); return false; } } return false; } /** * 释放分布式锁 * * @param lockKey 锁的key * @param requestId 请求标识 * @return 是否释放成功 */ public boolean unlock(String lockKey, String requestId) { String fullKey = LOCK_PREFIX + lockKey; // 使用Lua脚本保证原子性 RedisScript<Long> script = new DefaultRedisScript<>(UNLOCK_SCRIPT, Long.class); Long result = redisTemplate.execute(script, Collections.singletonList(fullKey), requestId); return result != null && result == 1; } /** * 锁续期（看门狗机制） * * @param lockKey 锁的key * @param requestId 请求标识 * @param expireTime 新的过期时间(毫秒) * @return 是否续期成功 */ public boolean renewLock(String lockKey, String requestId, long expireTime) { String fullKey = LOCK_PREFIX + lockKey; // 使用Lua脚本保证原子性 RedisScript<Long> script = new DefaultRedisScript<>(RENEW_SCRIPT, Long.class); Long result = redisTemplate.execute(script, Collections.singletonList(fullKey), requestId, String.valueOf(expireTime)); return result != null && result == 1; } /** * 获取锁（简化版，带自动续期） * * @param lockKey 锁的key * @param expireTime 锁的过期时间(毫秒) * @param waitTime 等待时间(毫秒) * @param task 需要执行的任务 * @return 任务执行结果 */ public <T> T lockAndExecute(String lockKey, long expireTime, long waitTime, LockTask<T> task) { String requestId = UUID.randomUUID().toString(); boolean locked = false; try { // 尝试获取锁 locked = tryLock(lockKey, requestId, expireTime, waitTime); if (!locked) { throw new RuntimeException("获取分布式锁失败"); } // 启动看门狗线程定期续期 WatchDog watchDog = new WatchDog(lockKey, requestId, expireTime); watchDog.start(); try { // 执行业务逻辑 return task.execute(); } finally { // 停止看门狗 watchDog.stop(); } } finally { // 确保锁被释放 if (locked) { unlock(lockKey, requestId); } } } // 看门狗线程实现 private class WatchDog { private final String lockKey; private final String requestId; private final long expireTime; private volatile boolean running = true; private Thread thread; public WatchDog(String lockKey, String requestId, long expireTime) { this.lockKey = lockKey; this.requestId = requestId; this.expireTime = expireTime; } public void start() { thread = new Thread(() -> { // 在过期时间的1/3时进行续期 long sleepTime = expireTime / 3; while (running) { try { Thread.sleep(sleepTime); if (!renewLock(lockKey, requestId, expireTime)) { // 续期失败，可能是锁已被释放或过期 break; } } catch (InterruptedException e) { Thread.currentThread().interrupt(); break; } } }, "RedisLock-WatchDog"); thread.setDaemon(true); thread.start(); } public void stop() { running = false; if (thread != null) { thread.interrupt(); } } } // 锁任务接口 @FunctionalInterface public interface LockTask<T> { T execute(); } } 

4. 业务服务中使用分布式锁

import org.springframework.stereotype.Service; @Service public class OrderService { private final RedisDistributedLock redisLock; public OrderService(RedisDistributedLock redisLock) { this.redisLock = redisLock; } /** * 创建订单（使用分布式锁保护） */ public void createOrder(String orderId) { // 使用锁执行关键操作 redisLock.lockAndExecute("order_create:" + orderId, 30000, 5000, () -> { // 在这里执行需要加锁的业务逻辑 try { // 1. 检查订单是否已存在 if (checkOrderExists(orderId)) { throw new RuntimeException("订单已存在"); } // 2. 执行创建订单的核心业务 processOrderCreation(orderId); // 3. 记录订单日志 logOrderCreation(orderId); return null; } catch (Exception e) { throw new RuntimeException("订单创建失败", e); } }); } private boolean checkOrderExists(String orderId) { // 实际业务逻辑 return false; } private void processOrderCreation(String orderId) { // 实际业务逻辑 System.out.println("处理订单创建: " + orderId); // 模拟耗时操作 try { Thread.sleep(1000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } private void logOrderCreation(String orderId) { // 实际业务逻辑 System.out.println("记录订单日志: " + orderId); } } 

5. 控制器示例

import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; @RestController public class OrderController { private final OrderService orderService; public OrderController(OrderService orderService) { this.orderService = orderService; } @GetMapping("/order/{orderId}") public String createOrder(@PathVariable String orderId) { try { orderService.createOrder(orderId); return "订单创建成功: " + orderId; } catch (Exception e) { return "订单创建失败: " + e.getMessage(); } } } 

关键注意事项

1. 锁过期时间

   ：
   • 设置合理的时间（略大于业务执行时间）
   • 过短：业务未完成锁已释放 → 数据不一致
   • 过长：客户端崩溃后锁释放延迟 → 系统可用性降低

2. 唯一标识（requestId）

   ：
   • 必须保证全局唯一（使用UUID）
   • 确保只有锁的持有者才能释放锁

3. 看门狗机制

   ：
   • 解决业务执行时间超过锁过期时间的问题
   • 定期续期（建议在1/3过期时间时续期）
   • 业务完成后立即停止看门狗

4. 异常处理

   ：
   • 使用try-finally确保锁最终被释放
   • 避免因异常导致锁无法释放

5. 重试机制

   ：
   • 设置合理的等待时间和重试策略
   • 使用随机退避避免活锁

潜在缺陷及解决方案

最佳实践建议

1. 锁粒度

   ：尽量使用细粒度锁（如订单ID而非整个系统锁）

2. 超时设置

   ：根据业务压力动态调整锁超时时间

3. 监控报警

   ：监控锁等待时间、获取失败率等关键指标

4. 熔断机制

   ：当Redis不可用时提供降级方案

5. 压力测试

   ：模拟高并发场景验证锁的正确性

6. 避免长时间持锁

   ：优化业务逻辑减少锁持有时间

这个实现提供了生产环境中使用Redis分布式锁的完整解决方案，包含了基本的锁获取/释放、看门狗续期机制、以及易用的API封装。在实际使用中，可以根据具体业务需求调整参数和实现细节。