<!-- 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 嘗試獲取鎖的最大等待時(shí)間，超過這個(gè)值，則認(rèn)為獲取鎖失敗
         * leaseTime   鎖的持有時(shí)間,超過這個(gè)時(shí)間鎖會(huì)自動(dòng)失效（值應(yīng)設(shè)置為大于業(yè)務(wù)處理的時(shí)間，確保在鎖有效期內(nèi)業(yè)務(wù)能處理完）
         */
        // 嘗試加鎖，最多等待100秒，上鎖以后10秒自動(dòng)解鎖
        boolean res = redLock.tryLock(100, 10, TimeUnit.SECONDS);
        if (res) {
            //成功獲得鎖，在這里處理業(yè)務(wù)
            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) {
    // 最小的獲取鎖成功數(shù)：n/2 + 1。 過半機(jī)制
    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);
        }
    }
    // 獲取當(dāng)前系統(tǒng)時(shí)間，單位：毫秒
    long time = System.currentTimeMillis();
    long remainTime = -1;
    if (waitTime > 0) {
        remainTime = unit.toMillis(waitTime);
    }
    long lockWaitTime = calcLockWaitTime(remainTime);
    // 允許加鎖失敗節(jié)點(diǎn)個(gè)數(shù)限制（N - ( N / 2 + 1 )）
    // 假設(shè)有三個(gè)redis節(jié)點(diǎn)，則failedLocksLimit = 1
    int failedLocksLimit = failedLocksLimit();
    // 存放調(diào)用tryLock()方法加鎖成功的那些redis節(jié)點(diǎn)
    List<RLock> acquiredLocks = new ArrayList<>(locks.size());
    // 循環(huán)所有節(jié)點(diǎn)，通過EVAL命令執(zhí)行LUA腳本進(jìn)行加鎖
    for (ListIterator<RLock> iterator = locks.listIterator(); iterator.hasNext();) {
        // 獲取到其中一個(gè)redis實(shí)例
        RLock lock = iterator.next();
        String lockName = lock.getName();
        System.out.println("lockName = " + lockName + "正在嘗試加鎖...");
        boolean lockAcquired;
        try {
            // 未指定鎖超時(shí)時(shí)間和獲取鎖等待時(shí)間的情況
            if (waitTime <= 0 && leaseTime <= 0) {
                // 調(diào)用tryLock()嘗試加鎖
                lockAcquired = lock.tryLock();
            } else {
                // 指定了超時(shí)時(shí)間的情況,重新計(jì)算獲取鎖的等待時(shí)間
                long awaitTime = Math.min(lockWaitTime, remainTime);
                // 調(diào)用tryLock()嘗試加鎖
                lockAcquired = lock.tryLock(awaitTime, newLeaseTime, TimeUnit.MILLISECONDS);
            }
        } catch (RedisResponseTimeoutException e) {
            // 如果拋出RedisResponseTimeoutException異常，為了防止加鎖成功，但是響應(yīng)失敗，需要解鎖所有節(jié)點(diǎn)
            unlockInner(Arrays.asList(lock));
            // 表示獲取鎖失敗
            lockAcquired = false;
        } catch (Exception e) {
            // 表示獲取鎖失敗
            lockAcquired = false;
        }
        if (lockAcquired) {
            // 如果當(dāng)前redis節(jié)點(diǎn)加鎖成功，則加入到acquiredLocks集合中
            acquiredLocks.add(lock);
        } else {
            // 計(jì)算已經(jīng)申請(qǐng)鎖失敗的節(jié)點(diǎn)是否已經(jīng)到達(dá) 允許加鎖失敗節(jié)點(diǎn)個(gè)數(shù)限制 （N-(N/2+1)）, 如果已經(jīng)到達(dá)，就認(rèn)定最終申請(qǐng)鎖失敗，則沒有必要繼續(xù)從后面的節(jié)點(diǎn)申請(qǐng)了。因?yàn)?Redlock 算法要求至少N/2+1 個(gè)節(jié)點(diǎn)都加鎖成功，才算最終的鎖申請(qǐng)成功
            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--;
            }
        }
        // 計(jì)算 目前從各個(gè)節(jié)點(diǎn)獲取鎖已經(jīng)消耗的總時(shí)間，如果已經(jīng)等于最大等待時(shí)間，則認(rèn)定最終申請(qǐng)鎖失敗，返回false
        if (remainTime > 0) {
            // remainTime: 鎖剩余時(shí)間，這個(gè)時(shí)間是某個(gè)客戶端向所有redis節(jié)點(diǎn)申請(qǐng)獲取鎖的總等待時(shí)間, 獲取鎖的中耗時(shí)時(shí)間不能大于這個(gè)時(shí)間。
            // System.currentTimeMillis() - time: 這個(gè)計(jì)算出來的就是當(dāng)前redis節(jié)點(diǎn)獲取鎖消耗的時(shí)間
            remainTime -= System.currentTimeMillis() - time;
            // 重置time為當(dāng)前時(shí)間，因?yàn)橄乱淮窝h(huán)的時(shí)候，方便計(jì)算下一個(gè)redis節(jié)點(diǎn)獲取鎖消耗的時(shí)間
            time = System.currentTimeMillis();
            // 鎖剩余時(shí)間減到0了，說明達(dá)到最大等待時(shí)間，加鎖超時(shí)，認(rèn)為獲取鎖失敗，需要對(duì)成功加鎖集合 acquiredLocks 中的所有鎖執(zhí)行鎖釋放
            if (remainTime <= 0) {
                unlockInner(acquiredLocks);
                // 直接返回false，獲取鎖失敗
                return false;
            }
        }
    }
    if (leaseTime > 0) {
        // 重置鎖過期時(shí)間
        acquiredLocks.stream()
                .map(l -> (RedissonBaseLock) l)
                .map(l -> l.expireAsync(unit.toMillis(leaseTime), TimeUnit.MILLISECONDS))
                .forEach(f -> f.toCompletableFuture().join());
    }
    // 如果邏輯正常執(zhí)行完則認(rèn)為最終申請(qǐng)鎖成功，返回true
    return true;
}