Redis分布式锁获取释放全解析避开那些坑实现高效并发控制

威震华夏关云长

引言

在分布式系统中，多个节点同时访问共享资源时，为了保证数据的一致性和正确性，我们需要使用分布式锁来协调各个节点的行为。Redis作为一个高性能的内存数据库，提供了实现分布式锁的理想工具。本文将深入探讨Redis分布式锁的获取和释放机制，分析实现过程中的常见问题，并提供避开这些坑的方法，最终实现高效的并发控制。

Redis分布式锁基础

分布式锁是一种在分布式环境下控制多个进程或线程对共享资源访问的同步机制。Redis分布式锁利用Redis的原子操作特性，可以在分布式系统中实现高效的锁机制。

基本原理

Redis分布式锁的基本原理是利用Redis的SETNX（SET if Not eXists）命令，该命令在指定的key不存在时设置key的值，如果key已经存在，则不做任何操作。通过这个特性，我们可以实现一个简单的互斥锁：

1. 当一个客户端尝试获取锁时，它执行SETNX命令，尝试设置一个特定的key。
2. 如果SETNX返回1，表示key不存在，客户端成功获取了锁。
3. 如果SETNX返回0，表示key已经存在，客户端获取锁失败。

简单实现

下面是一个简单的Redis分布式锁实现：

2. public class SimpleRedisLock {
3.     private Jedis jedis;
4.     private String lockKey;
5.     private int expireTime = 30; // 默认锁过期时间为30秒
6.    
7.     public SimpleRedisLock(Jedis jedis, String lockKey) {
8.         this.jedis = jedis;
9.         this.lockKey = lockKey;
10.     }
11.    
12.     public boolean tryLock() {
13.         // SETNX命令尝试获取锁
14.         long result = jedis.setnx(lockKey, String.valueOf(System.currentTimeMillis() + expireTime * 1000));
15.         return result == 1;
16.     }
17.    
18.     public boolean unlock() {
19.         // 释放锁，直接删除key
20.         long result = jedis.del(lockKey);
21.         return result == 1;
22.     }
23. }

复制代码

然而，这种简单的实现存在很多问题，比如锁没有设置过期时间可能导致死锁，以及锁的释放可能不是由锁的持有者执行等。在后面的章节中，我们将逐步完善这个实现。

Redis分布式锁的获取

获取Redis分布式锁需要考虑多个方面，包括锁的原子性、锁的唯一标识、锁的过期时间等。下面我们将详细介绍如何正确地获取Redis分布式锁。

SET命令的扩展

在早期版本的Redis中，我们通常使用SETNX命令来实现分布式锁，但SETNX有一个缺点，它不能同时设置key的过期时间。为了解决这个问题，Redis 2.6.12版本开始，SET命令支持了一系列选项，可以原子性地完成设置key和过期时间的操作：

2. SET lock_key unique_value NX PX 30000

复制代码

这个命令的含义是：

• lock_key：锁的key
• unique_value：唯一值，用于标识锁的持有者
• NX：只有当key不存在时才设置
• PX 30000：设置key的过期时间为30000毫秒（30秒）

使用这个命令，我们可以原子性地完成锁的获取和过期时间的设置，避免了先SETNX再EXPIRE可能导致的死锁问题。

获取锁的完整实现

下面是一个更完善的Redis分布式锁获取实现：

2. public class RedisDistributedLock {
3.     private Jedis jedis;
4.     private String lockKey;
5.     private String requestId; // 唯一标识，用于标识锁的持有者
6.     private int expireTime = 30; // 默认锁过期时间为30秒
7.    
8.     public RedisDistributedLock(Jedis jedis, String lockKey) {
9.         this.jedis = jedis;
10.         this.lockKey = lockKey;
11.         this.requestId = UUID.randomUUID().toString(); // 生成唯一标识
12.     }
13.    
14.     /**
15.      * 尝试获取锁
16.      * @return 是否获取成功
17.      */
18.     public boolean tryLock() {
19.         // 使用SET命令尝试获取锁
20.         String result = jedis.set(lockKey, requestId, "NX", "PX", expireTime * 1000);
21.         return "OK".equals(result);
22.     }
23.    
24.     /**
25.      * 带超时时间的获取锁
26.      * @param timeout 获取锁的超时时间（毫秒）
27.      * @return 是否获取成功
28.      */
29.     public boolean tryLock(long timeout) {
30.         long startTime = System.currentTimeMillis();
31.         long end = startTime + timeout;
32.         
33.         while (System.currentTimeMillis() < end) {
34.             if (tryLock()) {
35.                 return true;
36.             }
37.             try {
38.                 Thread.sleep(100); // 短暂休眠，避免CPU空转
39.             } catch (InterruptedException e) {
40.                 Thread.currentThread().interrupt();
41.                 return false;
42.             }
43.         }
44.         return false;
45.     }
46.    
47.     // 其他方法...
48. }

复制代码

在这个实现中，我们：

1. 使用SET命令原子性地设置锁和过期时间
2. 为每个锁生成一个唯一标识（requestId），用于标识锁的持有者
3. 提供了带超时时间的获取锁方法，在超时时间内不断尝试获取锁

锁的可重入性

可重入锁是指同一个线程可以多次获取同一个锁而不会造成死锁。要实现Redis分布式锁的可重入性，我们需要在锁中记录获取锁的次数和线程信息：

2. public class ReentrantRedisLock {
3.     private Jedis jedis;
4.     private String lockKey;
5.     private String requestId; // 唯一标识，用于标识锁的持有者
6.     private int expireTime = 30; // 默认锁过期时间为30秒
7.     private ThreadLocal<Integer> lockCount = new ThreadLocal<>(); // 记录当前线程获取锁的次数
8.    
9.     public ReentrantRedisLock(Jedis jedis, String lockKey) {
10.         this.jedis = jedis;
11.         this.lockKey = lockKey;
12.         this.requestId = Thread.currentThread().getId() + ":" + UUID.randomUUID().toString();
13.     }
14.    
15.     /**
16.      * 尝试获取锁
17.      * @return 是否获取成功
18.      */
19.     public boolean lock() {
20.         // 检查当前线程是否已经持有锁
21.         if (lockCount.get() != null && lockCount.get() > 0) {
22.             // 已经持有锁，增加计数
23.             lockCount.set(lockCount.get() + 1);
24.             return true;
25.         }
26.         
27.         // 使用SET命令尝试获取锁
28.         String result = jedis.set(lockKey, requestId, "NX", "PX", expireTime * 1000);
29.         if ("OK".equals(result)) {
30.             lockCount.set(1); // 初始化计数
31.             return true;
32.         }
33.         return false;
34.     }
35.    
36.     // 其他方法...
37. }

复制代码

在这个实现中，我们使用ThreadLocal来记录当前线程获取锁的次数，如果线程已经持有锁，则增加计数而不是重新获取锁。

Redis分布式锁的释放

释放Redis分布式锁同样需要考虑多个方面，包括确保只有锁的持有者才能释放锁，以及避免误删其他客户端的锁等。

简单释放的问题

最简单的释放锁方法是直接删除锁的key：

2. public boolean unlock() {
3.     long result = jedis.del(lockKey);
4.     return result == 1;
5. }

复制代码

然而，这种方法存在一个严重的问题：如果一个客户端获取锁后，由于某些原因（如GC暂停、网络延迟等）导致锁过期，然后另一个客户端获取了同一个锁，这时第一个客户端执行unlock方法，会错误地释放第二个客户端的锁。

正确的释放方式

为了避免上述问题，我们需要在释放锁时验证锁的唯一标识，确保只有锁的持有者才能释放锁：

2. public boolean unlock() {
3.     // 使用Lua脚本确保操作的原子性
4.     String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
5.     Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
6.     return Long.parseLong(result.toString()) == 1;
7. }

复制代码

在这个实现中，我们使用Lua脚本确保获取锁的值和删除锁的操作是原子性的。只有当锁的值与当前客户端的requestId匹配时，才会删除锁。

可重入锁的释放

对于可重入锁，我们需要在释放锁时减少计数，只有当计数减到0时才真正释放锁：

2. public boolean unlock() {
3.     // 检查当前线程是否持有锁
4.     if (lockCount.get() == null || lockCount.get() <= 0) {
5.         return false;
6.     }
7.    
8.     // 减少计数
9.     int newCount = lockCount.get() - 1;
10.     lockCount.set(newCount);
11.    
12.     // 如果计数为0，则真正释放锁
13.     if (newCount == 0) {
14.         // 使用Lua脚本确保操作的原子性
15.         String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
16.         Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
17.         return Long.parseLong(result.toString()) == 1;
18.     }
19.    
20.     return true;
21. }

复制代码

锁的续期

在某些场景下，业务逻辑的执行时间可能超过锁的过期时间，这时我们需要在锁过期前对其进行续期，以避免锁自动释放导致的问题。下面是一个实现锁续期的例子：

2. public class RedisDistributedLockWithRenewal {
3.     private Jedis jedis;
4.     private String lockKey;
5.     private String requestId;
6.     private int expireTime = 30; // 默认锁过期时间为30秒
7.     private ScheduledExecutorService scheduler;
8.     private Future<?> renewalTask;
9.    
10.     public RedisDistributedLockWithRenewal(Jedis jedis, String lockKey) {
11.         this.jedis = jedis;
12.         this.lockKey = lockKey;
13.         this.requestId = UUID.randomUUID().toString();
14.         this.scheduler = Executors.newScheduledThreadPool(1);
15.     }
16.    
17.     /**
18.      * 尝试获取锁
19.      * @return 是否获取成功
20.      */
21.     public boolean tryLock() {
22.         // 使用SET命令尝试获取锁
23.         String result = jedis.set(lockKey, requestId, "NX", "PX", expireTime * 1000);
24.         if ("OK".equals(result)) {
25.             // 获取锁成功，启动续期任务
26.             startRenewalTask();
27.             return true;
28.         }
29.         return false;
30.     }
31.    
32.     /**
33.      * 启动续期任务
34.      */
35.     private void startRenewalTask() {
36.         // 锁过期时间的1/3时间后开始续期
37.         int renewalInterval = expireTime * 1000 / 3;
38.         renewalTask = scheduler.scheduleAtFixedRate(() -> {
39.             // 使用Lua脚本续期
40.             String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('pexpire', KEYS[1], ARGV[2]) else return 0 end";
41.             Object result = jedis.eval(script, Collections.singletonList(lockKey),
42.                                      Arrays.asList(requestId, String.valueOf(expireTime * 1000)));
43.             if (Long.parseLong(result.toString()) == 0) {
44.                 // 续期失败，取消续期任务
45.                 renewalTask.cancel(false);
46.             }
47.         }, renewalInterval, renewalInterval, TimeUnit.MILLISECONDS);
48.     }
49.    
50.     /**
51.      * 释放锁
52.      * @return 是否释放成功
53.      */
54.     public boolean unlock() {
55.         // 取消续期任务
56.         if (renewalTask != null) {
57.             renewalTask.cancel(false);
58.         }
59.         
60.         // 使用Lua脚本释放锁
61.         String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
62.         Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
63.         return Long.parseLong(result.toString()) == 1;
64.     }
65.    
66.     /**
67.      * 关闭锁，释放资源
68.      */
69.     public void close() {
70.         // 取消续期任务
71.         if (renewalTask != null) {
72.             renewalTask.cancel(false);
73.         }
74.         // 关闭线程池
75.         scheduler.shutdown();
76.     }
77. }

复制代码

在这个实现中，我们使用ScheduledExecutorService来定期续期锁。续期的时间间隔是锁过期时间的1/3，这样可以确保在锁过期前至少有两次续期机会。续期操作同样使用Lua脚本确保原子性。

常见问题和坑

在实现和使用Redis分布式锁的过程中，有很多常见的问题和坑需要注意。下面我们将分析这些问题，并提供解决方案。

问题1：锁过期但业务未完成

这是一个经典的问题：客户端A获取了锁，但业务逻辑的执行时间超过了锁的过期时间，导致锁自动释放。然后客户端B获取了锁，这时客户端A完成了业务逻辑，尝试释放锁，结果错误地释放了客户端B的锁。

解决方案：

1. 为每个锁生成唯一标识，并在释放锁时验证这个标识。
2. 使用Lua脚本确保获取锁的值和删除锁的操作是原子性的。
3. 考虑实现锁的自动续期机制。

问题2：Redis单点故障

如果使用单个Redis实例作为分布式锁服务，当这个实例发生故障时，所有的锁服务都会不可用。

解决方案：

1. 使用Redis集群，确保高可用性。
2. 使用多个独立的Redis实例，实现RedLock算法。

问题3：时钟漂移

Redis分布式锁依赖过期时间来自动释放锁，如果不同Redis实例的时钟存在漂移，可能导致锁提前或延迟释放。

解决方案：

1. 尽量使用NTP同步所有服务器的时间。
2. 在设置锁的过期时间时，考虑时钟漂移的可能性，适当延长过期时间。
3. 实现锁的自动续期机制，减少对过期时间的依赖。

问题4：GC暂停导致的锁过期

在Java应用中，长时间的GC暂停可能导致线程无法及时续期锁，从而导致锁过期。

解决方案：

1. 优化JVM参数，减少长时间GC暂停的可能性。
2. 使用多个续期线程，确保即使一个线程被GC暂停，其他线程也能继续续期。
3. 考虑使用更短的锁过期时间和更频繁的续期操作。

问题5：网络分区

在网络分区的情况下，客户端可能无法与Redis服务器通信，导致无法获取锁或释放锁。

解决方案：

1. 实现重试机制，在网络恢复后自动重试。
2. 设置合理的超时时间，避免无限等待。
3. 考虑使用本地锁作为后备方案，在网络分区时提供有限的并发控制。

问题6：锁的误删

在实现不完善的情况下，可能会出现客户端错误地删除其他客户端的锁。

解决方案：

1. 为每个锁生成唯一标识，并在释放锁时验证这个标识。
2. 使用Lua脚本确保获取锁的值和删除锁的操作是原子性的。

高效并发控制

Redis分布式锁不仅仅是获取和释放锁，还需要考虑如何实现高效的并发控制。下面我们将介绍一些优化策略和技术。

1. 锁分段

当并发量很大时，单个锁可能成为性能瓶颈。这时可以考虑使用锁分段技术，将资源分成多个段，每个段使用一个独立的锁。

2. public class SegmentedRedisLock {
3.     private Jedis jedis;
4.     private String baseKey;
5.     private int segmentCount;
6.     private RedisDistributedLock[] locks;
7.    
8.     public SegmentedRedisLock(Jedis jedis, String baseKey, int segmentCount) {
9.         this.jedis = jedis;
10.         this.baseKey = baseKey;
11.         this.segmentCount = segmentCount;
12.         this.locks = new RedisDistributedLock[segmentCount];
13.         
14.         // 初始化分段锁
15.         for (int i = 0; i < segmentCount; i++) {
16.             locks[i] = new RedisDistributedLock(jedis, baseKey + ":" + i);
17.         }
18.     }
19.    
20.     /**
21.      * 根据资源的key获取对应的锁
22.      * @param resourceKey 资源key
23.      * @return 对应的锁
24.      */
25.     public RedisDistributedLock getLock(String resourceKey) {
26.         int hash = Math.abs(resourceKey.hashCode());
27.         int segment = hash % segmentCount;
28.         return locks[segment];
29.     }
30.    
31.     /**
32.      * 锁定资源
33.      * @param resourceKey 资源key
34.      * @return 是否锁定成功
35.      */
36.     public boolean lock(String resourceKey) {
37.         return getLock(resourceKey).tryLock();
38.     }
39.    
40.     /**
41.      * 释放资源锁
42.      * @param resourceKey 资源key
43.      * @return 是否释放成功
44.      */
45.     public boolean unlock(String resourceKey) {
46.         return getLock(resourceKey).unlock();
47.     }
48. }

复制代码

在这个实现中，我们将资源分成多个段，每个资源根据其key的哈希值分配到不同的段上，从而减少锁竞争。

2. 读写锁

在读多写少的场景下，使用互斥锁会导致并发性能下降。这时可以考虑实现读写锁，允许多个读操作同时进行，但写操作是互斥的。

2. public class RedisReadWriteLock {
3.     private Jedis jedis;
4.     private String lockKey;
5.     private String readLockKey;
6.     private String writeLockKey;
7.     private String requestId;
8.     private int expireTime = 30; // 默认锁过期时间为30秒
9.    
10.     public RedisReadWriteLock(Jedis jedis, String lockKey) {
11.         this.jedis = jedis;
12.         this.lockKey = lockKey;
13.         this.readLockKey = lockKey + ":read";
14.         this.writeLockKey = lockKey + ":write";
15.         this.requestId = UUID.randomUUID().toString();
16.     }
17.    
18.     /**
19.      * 获取读锁
20.      * @return 是否获取成功
21.      */
22.     public boolean readLock() {
23.         // 检查是否有写锁
24.         String writeLockValue = jedis.get(writeLockKey);
25.         if (writeLockValue != null) {
26.             return false;
27.         }
28.         
29.         // 获取读锁
30.         long result = jedis.incr(readLockKey);
31.         if (result == 1) {
32.             // 第一个读锁，设置过期时间
33.             jedis.expire(readLockKey, expireTime);
34.         }
35.         return true;
36.     }
37.    
38.     /**
39.      * 释放读锁
40.      * @return 是否释放成功
41.      */
42.     public boolean readUnlock() {
43.         // 释放读锁
44.         long result = jedis.decr(readLockKey);
45.         if (result == 0) {
46.             // 没有读锁了，删除key
47.             jedis.del(readLockKey);
48.         }
49.         return true;
50.     }
51.    
52.     /**
53.      * 获取写锁
54.      * @return 是否获取成功
55.      */
56.     public boolean writeLock() {
57.         // 检查是否有写锁
58.         String writeLockValue = jedis.get(writeLockKey);
59.         if (writeLockValue != null) {
60.             return false;
61.         }
62.         
63.         // 检查是否有读锁
64.         String readLockValue = jedis.get(readLockKey);
65.         if (readLockValue != null && Long.parseLong(readLockValue) > 0) {
66.             return false;
67.         }
68.         
69.         // 获取写锁
70.         String result = jedis.set(writeLockKey, requestId, "NX", "PX", expireTime * 1000);
71.         return "OK".equals(result);
72.     }
73.    
74.     /**
75.      * 释放写锁
76.      * @return 是否释放成功
77.      */
78.     public boolean writeUnlock() {
79.         // 使用Lua脚本确保操作的原子性
80.         String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
81.         Object result = jedis.eval(script, Collections.singletonList(writeLockKey), Collections.singletonList(requestId));
82.         return Long.parseLong(result.toString()) == 1;
83.     }
84. }

复制代码

在这个实现中，我们使用两个key来实现读写锁：一个用于读锁（readLockKey），一个用于写锁（writeLockKey）。读锁使用计数器来记录当前有多少个读操作，写锁使用SET命令来确保互斥性。

3. 锁优化策略

除了锁分段和读写锁，还有一些其他的优化策略可以提高并发性能：

尽量使用细粒度的锁，而不是粗粒度的锁。例如，如果可能的话，锁定单个记录而不是整个表。

在需要获取多个锁的情况下，始终按照相同的顺序获取锁，以避免死锁。

设置合理的锁获取超时时间，并在获取失败时进行适当的重试，避免无限等待。

对于频繁获取和释放的锁，可以考虑在本地缓存锁的状态，减少对Redis的访问。

2. public class CachedRedisLock {
3.     private Jedis jedis;
4.     private String lockKey;
5.     private String requestId;
6.     private int expireTime = 30; // 默认锁过期时间为30秒
7.     private ConcurrentHashMap<String, Boolean> localLocks = new ConcurrentHashMap<>();
8.    
9.     public CachedRedisLock(Jedis jedis, String lockKey) {
10.         this.jedis = jedis;
11.         this.lockKey = lockKey;
12.         this.requestId = UUID.randomUUID().toString();
13.     }
14.    
15.     /**
16.      * 尝试获取锁
17.      * @return 是否获取成功
18.      */
19.     public boolean tryLock() {
20.         // 首先检查本地缓存
21.         if (localLocks.containsKey(lockKey)) {
22.             return false;
23.         }
24.         
25.         // 尝试从Redis获取锁
26.         String result = jedis.set(lockKey, requestId, "NX", "PX", expireTime * 1000);
27.         if ("OK".equals(result)) {
28.             // 获取成功，更新本地缓存
29.             localLocks.put(lockKey, true);
30.             return true;
31.         }
32.         return false;
33.     }
34.    
35.     /**
36.      * 释放锁
37.      * @return 是否释放成功
38.      */
39.     public boolean unlock() {
40.         // 检查本地缓存
41.         if (!localLocks.containsKey(lockKey)) {
42.             return false;
43.         }
44.         
45.         // 使用Lua脚本释放锁
46.         String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
47.         Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
48.         if (Long.parseLong(result.toString()) == 1) {
49.             // 释放成功，更新本地缓存
50.             localLocks.remove(lockKey);
51.             return true;
52.         }
53.         return false;
54.     }
55. }

复制代码

在这个实现中，我们使用本地缓存来记录锁的状态，减少对Redis的访问。这种方法适用于锁竞争激烈的场景，但需要注意本地缓存和Redis之间的同步问题。

完整示例

下面是一个完整的Redis分布式锁实现，包含了前面讨论的各种特性：

2. import redis.clients.jedis.Jedis;
3. import redis.clients.jedis.params.SetParams;
5. import java.util.Collections;
6. import java.util.UUID;
7. import java.util.concurrent.*;
9. public class CompleteRedisLock implements AutoCloseable {
10.     private Jedis jedis;
11.     private String lockKey;
12.     private String requestId;
13.     private int expireTime = 30; // 默认锁过期时间为30秒
14.     private ThreadLocal<Integer> lockCount = new ThreadLocal<>(); // 记录当前线程获取锁的次数
15.     private ScheduledExecutorService scheduler;
16.     private Future<?> renewalTask;
17.     private boolean locked = false;
18.    
19.     public CompleteRedisLock(Jedis jedis, String lockKey) {
20.         this.jedis = jedis;
21.         this.lockKey = lockKey;
22.         this.requestId = Thread.currentThread().getId() + ":" + UUID.randomUUID().toString();
23.         this.scheduler = Executors.newScheduledThreadPool(1);
24.     }
25.    
26.     /**
27.      * 尝试获取锁
28.      * @return 是否获取成功
29.      */
30.     public boolean tryLock() {
31.         // 检查当前线程是否已经持有锁
32.         if (lockCount.get() != null && lockCount.get() > 0) {
33.             // 已经持有锁，增加计数
34.             lockCount.set(lockCount.get() + 1);
35.             return true;
36.         }
37.         
38.         // 使用SET命令尝试获取锁
39.         SetParams params = SetParams.setParams().nx().px(expireTime * 1000);
40.         String result = jedis.set(lockKey, requestId, params);
41.         if ("OK".equals(result)) {
42.             // 获取锁成功，启动续期任务
43.             startRenewalTask();
44.             lockCount.set(1);
45.             locked = true;
46.             return true;
47.         }
48.         return false;
49.     }
50.    
51.     /**
52.      * 带超时时间的获取锁
53.      * @param timeout 获取锁的超时时间（毫秒）
54.      * @return 是否获取成功
55.      */
56.     public boolean tryLock(long timeout) {
57.         long startTime = System.currentTimeMillis();
58.         long end = startTime + timeout;
59.         
60.         while (System.currentTimeMillis() < end) {
61.             if (tryLock()) {
62.                 return true;
63.             }
64.             try {
65.                 Thread.sleep(100); // 短暂休眠，避免CPU空转
66.             } catch (InterruptedException e) {
67.                 Thread.currentThread().interrupt();
68.                 return false;
69.             }
70.         }
71.         return false;
72.     }
73.    
74.     /**
75.      * 启动续期任务
76.      */
77.     private void startRenewalTask() {
78.         // 锁过期时间的1/3时间后开始续期
79.         int renewalInterval = expireTime * 1000 / 3;
80.         renewalTask = scheduler.scheduleAtFixedRate(() -> {
81.             // 使用Lua脚本续期
82.             String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('pexpire', KEYS[1], ARGV[2]) else return 0 end";
83.             Object result = jedis.eval(script, Collections.singletonList(lockKey),
84.                                      Arrays.asList(requestId, String.valueOf(expireTime * 1000)));
85.             if (Long.parseLong(result.toString()) == 0) {
86.                 // 续期失败，取消续期任务
87.                 renewalTask.cancel(false);
88.             }
89.         }, renewalInterval, renewalInterval, TimeUnit.MILLISECONDS);
90.     }
91.    
92.     /**
93.      * 释放锁
94.      * @return 是否释放成功
95.      */
96.     public boolean unlock() {
97.         // 检查当前线程是否持有锁
98.         if (lockCount.get() == null || lockCount.get() <= 0) {
99.             return false;
100.         }
101.         
102.         // 减少计数
103.         int newCount = lockCount.get() - 1;
104.         lockCount.set(newCount);
105.         
106.         // 如果计数为0，则真正释放锁
107.         if (newCount == 0) {
108.             // 取消续期任务
109.             if (renewalTask != null) {
110.                 renewalTask.cancel(false);
111.             }
112.             
113.             // 使用Lua脚本释放锁
114.             String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
115.             Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
116.             if (Long.parseLong(result.toString()) == 1) {
117.                 locked = false;
118.                 return true;
119.             }
120.             return false;
121.         }
122.         
123.         return true;
124.     }
125.    
126.     /**
127.      * 检查当前线程是否持有锁
128.      * @return 是否持有锁
129.      */
130.     public boolean isLocked() {
131.         return locked;
132.     }
133.    
134.     /**
135.      * 设置锁的过期时间
136.      * @param expireTime 过期时间（秒）
137.      */
138.     public void setExpireTime(int expireTime) {
139.         this.expireTime = expireTime;
140.     }
141.    
142.     /**
143.      * 关闭锁，释放资源
144.      */
145.     @Override
146.     public void close() {
147.         // 释放锁
148.         if (locked) {
149.             unlock();
150.         }
151.         
152.         // 取消续期任务
153.         if (renewalTask != null) {
154.             renewalTask.cancel(false);
155.         }
156.         
157.         // 关闭线程池
158.         scheduler.shutdown();
159.         try {
160.             if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
161.                 scheduler.shutdownNow();
162.             }
163.         } catch (InterruptedException e) {
164.             scheduler.shutdownNow();
165.             Thread.currentThread().interrupt();
166.         }
167.     }
168. }

复制代码

这个完整的Redis分布式锁实现包含了以下特性：

1. 可重入性：同一个线程可以多次获取同一个锁
2. 锁的自动续期：防止业务逻辑执行时间超过锁的过期时间
3. 原子性操作：使用Lua脚本确保关键操作的原子性
4. 资源管理：实现AutoCloseable接口，支持try-with-resources语法
5. 唯一标识：为每个锁生成唯一标识，避免误删其他客户端的锁

使用示例：

2. public class RedisLockExample {
3.     public static void main(String[] args) {
4.         Jedis jedis = new Jedis("localhost", 6379);
5.         
6.         try (CompleteRedisLock lock = new CompleteRedisLock(jedis, "myLock")) {
7.             // 尝试获取锁，最多等待10秒
8.             if (lock.tryLock(10000)) {
9.                 System.out.println("获取锁成功，执行业务逻辑...");
10.                
11.                 // 模拟业务逻辑执行
12.                 try {
13.                     Thread.sleep(5000);
14.                 } catch (InterruptedException e) {
15.                     Thread.currentThread().interrupt();
16.                 }
17.                
18.                 System.out.println("业务逻辑执行完成");
19.             } else {
20.                 System.out.println("获取锁失败");
21.             }
22.         } catch (Exception e) {
23.             e.printStackTrace();
24.         } finally {
25.             jedis.close();
26.         }
27.     }
28. }

复制代码

总结

Redis分布式锁是分布式系统中实现并发控制的重要工具。在实现和使用Redis分布式锁时，需要注意以下几点：

1. 原子性操作：使用Redis的SET命令和Lua脚本确保关键操作的原子性，避免竞态条件。
2. 锁的唯一标识：为每个锁生成唯一标识，并在释放锁时验证这个标识，避免误删其他客户端的锁。
3. 锁的过期时间：设置合理的锁过期时间，防止死锁，但也要考虑业务逻辑的执行时间。
4. 锁的自动续期：对于可能长时间执行的业务逻辑，实现锁的自动续期机制，防止锁过期。
5. 可重入性：在需要的情况下，实现锁的可重入性，允许同一个线程多次获取同一个锁。
6. 高可用性：考虑使用Redis集群或多个独立的Redis实例，确保锁服务的高可用性。
7. 性能优化：根据实际场景，考虑使用锁分段、读写锁等技术提高并发性能。

原子性操作：使用Redis的SET命令和Lua脚本确保关键操作的原子性，避免竞态条件。

锁的唯一标识：为每个锁生成唯一标识，并在释放锁时验证这个标识，避免误删其他客户端的锁。

锁的过期时间：设置合理的锁过期时间，防止死锁，但也要考虑业务逻辑的执行时间。

锁的自动续期：对于可能长时间执行的业务逻辑，实现锁的自动续期机制，防止锁过期。

可重入性：在需要的情况下，实现锁的可重入性，允许同一个线程多次获取同一个锁。

高可用性：考虑使用Redis集群或多个独立的Redis实例，确保锁服务的高可用性。

性能优化：根据实际场景，考虑使用锁分段、读写锁等技术提高并发性能。

通过遵循这些原则和技巧，我们可以实现一个高效、可靠的Redis分布式锁，为分布式系统提供有效的并发控制。