关于java:面试官说一下红锁RedLock的实现原理

RedLock 是一种分布式锁的实现算法，由 Redis 的作者 Salvatore Sanfilippo（也称为 Antirez）提出，次要用于解决在分布式系统中实现牢靠锁的问题。在 Redis 独自节点的根底上，RedLock 应用了多个独立的 Redis 实例（通常倡议是奇数个，比方 5 个），独特合作来提供更健壮的分布式锁服务。

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

RedLock 具备以下次要个性：

互斥性：在任何工夫，只有一个客户端能够取得锁，确保了资源的互斥拜访。
防止死锁：通过为锁设置一个较短的过期工夫，即便客户端在取得锁后因为网络故障等起因未能按时开释锁，锁也会因为过期而主动开释，防止了死锁的产生。
容错性：即便一部分 Redis 节点宕机，只有大多数节点（即过半数以上的节点）仍在线，RedLock 算法就能持续提供服务，并确保锁的正确性。
1.RedLock 实现思路
RedLock 是对集群的每个节点进行加锁，如果大多数节点（N/2+1）加锁胜利，则才会认为加锁胜利。

这样即便集群中有某个节点挂掉了，因为大部分集群节点都加锁胜利了，所以分布式锁还是能够持续应用的。

2.工作流程

RedLock 算法的工作流程大抵如下：

客户端向多个独立的 Redis 实例尝试获取锁，设置锁的过期工夫十分短。
如果客户端能在大部分节点上胜利获取锁，并且所破费的工夫小于锁的过期工夫的一半，那么认为客户端胜利获取到了分布式锁。
当客户端实现对受爱护资源的操作后，它须要向所有曾获取锁的 Redis 实例开释锁。

若在开释锁的过程中，客户端因故无奈实现，因为设置了锁的过期工夫，锁最终会主动过期开释，防止了死锁。

3.根本应用

在 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();      }  }}

4.实现原理

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 加锁胜利。

5.存在问题

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

性能问题：RedLock 要期待大多数节点返回之后，能力加锁胜利，而这个过程中可能会因为网络问题，或节点超时的问题，影响加锁的性能。
并发安全性问题：当客户端加锁时，如果遇到 GC 可能会导致加锁生效，但 GC 后误认为加锁胜利的安全事故，例如以下流程：
1. 客户端 A 申请 3 个节点进行加锁。
2. 在节点回复解决之前，客户端 A 进入 GC 阶段（存在 STW，全局进展）。
3. 之后因为加锁工夫的起因，锁曾经生效了。
4. 客户端 B 申请加锁（和客户端 A 是同一把锁），加锁胜利。
5. 客户端 A GC 实现，持续解决后面节点的音讯，误以为加锁胜利。
6. 此时客户端 B 和客户端 A 同时加锁胜利，呈现并发安全性问题。
  6.已废除的 RedLock
  因为 RedLock 存在的问题争议较大，且没有完满的解决方案，所以 Redisson 中曾经废除了 RedLock，这一点在 Redisson 官网文档中能找到，如下图所示：
  
  课后思考
  既然 RedLock 曾经被废除，那么想要实现分布式锁，同时又想防止 Redis 单点故障问题，应该应用哪种解决方案呢？

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

1.RedLock 实现思路

2.工作流程

3.根本应用

4.实现原理

5.存在问题

6.已废除的 RedLock

课后思考