Redis 分布式锁｜从青铜到钻石的五种演进方案
Redis是一种内存数据库，也是一种开源的Key-Value存储系统。它是当前最热门的NoSQL系统之一，因其高性能、高可扩展性和高可用性而受到广泛关注。Redis不仅仅只是一种存储系统，还可以用来实现许多其他功能，比如在分布式系统中实现分布式锁。本文介绍了Redis在实现分布式锁时的五种不同演进方案。
1. 青铜方案：使用SETNX
Redis最简单的分布式锁方案就是使用SETNX命令，该命令用于在Key不存在的情况下设置Key的值。
public boolean lock(String lockKey, String requestId, int expireTime) {
Long result = jedis.setnx(lockKey, requestId);
if (result == 1) { // SETNX成功，获取锁成功
jedis.expire(lockKey, expireTime);
return true;
}
return false;
}
上述代码中的lock方法用于获取分布式锁，首先使用SETNX命令尝试在分布式Redis系统中创建一个新Key。如果该命令返回1，则说明我们成功地获取了锁，此时设置该Key的失效时间以确保释放锁，并返回true；否则，返回false。
1.1 SETNX存在的问题
尽管SETNX非常简单，但它存在一个重大的问题：如果Redis节点发生故障，持有锁的节点无法正常释放锁。在这种情况下，其他节点将无法获取该锁，因为设置Key的操作已被持有锁的节点锁定。这会导致分布式系统的灾难性失败，因此需要一种更稳定的分布式锁机制。
2. 白银方案：使用SETNX和GETSET
为了克服SETNX的问题，可以引入GETSET命令。GETSET命令用于获取并设置Key的值，并返回新值。
public boolean lock(String lockKey, String requestId, int expireTime) {
String result = jedis.getSet(lockKey, requestId);
if (result == null) { // 如果返回null则说明Key不存在，获取锁成功
jedis.expire(lockKey, expireTime);
return true;
}
return false;
}
2.1 GETSET存在的问题
由于GETSET的特性，在某些情况下会出现死锁问题。例如，如果线程A获取了锁，但由于各种原因而无法正常释放锁，则线程B可以使用GETSET命令获取锁。此时线程A恢复并尝试释放锁时，它将在执行DEL命令之前附加了一个新值，这将导致线程A删除B获取的锁，从而导致问题。
3. 黄金方案：使用RedLock算法
为了克服白银方案中存在的问题，可以引入RedLock算法，该算法由Redis的创始人Salvator Sanfilippo开发。RedLock算法允许在Redis集群的多个节点上获取锁，并使用Quorum机制来保证锁的可用性。
3.1 RedLock的实现
RedLock算法的基本思想是在多个Redis节点上锁定同一Key，但在释放锁时必须在大多数节点上执行。Quorum机制可以用来确保在锁定和释放锁时必须得到大多数节点的确认，从而保证锁的正确性。
具体实现时，可以将Redis节点按照哈希顺序进行排序，并向前5个节点（或者通过参数进行指定）发送SET命令进行锁定。如果大多数Redis节点在相同的一段时间内都成功设置了Key，那么锁就会生效。
public boolean lock(String lockKey, String requestId, int expireTime) {
int retryCount = 0;
int quorum = nodeList.size() / 2 + 1;
int n = nodeList.size();
while (retryCount < retryTimes) {
Long start = System.currentTimeMillis();
int successCount = 0;
String value = requestId + "_" + (start + expireTime);
for (RedisNode node : nodeList) {
try (Jedis jedis = new Jedis(node.getHost(), node.getPort(), timeout)) {
String result = jedis.set(lockKey, value, "NX", "EX", expireTime);
if ("OK".equals(result)) {
successCount++;
}
} catch (Exception e) {
e.printStackTrace();
}
}
if (successCount >= quorum) {
return true;
}
// 如果在Redis集群各节点之间同步的时间偏差大于predetermineTime，则需要等待一段时间再重试
if (System.currentTimeMillis() - start + 2 > expireTime && successCount < n) {
return false;
}
retryCount++;
Thread.sleep(sleepTime);
}
return false;
}
上述代码中的lock方法用于使用RedLock算法获取分布式锁。在获得节点列表和其他必要的配置参数后，可以进行多次尝试，直到获取锁或超过重试次数。在每次尝试中，使用集群中的五个节点（或指定数量）进行SET命令，并检查是否已成功设置Key。如果在超时时间内获得足够的Quorum确认，则返回true，否则继续尝试。
3.2 RedLock存在的问题
RedLock算法仍然存在一些问题。首先，由于网络延迟，可能会导致获取锁的节点不是第一个成功设置Key的节点。其次，如果一个节点因崩溃而失去其所有锁定，其他节点将无法感知这一情况，从而可能会解锁由该节点锁定的Key。
4. 白金方案：使用Redisson框架
为了克服RedLock算法存在的问题，可以使用Redisson框架。Redisson是一种基于Redis的分布式Java对象和服务框架，它为Java开发人员提供了类似于Java集合的分布式对象和服务，同时也提供了分布式锁的实现。
4.1 Redisson的使用
Redisson提供了RLock接口来实现分布式锁。其中，RLock实现了一组基本的获取和释放分布式锁的方法。
public void test() {
Config config = new Config();
config.useSingleServer().setAddress("redis://127.0.0.1:6379");
RedissonClient redissonClient = Redisson.create(config);
RLock lock = redissonClient.getLock("lockKey");
try {
boolean result = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (result) {
// 成功获取锁
} else {
// 未能获得锁
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 释放锁
lock.unlock();
}
}
上述代码中的test方法用于演示如何使用Redisson获取分布式锁。首先创建了RedissonClient对象，并获取了锁对象。在tryLock方法中设置了有效期和等待时间，该方法将一直尝试获得锁，直到超时。如果获取锁成功，则返回true，代码将进入“成功获取锁”的代码块中，否则将进入“未能获得锁”的代码块中。在使用完毕后，必须调用unlock方法来释放锁。
4.2 Redisson的优点
Redisson的主要优点是在实现分布式锁时具有高度可靠性和可扩展性。Redisson支持许多常见的分布式锁解决方案，包括Retry、Fair、MultiLock等。此外，Redisson还为简单的锁和读写锁提供了专用接口，最大程度地简化了开发过程。
5. 钻石方案：使用RedLock和Redisson结合
为了充分发挥Redisson的优势，可以将它与RedLock算法结合使用。这种方法采用了Redisson的RLock接口，同时对Redis集群使用RedLock算法，以提高分布式锁的可靠性。
public boolean lock(String lockKey, String requestId, int expireTime) {
RLock lock = redissonClient.getLock(lockKey);
RedisConnection conn = (RedisConnection) lock.getHoldCountCommand().getConnection();
List nodeList = getRedisClusterNodes(conn);
int retryCount = 0;
int quorum = nodeList.size() / 2 + 1;
int n = nodeList.size();
while (retryCount < retryTimes) {
long start = System.currentTimeMillis();
int successCount = 0;
long waitTime = expireTime * 1000 / n / 2;
long toWait = waitTime + new Random().nextInt((int) waitTime);
for (RedisNode node : nodeList) {
String result = null;
try (Jedis jedis = new Jedis(node.getHost(), node.getPort(), timeout)) {
result = jedis.set(lockKey, requestId, "NX", "EX", expireTime);
} catch (Exception e) {
e.printStackTrace();
}
if ("OK".equals(result)) {
successCount++;
}
}
if (successCount >= quorum) {
LockResult lockResult = (LockResult) lock.get(30, TimeUnit.SECONDS);
if (lockResult.isSuccess()) {
return true;
} else {
int unlockCount = 0;
for (RedisNode node : nodeList) {
try (Jedis jedis = new Jedis(node.getHost(), node.getPort(), timeout)) {
jedis.del(lockKey);
unlockCount++;
} catch (Exception e) {
e.printStackTrace();
}
}
if (unlockCount >= quorum) {
return false;
}
}
}
retryCount++;
try {
Thread.sleep(toWait);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return false;
}
上述代码中的lock方法是在RedLock和Redisson结合使用的情况下获得分布式锁的实现。在尝试获取锁之前，首先使用RLock对象获取RedLock算法的循环节点列表。在获取了循环节点列表之后，就可以使用RedLock算法在Redis集群中进行键锁定。如果成功获取了Quorum确认，则需要再次使用RLock接口检查锁状态，并等待其他锁持有者释放锁。如果可以获取锁，则返回true，否则返回false。
5.1 组合方案的优点
RedLock和Redisson结合使用的优点是能够使用最大程度减少Redis节点丢失锁的风险，同时继续利用Redisson的高度可靠性和可扩展性。此外，该方案还在锁持有状态的检查和延迟时间上进行了调整，以达到更好的性能。