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

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

核心机制

• 原子获取锁：使用 SET key unique_value NX PX milliseconds 命令
  
  
  
  • NX：仅当 key 不存在时设置值
    
  • PX：设置过期时间（毫秒）
    
  • unique_value：唯一标识客户端（防止误删其他客户端的锁）
    
  
  
• 安全释放锁：使用 Lua 脚本保证原子性
  1. if redis.call("get", KEYS[1]) == ARGV[1] then
  2.     return redis.call("del", KEYS[1])
  3. else
  4.     return 0
  5. end

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

关键特性

• 互斥性：同一时刻只有一个客户端能持有锁
  
• 防死锁：自动过期机制确保锁最终释放
  
• 容错性：客户端崩溃后锁会自动释放
  
• 安全性：只有锁的持有者才能释放锁
  

Spring Boot 实现示例

1. 添加依赖 (pom.xml)

1. <dependencies>
2.     <dependency>
3.         <groupId>org.springframework.boot</groupId>
4.         spring-boot-starter-data-redis</artifactId>
5.     </dependency>
6.     <dependency>
7.         <groupId>org.apache.commons</groupId>
8.         commons-pool2</artifactId>
9.     </dependency>
10. </dependencies>

复制代码

2. 配置 Redis (application.yml)

1. spring:
2.   redis:
3.     host: localhost
4.     port: 6379
5.     password:
6.     lettuce:
7.       pool:
8.         max-active: 8
9.         max-idle: 8
10.         min-idle: 0
11.         max-wait: -1ms

复制代码

3. Redis 分布式锁工具类

1. import org.springframework.data.redis.core.RedisTemplate;
2. import org.springframework.data.redis.core.script.DefaultRedisScript;
3. import org.springframework.data.redis.core.script.RedisScript;
4. import org.springframework.stereotype.Component;
6. import java.util.Collections;
7. import java.util.UUID;
8. import java.util.concurrent.TimeUnit;
10. @Component
11. public class RedisDistributedLock {
13.     private final RedisTemplate<String, String> redisTemplate;
14.    
15.     // 锁键前缀
16.     private static final String LOCK_PREFIX = "lock:";
17.     // 解锁Lua脚本
18.     private static final String UNLOCK_SCRIPT =
19.         "if redis.call('get', KEYS[1]) == ARGV[1] then " +
20.         "   return redis.call('del', KEYS[1]) " +
21.         "else " +
22.         "   return 0 " +
23.         "end";
24.     // 续期Lua脚本
25.     private static final String RENEW_SCRIPT =
26.         "if redis.call('get', KEYS[1]) == ARGV[1] then " +
27.         "   return redis.call('pexpire', KEYS[1], ARGV[2]) " +
28.         "else " +
29.         "   return 0 " +
30.         "end";
32.     public RedisDistributedLock(RedisTemplate<String, String> redisTemplate) {
33.         this.redisTemplate = redisTemplate;
34.     }
36.     /**
37.      * 尝试获取分布式锁
38.      *
39.      * @param lockKey    锁的key
40.      * @param requestId  请求标识（可使用UUID）
41.      * @param expireTime 锁的过期时间(毫秒)
42.      * @param waitTime   等待时间(毫秒)
43.      * @return 是否获取成功
44.      */
45.     public boolean tryLock(String lockKey, String requestId, long expireTime, long waitTime) {
46.         String fullKey = LOCK_PREFIX + lockKey;
47.         long end = System.currentTimeMillis() + waitTime;
48.         
49.         while (System.currentTimeMillis() < end) {
50.             // 尝试获取锁
51.             Boolean success = redisTemplate.opsForValue()
52.                 .setIfAbsent(fullKey, requestId, expireTime, TimeUnit.MILLISECONDS);
53.             
54.             if (Boolean.TRUE.equals(success)) {
55.                 return true;
56.             }
57.             
58.             // 等待随机时间后重试，避免活锁
59.             try {
60.                 Thread.sleep(50 + (long) (Math.random() * 100));
61.             } catch (InterruptedException e) {
62.                 Thread.currentThread().interrupt();
63.                 return false;
64.             }
65.         }
66.         return false;
67.     }
69.     /**
70.      * 释放分布式锁
71.      *
72.      * @param lockKey   锁的key
73.      * @param requestId 请求标识
74.      * @return 是否释放成功
75.      */
76.     public boolean unlock(String lockKey, String requestId) {
77.         String fullKey = LOCK_PREFIX + lockKey;
78.         
79.         // 使用Lua脚本保证原子性
80.         RedisScript<Long> script = new DefaultRedisScript<>(UNLOCK_SCRIPT, Long.class);
81.         Long result = redisTemplate.execute(script, Collections.singletonList(fullKey), requestId);
82.         
83.         return result != null && result == 1;
84.     }
86.     /**
87.      * 锁续期（看门狗机制）
88.      *
89.      * @param lockKey    锁的key
90.      * @param requestId  请求标识
91.      * @param expireTime 新的过期时间(毫秒)
92.      * @return 是否续期成功
93.      */
94.     public boolean renewLock(String lockKey, String requestId, long expireTime) {
95.         String fullKey = LOCK_PREFIX + lockKey;
96.         
97.         // 使用Lua脚本保证原子性
98.         RedisScript<Long> script = new DefaultRedisScript<>(RENEW_SCRIPT, Long.class);
99.         Long result = redisTemplate.execute(script,
100.             Collections.singletonList(fullKey),
101.             requestId,
102.             String.valueOf(expireTime));
103.         
104.         return result != null && result == 1;
105.     }
107.     /**
108.      * 获取锁（简化版，带自动续期）
109.      *
110.      * @param lockKey    锁的key
111.      * @param expireTime 锁的过期时间(毫秒)
112.      * @param waitTime   等待时间(毫秒)
113.      * @param task       需要执行的任务
114.      * @return 任务执行结果
115.      */
116.     public <T> T lockAndExecute(String lockKey, long expireTime, long waitTime, LockTask<T> task) {
117.         String requestId = UUID.randomUUID().toString();
118.         boolean locked = false;
119.         
120.         try {
121.             // 尝试获取锁
122.             locked = tryLock(lockKey, requestId, expireTime, waitTime);
123.             
124.             if (!locked) {
125.                 throw new RuntimeException("获取分布式锁失败");
126.             }
127.             
128.             // 启动看门狗线程定期续期
129.             WatchDog watchDog = new WatchDog(lockKey, requestId, expireTime);
130.             watchDog.start();
131.             
132.             try {
133.                 // 执行业务逻辑
134.                 return task.execute();
135.             } finally {
136.                 // 停止看门狗
137.                 watchDog.stop();
138.             }
139.         } finally {
140.             // 确保锁被释放
141.             if (locked) {
142.                 unlock(lockKey, requestId);
143.             }
144.         }
145.     }
147.     // 看门狗线程实现
148.     private class WatchDog {
149.         private final String lockKey;
150.         private final String requestId;
151.         private final long expireTime;
152.         private volatile boolean running = true;
153.         private Thread thread;
155.         public WatchDog(String lockKey, String requestId, long expireTime) {
156.             this.lockKey = lockKey;
157.             this.requestId = requestId;
158.             this.expireTime = expireTime;
159.         }
161.         public void start() {
162.             thread = new Thread(() -> {
163.                 // 在过期时间的1/3时进行续期
164.                 long sleepTime = expireTime / 3;
165.                
166.                 while (running) {
167.                     try {
168.                         Thread.sleep(sleepTime);
169.                         if (!renewLock(lockKey, requestId, expireTime)) {
170.                             // 续期失败，可能是锁已被释放或过期
171.                             break;
172.                         }
173.                     } catch (InterruptedException e) {
174.                         Thread.currentThread().interrupt();
175.                         break;
176.                     }
177.                 }
178.             }, "RedisLock-WatchDog");
179.             thread.setDaemon(true);
180.             thread.start();
181.         }
183.         public void stop() {
184.             running = false;
185.             if (thread != null) {
186.                 thread.interrupt();
187.             }
188.         }
189.     }
191.     // 锁任务接口
192.     @FunctionalInterface
193.     public interface LockTask<T> {
194.         T execute();
195.     }
196. }

复制代码

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

1. import org.springframework.stereotype.Service;
3. @Service
4. public class OrderService {
6.     private final RedisDistributedLock redisLock;
7.    
8.     public OrderService(RedisDistributedLock redisLock) {
9.         this.redisLock = redisLock;
10.     }
11.    
12.     /**
13.      * 创建订单（使用分布式锁保护）
14.      */
15.     public void createOrder(String orderId) {
16.         // 使用锁执行关键操作
17.         redisLock.lockAndExecute("order_create:" + orderId, 30000, 5000, () -> {
18.             // 在这里执行需要加锁的业务逻辑
19.             try {
20.                 // 1. 检查订单是否已存在
21.                 if (checkOrderExists(orderId)) {
22.                     throw new RuntimeException("订单已存在");
23.                 }
24.                
25.                 // 2. 执行创建订单的核心业务
26.                 processOrderCreation(orderId);
27.                
28.                 // 3. 记录订单日志
29.                 logOrderCreation(orderId);
30.                
31.                 return null;
32.             } catch (Exception e) {
33.                 throw new RuntimeException("订单创建失败", e);
34.             }
35.         });
36.     }
37.    
38.     private boolean checkOrderExists(String orderId) {
39.         // 实际业务逻辑
40.         return false;
41.     }
42.    
43.     private void processOrderCreation(String orderId) {
44.         // 实际业务逻辑
45.         System.out.println("处理订单创建: " + orderId);
46.         // 模拟耗时操作
47.         try {
48.             Thread.sleep(1000);
49.         } catch (InterruptedException e) {
50.             Thread.currentThread().interrupt();
51.         }
52.     }
53.    
54.     private void logOrderCreation(String orderId) {
55.         // 实际业务逻辑
56.         System.out.println("记录订单日志: " + orderId);
57.     }
58. }

复制代码

5. 控制器示例

1. import org.springframework.web.bind.annotation.GetMapping;
2. import org.springframework.web.bind.annotation.PathVariable;
3. import org.springframework.web.bind.annotation.RestController;
5. @RestController
6. public class OrderController {
8.     private final OrderService orderService;
10.     public OrderController(OrderService orderService) {
11.         this.orderService = orderService;
12.     }
14.     @GetMapping("/order/{orderId}")
15.     public String createOrder(@PathVariable String orderId) {
16.         try {
17.             orderService.createOrder(orderId);
18.             return "订单创建成功: " + orderId;
19.         } catch (Exception e) {
20.             return "订单创建失败: " + e.getMessage();
21.         }
22.     }
23. }

复制代码

关键注意事项

• 锁过期时间：
  
  
  
  • 设置合理的时间（略大于业务执行时间）
    
  • 过短：业务未完成锁已释放 → 数据不一致
    
  • 过长：客户端崩溃后锁释放延迟 → 系统可用性降低
    
  
  
• 唯一标识（requestId）：
  
  
  
  • 必须保证全局唯一（使用UUID）
    
  • 确保只有锁的持有者才能释放锁
    
  
  
• 看门狗机制：
  
  
  
  • 解决业务执行时间超过锁过期时间的问题
    
  • 定期续期（建议在1/3过期时间时续期）
    
  • 业务完成后立即停止看门狗
    
  
  
• 异常处理：
  
  
  
  • 使用try-finally确保锁最终被释放
    
  • 避免因异常导致锁无法释放
    
  
  
• 重试机制：
  
  
  
  • 设置合理的等待时间和重试策略
    
  • 使用随机退避避免活锁
    
  
  

潜在缺陷及解决方案

缺陷解决方案锁提前过期实现看门狗续期机制非原子操作风险使用Lua脚本保证原子性单点故障主从复制（但有数据丢失风险）或改用RedLockGC暂停导致锁失效优化JVM参数，减少GC暂停时间时钟漂移问题使用NTP同步时间，监控时钟差异锁被误删使用唯一标识验证锁持有者最佳实践建议

• 锁粒度：尽量使用细粒度锁（如订单ID而非整个系统锁）
  
• 超时设置：根据业务压力动态调整锁超时时间
  
• 监控报警：监控锁等待时间、获取失败率等关键指标
  
• 熔断机制：当Redis不可用时提供降级方案
  
• 压力测试：模拟高并发场景验证锁的正确性
  
• 避免长时间持锁：优化业务逻辑减少锁持有时间
  

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

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！