Redisson RedLock红锁加锁实现过程及原理

<!-- JDK 1.8+ compatible -->
<dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson</artifactId>
   <version>3.9.0</version>
</dependency> 

@Test
public void testRedLock() {
    Config config = new Config();
    config.useSingleServer().setAddress("redis://127.0.0.1:6379");
    RedissonClient client1 = Redisson.create(config);
    RLock lock1 = client1.getLock("lock1");
    RLock lock2 = client1.getLock("lock2");
    RLock lock3 = client1.getLock("lock3");
    RedissonRedLock redLock = new RedissonRedLock(lock1, lock2, lock3);
    try {
        /**
         * 4.尝试获取锁
         * redLock.tryLock((long)waitTimeout, (long)leaseTime, TimeUnit.SECONDS)
         * waitTimeout 尝试获取锁的最大等待时间，超过这个值，则认为获取锁失败
         * leaseTime   锁的持有时间,超过这个时间锁会自动失效（值应设置为大于业务处理的时间，确保在锁有效期内业务能处理完）
         */
        // 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
        boolean res = redLock.tryLock(100, 10, TimeUnit.SECONDS);
        if (res) {
            //成功获得锁，在这里处理业务
            System.out.println("成功获取到锁...");
        }
    } catch (Exception e) {
        throw new RuntimeException("aquire lock fail");
    } finally {
        // 无论如何, 最后都要解锁
        redLock.unlock();
    }
}

protected int failedLocksLimit() {
    return locks.size() - minLocksAmount(locks);
}
protected int minLocksAmount(final List<RLock> locks) {
    // 最小的获取锁成功数：n/2 + 1。 过半机制
    return locks.size()/2 + 1;
}

protected int failedLocksLimit() {
    return 0;
}

public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
//        try {
//            return tryLockAsync(waitTime, leaseTime, unit).get();
//        } catch (ExecutionException e) {
//            throw new IllegalStateException(e);
//        }
    long newLeaseTime = -1;
    if (leaseTime > 0) {
        if (waitTime > 0) {
            newLeaseTime = unit.toMillis(waitTime)*2;
        } else {
            newLeaseTime = unit.toMillis(leaseTime);
        }
    }
    // 获取当前系统时间，单位：毫秒
    long time = System.currentTimeMillis();
    long remainTime = -1;
    if (waitTime > 0) {
        remainTime = unit.toMillis(waitTime);
    }
    long lockWaitTime = calcLockWaitTime(remainTime);
    // 允许加锁失败节点个数限制（N - ( N / 2 + 1 )）
    // 假设有三个redis节点，则failedLocksLimit = 1
    int failedLocksLimit = failedLocksLimit();
    // 存放调用tryLock()方法加锁成功的那些redis节点
    List<RLock> acquiredLocks = new ArrayList<>(locks.size());
    // 循环所有节点，通过EVAL命令执行LUA脚本进行加锁
    for (ListIterator<RLock> iterator = locks.listIterator(); iterator.hasNext();) {
        // 获取到其中一个redis实例
        RLock lock = iterator.next();
        String lockName = lock.getName();
        System.out.println("lockName = " + lockName + "正在尝试加锁...");
        boolean lockAcquired;
        try {
            // 未指定锁超时时间和获取锁等待时间的情况
            if (waitTime <= 0 && leaseTime <= 0) {
                // 调用tryLock()尝试加锁
                lockAcquired = lock.tryLock();
            } else {
                // 指定了超时时间的情况,重新计算获取锁的等待时间
                long awaitTime = Math.min(lockWaitTime, remainTime);
                // 调用tryLock()尝试加锁
                lockAcquired = lock.tryLock(awaitTime, newLeaseTime, TimeUnit.MILLISECONDS);
            }
        } catch (RedisResponseTimeoutException e) {
            // 如果抛出RedisResponseTimeoutException异常，为了防止加锁成功，但是响应失败，需要解锁所有节点
            unlockInner(Arrays.asList(lock));
            // 表示获取锁失败
            lockAcquired = false;
        } catch (Exception e) {
            // 表示获取锁失败
            lockAcquired = false;
        }
        if (lockAcquired) {
            // 如果当前redis节点加锁成功，则加入到acquiredLocks集合中
            acquiredLocks.add(lock);
        } else {
            // 计算已经申请锁失败的节点是否已经到达 允许加锁失败节点个数限制 （N-(N/2+1)）, 如果已经到达，就认定最终申请锁失败，则没有必要继续从后面的节点申请了。因为 Redlock 算法要求至少N/2+1 个节点都加锁成功，才算最终的锁申请成功
            if (locks.size() - acquiredLocks.size() == failedLocksLimit()) {
                break;
            }
            if (failedLocksLimit == 0) {
                unlockInner(acquiredLocks);
                if (waitTime <= 0) {
                    return false;
                }
                failedLocksLimit = failedLocksLimit();
                acquiredLocks.clear();
                // reset iterator
                while (iterator.hasPrevious()) {
                    iterator.previous();
                }
            } else {
                failedLocksLimit--;
            }
        }
        // 计算 目前从各个节点获取锁已经消耗的总时间，如果已经等于最大等待时间，则认定最终申请锁失败，返回false
        if (remainTime > 0) {
            // remainTime: 锁剩余时间，这个时间是某个客户端向所有redis节点申请获取锁的总等待时间, 获取锁的中耗时时间不能大于这个时间。
            // System.currentTimeMillis() - time: 这个计算出来的就是当前redis节点获取锁消耗的时间
            remainTime -= System.currentTimeMillis() - time;
            // 重置time为当前时间，因为下一次循环的时候，方便计算下一个redis节点获取锁消耗的时间
            time = System.currentTimeMillis();
            // 锁剩余时间减到0了，说明达到最大等待时间，加锁超时，认为获取锁失败，需要对成功加锁集合 acquiredLocks 中的所有锁执行锁释放
            if (remainTime <= 0) {
                unlockInner(acquiredLocks);
                // 直接返回false，获取锁失败
                return false;
            }
        }
    }
    if (leaseTime > 0) {
        // 重置锁过期时间
        acquiredLocks.stream()
                .map(l -> (RedissonBaseLock) l)
                .map(l -> l.expireAsync(unit.toMillis(leaseTime), TimeUnit.MILLISECONDS))
                .forEach(f -> f.toCompletableFuture().join());
    }
    // 如果逻辑正常执行完则认为最终申请锁成功，返回true
    return true;
}