面试官：分布式锁最终解决方案是RedLock吗？为什么？

RedLock 是 Redis 分布式锁的一种实现方案，由 Redis 的作者 Salvatore Sanfilippo 提出。

RedLock 算法旨在解决单个 Redis 实例作为分布式锁时可能出现的单点故障问题，通过在多个独立运行的 Redis 实例上同时获取锁的方式来提高锁服务的可用性和安全性。

1.实现思路

RedLock 是对集群的每个节点进行加锁，如果大多数节点（N/2+1）加锁成功，则才会认为加锁成功。
这样即使集群中有某个节点挂掉了，因为大部分集群节点都加锁成功了，所以分布式锁还是可以继续使用的。

2.实现代码

在 Java 开发中，可以使用 Redisson 框架很方便的实现 RedLock，具体操作代码如下：

import org.redisson.Redisson;
import org.redisson.api.RedisClient;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.redisson.RedissonRedLock;

public class RedLockDemo {
   
   

    public static void main(String[] args) {
   
   
        // 创建 Redisson 客户端配置
        Config config = new Config();
        config.useClusterServers()
        .addNodeAddress("redis://127.0.0.1:6379",
                        "redis://127.0.0.1:6380",
                        "redis://127.0.0.1:6381"); // 假设有三个 Redis 节点
        // 创建 Redisson 客户端实例
        RedissonClient redissonClient = Redisson.create(config);
        // 创建 RedLock 对象
        RedissonRedLock redLock = redissonClient.getRedLock("resource");
        try {
   
   
            // 尝试获取分布式锁，最多尝试 5 秒获取锁，并且锁的有效期为 5000 毫秒
            boolean lockAcquired = redLock.tryLock(5, 5000, TimeUnit.MILLISECONDS); 
            if (lockAcquired) {
   
   
                // 加锁成功，执行业务代码...
            } else {
   
   
                System.out.println("Failed to acquire the lock!");
            }
        } catch (InterruptedException e) {
   
   
            Thread.currentThread().interrupt();
            System.err.println("Interrupted while acquiring the lock");
        } finally {
   
   
            // 无论是否成功获取到锁，在业务逻辑结束后都要释放锁
            if (redLock.isLocked()) {
   
   
                redLock.unlock();
            }
            // 关闭 Redisson 客户端连接
            redissonClient.shutdown();
        }
    }
}

3.实现原理

Redisson 中的 RedLock 是基于 RedissonMultiLock（联锁）实现的。

RedissonMultiLock 是 Redisson 提供的一种分布式锁类型，它可以同时操作多个锁，以达到对多个锁进行统一管理的目的。联锁的操作是原子性的，即要么全部锁住，要么全部解锁。这样可以保证多个锁的一致性。

RedissonMultiLock 使用示例如下：

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.multi.MultiLock;

public class RedissonMultiLockDemo {
   
   

    public static void main(String[] args) throws InterruptedException {
   
   
        // 创建 Redisson 客户端
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        RedissonClient redisson = Redisson.create(config);

        // 创建多个分布式锁实例
        RLock lock1 = redisson.getLock("lock1");
        RLock lock2 = redisson.getLock("lock2");
        RLock lock3 = redisson.getLock("lock3");

        // 创建 RedissonMultiLock 对象
        MultiLock multiLock = new MultiLock(lock1, lock2, lock3);

        // 加锁
        multiLock.lock();
        try {
   
   
            // 执行任务
            System.out.println("Lock acquired. Task started.");
            Thread.sleep(3000);
            System.out.println("Task finished. Releasing the lock.");
        } finally {
   
   
            // 释放锁
            multiLock.unlock();
        }
        // 关闭客户端连接
        redisson.shutdown();
    }
}

在示例中，我们首先创建了一个 Redisson 客户端并连接到 Redis 服务器。然后，我们使用 redisson.getLock 方法创建了多个分布式锁实例。接下来，我们通过传入这些锁实例来创建了 RedissonMultiLock 对象。

说回正题，RedissonRedLock 是基于 RedissonMultiLock 实现的这点，可以从继承关系看出。

RedissonRedLock 继承自 RedissonMultiLock，核心实现源码如下：

public class RedissonRedLock extends RedissonMultiLock {
   
   
    public RedissonRedLock(RLock... locks) {
   
   
        super(locks);
    }

    /**
     * 锁可以失败的次数，锁的数量-锁成功客户端最小的数量
     */
    @Override
    protected int failedLocksLimit() {
   
   
        return locks.size() - minLocksAmount(locks);
    }

    /**
     * 锁的数量 / 2 + 1，例如有3个客户端加锁，那么最少需要2个客户端加锁成功
     */
    protected int minLocksAmount(final List<RLock> locks) {
   
   
        return locks.size()/2 + 1;
    }

    /** 
     * 计算多个客户端一起加锁的超时时间，每个客户端的等待时间
     */
    @Override
    protected long calcLockWaitTime(long remainTime) {
   
   
        return Math.max(remainTime / locks.size(), 1);
    }

    @Override
    public void unlock() {
   
   
        unlockInner(locks);
    }
}

从上述源码可以看出，Redisson 中的 RedLock 是基于 RedissonMultiLock（联锁）实现的，当 RedLock 是对集群的每个节点进行加锁，如果大多数节点，也就是 N/2+1 个节点加锁成功，则认为 RedLock 加锁成功。

4.存在问题

RedLock 主要存在以下两个问题：

1. 性能问题：RedLock 要等待大多数节点返回之后，才能加锁成功，而这个过程中可能会因为网络问题，或节点超时的问题，影响加锁的性能。
2. 并发安全性问题：当客户端加锁时，如果遇到 GC 可能会导致加锁失效，但 GC 后误认为加锁成功的安全事故，例如以下流程：
   1. 客户端 A 请求 3 个节点进行加锁。
   2. 在节点回复处理之前，客户端 A 进入 GC 阶段（存在 STW，全局停顿）。
   3. 之后因为加锁时间的原因，锁已经失效了。
   4. 客户端 B 请求加锁（和客户端 A 是同一把锁），加锁成功。
   5. 客户端 A GC 完成，继续处理前面节点的消息，误以为加锁成功。
   6. 此时客户端 B 和客户端 A 同时加锁成功，出现并发安全性问题。

      5.已废弃 RedLock

      因为 RedLock 存在的问题争议较大，且没有完美的解决方案，所以 Redisson 中已经废弃了 RedLock，这一点在 Redisson 官方文档中能找到，如下图所示：
      
      

      6.废弃 RedLock 后的解决方案

      虽然 Redisson 中已经废弃了 RedLock，但是你可以直接使用 Redisson 中的普通的加锁即可，因为它的普通锁会基于 wait 机制，等待锁将信息同步到从节点，从而保证数据一致性的，虽然不能完全避免数据一致性问题，但也能最大限度的保证数据的一致性。

      课后思考

      既然普通的分布式锁存在单点问题？而 RedLock 又不是最完美的解决方案，那么在分布式锁领域，谁才是最终的解决方案呢？请在评论区留下您的解决方案，以及对应的原因？

本文已收录到我的面试小站 www.javacn.site，其中包含的内容有：Redis、JVM、并发、并发、MySQL、Spring、Spring MVC、Spring Boot、Spring Cloud、MyBatis、设计模式、消息队列等模块。