学习高可靠Redis分布式锁实现思路

一、分布式锁的必要性

在单体应用时代，我们使用ReentrantLock或synchronized就能解决线程安全问题。但当系统拆分为分布式架构后（目前大多数公司应该不会只是单体应用了），跨进程的共享资源竞争就成了必须要解决的问题。
分布式锁由此应运而生，但是必须解决三大核心问题：

• 竞态条件：多人操作共享资源，顺序不可控
  
• 锁失效：锁自动过期但业务未执行完，其他客户端抢占资源 / 加锁成功但未设置过期时间，服务宕机导致死锁
  
• 锁误删：客户端A释放了客户端B持有的锁。
  

二、核心实现解析（附源码）

2.1 原子性加锁

1. local lockKey = KEYS[1]              -- 锁的键名，如"order_lock_123"
2. local lockSecret = ARGV[1]           -- 锁的唯一标识（建议UUID）
3. local expireTime = tonumber(ARGV[2]) -- 过期时间（单位：秒）
5. -- 参数有效性校验
6. if not expireTime or expireTime <= 0 then
7.     return "0" -- 参数非法直接返回失败
8. end
10. -- 原子操作：SET lockKey lockSecret NX EX expireTime
11. local result = redis.call("set", lockKey, lockSecret, "NX", "EX", expireTime)
12. return result and "1" or "0" -- 成功返回"1"，失败返回"0"

复制代码

设计思路：

• 续期间隔=过期时间/3（如30s过期则10s续期）
  
• 异步线程池需单独配置
  
• 双重校验锁状态（内存标记+Redis实际值）
  

2.3 安全释放锁

1. local lockKey = KEYS[1]              -- 锁的键名
2. local lockSecret = ARGV[1]           -- 锁标识
3. local expireTime = tonumber(ARGV[2]) -- 新的过期时间
5. -- 参数校验
6. if not expireTime or expireTime <= 0 then
7.     return "0"
8. end
10. -- 获取当前锁的值
11. local storedSecret = redis.call("get", lockKey)
13. -- 续期逻辑
14. if storedSecret == lockSecret then
15.     -- 值匹配则延长过期时间
16.     local result = redis.call("expire", lockKey, expireTime)
17.     return result == 1 and "1" or "0" -- 续期成功返回"1"
18. else
19.     -- 锁不存在或值不匹配
20.     return "0"
21. end

复制代码

设计思路：

• 校验value避免误删其他线程的锁
  

三、源码

1. // 定时续约线程
2. watchdogExecutor.scheduleAtFixedRate(() -> {
3.     locks.entrySet().removeIf(entry -> entry.getValue().isCancelled());
4.     for (Entry<String, Lock> entry : locks.entrySet()) {
5.         if (!entry.getValue().isCancelled()) {
6.             String result = redisTemplate.execute(RENEWAL_SCRIPT,
7.                 Collections.singletonList(key),
8.                 lock.value, "30");
9.             if ("0".equals(result)) lock.cancel();
10.         }
11.     }
12. }, 0, 10, TimeUnit.SECONDS);

复制代码

四、如何使用

4.1 配置类

1. local lockKey = KEYS[1]       -- 锁的键名
2. local lockSecret = ARGV[1]    -- 要释放的锁标识
4. -- 获取当前锁的值
5. local storedSecret = redis.call("get", lockKey)
7. -- 校验锁归属
8. if storedSecret == lockSecret then
9.     -- 值匹配则删除Key
10.     return redis.call("del", lockKey) == 1 and "1" or "0"
11. else
12.     -- 值不匹配
13.     return "0"
14. end

复制代码

4.2 使用

1. package org.example.tao.util;
3. import com.alibaba.fastjson2.JSON;
4. import org.springframework.data.redis.core.RedisTemplate;
5. import org.springframework.data.redis.core.script.RedisScript;
7. import javax.annotation.PreDestroy;
8. import java.util.Collections;
9. import java.util.Map;
10. import java.util.Objects;
11. import java.util.concurrent.ConcurrentHashMap;
12. import java.util.concurrent.Executors;
13. import java.util.concurrent.ScheduledExecutorService;
14. import java.util.concurrent.TimeUnit;
16. public class RedisUtils {
18.     static class Lock {
19.         private final String value;
20.         private volatile boolean isCancelled = false;
22.         public Lock(String value) {
23.             this.value = value;
24.         }
26.         public boolean isCancelled() {
27.             return isCancelled;
28.         }
30.         public void cancel() {
31.             isCancelled = true;
32.         }
33.     }
35.     private static final String LOCK_LUA = "local lockKey = KEYS[1]\n" + "local lockSecret = ARGV[1]\n" + "local expireTime = tonumber(ARGV[2])  -- 动态过期时间\n" + "if not expireTime or expireTime <= 0 then\n" + "    return "0"\n" + "end\n" + "local result = redis.call("set", lockKey, lockSecret, "NX", "EX", expireTime)\n" + "return result and "1" or "0"";
36.     private static final String RELEASE_LOCK_LUA = "local lockKey = KEYS[1]\n" + "local lockSecret = ARGV[1]\n" + "local storedSecret = redis.call("get", lockKey)\n" + "if storedSecret == lockSecret then\n" + "    return redis.call("del", lockKey) == 1 and "1" or "0"\n" + "else\n" + "    return "0"\n" + "end";
37.     private static final String RENEWAL_LUA = "local lockKey = KEYS[1]\n" + "local lockSecret = ARGV[1]\n" + "local expireTime = tonumber(ARGV[2])\n" + "if not expireTime or expireTime <= 0 then\n" + "    return "0"\n" + "end\n" + "local storedSecret = redis.call("get", lockKey)\n" + "if storedSecret == lockSecret then\n" + "    local result = redis.call("expire", lockKey, expireTime)\n" + "    return result == 1 and "1" or "0"\n" + "else\n" + "    return "0"\n" + "end";
39.     private final String defaultExpireTime = "30";
40.     private final RedisTemplate<String, String> redisTemplate;
41.     private final Map<String, Lock> locks = new ConcurrentHashMap<>();
42.     private final ScheduledExecutorService watchdogExecutor = Executors.newScheduledThreadPool(1);
44.     public RedisUtils(RedisTemplate<String, String> redisTemplate) {
45.         this.redisTemplate = redisTemplate;
46.         watchdogExecutor.scheduleAtFixedRate(() -> {
47.             try {
48.                 System.out.println("watchdogExecutor 执行中... locks => " + JSON.toJSONString(locks));
49.                 locks.entrySet().removeIf(entry -> entry.getValue().isCancelled());
50.                 for (Map.Entry<String, Lock> entry : locks.entrySet()) {
51.                     String key = entry.getKey();
52.                     Lock lock = entry.getValue();
53.                     if (!lock.isCancelled()) {
54.                         RedisScript<String> redisScript = RedisScript.of(RENEWAL_LUA, String.class);
55.                         String result = redisTemplate.execute(redisScript, Collections.singletonList(key), lock.value, defaultExpireTime);
56.                         if (Objects.equals(result, "0")) {
57.                             lock.cancel(); // 移除已经释放的锁
58.                         }
59.                     }
60.                 }
61.             } catch (Exception e) {
62.                 System.err.println("看门狗任务执行失败: " + e.getMessage());
63.             }
64.         }, 0, 10, TimeUnit.SECONDS);
65.     }
67.     public boolean acquireLock(String key, String value) {
68.         RedisScript<String> redisScript = RedisScript.of(LOCK_LUA, String.class);
69.         String result = redisTemplate.execute(redisScript, Collections.singletonList(key), value, defaultExpireTime);
70.         if (Objects.equals(result, "1")) {
71.             locks.put(key, new Lock(value));
72.             return true;
73.         }
74.         return false;
75.     }
77.     public boolean acquireLockWithRetry(String key, String value, int maxRetries, long retryIntervalMillis) {
78.         int retryCount = 0;
79.         while (retryCount < maxRetries) {
80.             boolean result = this.acquireLock(key, value);
81.             if (result) {
82.                 locks.put(key, new Lock(value));
83.                 return true;
84.             }
85.             retryCount++;
86.             try {
87.                 Thread.sleep(retryIntervalMillis);
88.             } catch (InterruptedException e) {
89.                 Thread.currentThread().interrupt();
90.                 return false;
91.             }
92.         }
93.         return false;
94.     }
96.     public boolean releaseLock(String key, String value) {
97.         RedisScript<String> redisScript = RedisScript.of(RELEASE_LOCK_LUA, String.class);
98.         String result = redisTemplate.execute(redisScript, Collections.singletonList(key), value);
99.         if (Objects.equals(result, "1")) {
100.             Lock lock = locks.get(key);
101.             if (lock != null) {
102.                 lock.cancel();
103.             }
104.             return true;
105.         }
106.         return false;
107.     }
109.     @PreDestroy
110.     public void shutdown() {
111.         watchdogExecutor.shutdown();
112.         try {
113.             if (!watchdogExecutor.awaitTermination(60, TimeUnit.SECONDS)) {
114.                 watchdogExecutor.shutdownNow();
115.             }
116.         } catch (InterruptedException e) {
117.             watchdogExecutor.shutdownNow();
118.         }
119.     }
120. }

复制代码

后记

还是免责声明，仅供学习参考

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