面試官：說一下紅鎖RedLock的實現原理？

作者：磊哥 2024-02-27 15:23:48

RedLock 算法旨在解決單個 Redis 實例作為分布式鎖時可能出現的單點故障問題，通過在多個獨立運行的 Redis 實例上同時獲取鎖的方式來提高鎖服務的可用性和安全性。

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 后誤認為加鎖成功的安全事故，例如以下流程：

客戶端 A 請求 3 個節點進行加鎖。
在節點回復處理之前，客戶端 A 進入 GC 階段（存在 STW，全局停頓）。
之后因為加鎖時間的原因，鎖已經失效了。
客戶端 B 請求加鎖（和客戶端 A 是同一把鎖），加鎖成功。
客戶端 A GC 完成，繼續處理前面節點的消息，誤以為加鎖成功。
此時客戶端 B 和客戶端 A 同時加鎖成功，出現并發安全性問題。

6.已廢棄的 RedLock

因為 RedLock 存在的問題爭議較大，且沒有完美的解決方案，所以 Redisson 中已經廢棄了 RedLock，這一點在 Redisson 官方文檔中能找到，如下圖所示：

責任編輯：姜華來源： Java中文社群

RedLock 算法 Redis