介紹

當我們涉及到多進程或多節點的分布式系統時，傳統的單機鎖機制不再足夠應對并發控制的需求。這是因為在分布式環境中，多個進程或節點同時訪問共享資源，傳統鎖無法有效地協調這種復雜的并發情況，這就引入了分布式鎖，本文將一步一步引導大家使用lua腳本和redis實現分布式鎖。

理解分布式鎖

1.1 什么是分布式鎖？

分布式鎖的是確保在多個進程或多個節點之間對共享資源的訪問是有序、互斥和原子的，以避免競態條件和數據不一致性問題。在多進程或多節點環境中，分布式鎖廣泛應用于協調共享資源的安全訪問。

1.2 Redis作為分布式鎖的選擇

Redis（Remote Dictionary Server）是一種高性能的開源內存數據庫，因其具有以下優勢，使其成為實現分布式鎖的理想選擇：

• 高性能和低延遲：Redis以內存為基礎，使得數據的讀寫操作非常快速，具有極低的延遲，適用于高吞吐量的應用場景。
• 持久性支持：盡管Redis是內存數據庫，但它支持不同級別的數據持久性，可以將數據持久化到磁盤，確保數據不會因服務器重啟而丟失。
• 數據結構豐富：Redis支持多種數據結構，如字符串、哈希、列表、集合和有序集合等，這使得它非常適合在分布式鎖實現中靈活地操作數據。
• 原子性操作：Redis提供了各種原子性操作，包括原子的SETNX（SET if Not eXists）操作，這是實現分布式鎖所需的基本操作之一。
• 發布-訂閱功能：Redis支持發布-訂閱模式，可用于實現分布式鎖的通知機制，以便其他進程能夠獲知鎖的狀態變化。
• Lua腳本支持：Redis支持運行Lua腳本，這意味著可以在Redis服務器上執行復雜的原子性操作，確保在多個命令之間不會發生競態條件(重點)。

Redis的高性能、持久性、豐富的數據結構以及對Lua腳本的支持，使其成為實現分布式鎖的理想選擇。特別是Lua腳本的原子性執行，確保了獲取和釋放分布式鎖的操作是不可分割的，從而有效地解決了競態條件問題，確保了分布式鎖的可靠性。

Lua腳本基礎

2.1 Lua腳本簡介

Lua是一種輕量級、高性能的腳本語言，廣泛用于嵌入式系統和游戲開發，也被用于各種其他應用中：

• 輕量級：Lua被設計為一種輕量級的腳本語言，具有小巧的代碼庫和低內存消耗。這使得它適用于嵌入式系統和資源受限的環境。
• 高性能：Lua的解釋器非常快速，執行效率高。這使得它在需要快速執行的應用中表現出色，如游戲引擎。
• 可嵌入性：Lua可以輕松嵌入到其他編程語言中，例如C/C++。這種特性使得它成為擴展應用程序功能的有力工具。
• 簡單的語法：Lua采用簡單、清晰的語法，易于學習和使用。它支持面向過程和函數式編程范式。
• 動態類型：Lua是一種動態類型語言，變量的類型在運行時確定。這增加了靈活性，但也需要更多的注意力來處理類型相關的錯誤。

Redis是一種開源的內存數據庫，常用于緩存、隊列和實時數據處理等場景。Redis引入了Lua腳本引擎，允許用戶編寫和執行Lua腳本來操作Redis數據。Lua腳本可以在Redis服務器上執行，確保多個Redis命令在單個事務中原子執行。這對于需要執行多個命令來維護數據一致性的應用非常有用。

Lua腳本在Redis中的應用使得Redis不僅僅是一個簡單的鍵值存儲，還可以執行復雜的操作和自定義業務邏輯，提高了Redis的靈活性和性能。這使得它成為處理高并發、實時數據的流行選擇。

2.2 Redis 執行 Lua腳本

Lua執行格式：EVAL script numkeys key [key ...] arg [arg ...]

eval "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}" 2 key1 key2 arg1 arg2

eval: 腳本執行命令
 
"return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}": 腳本內容

2: key數量 

key1 key2 arg1 arg2: key和value的值  角標從1開始

因為numkeys數量為2，故key1 key2 為key， arg1 arg2為value

例1:

127.0.0.1:6379> eval "return redis.call('set',KEYS[1],'liulianJAVA')" 1 name
OK
127.0.0.1:6379> get name
"liulianJAVA"
127.0.0.1:6379> 

例2:

127.0.0.1:6379> eval "return redis.call('set',KEYS[1], ARGV[1])" 1 name LIULIANJAVA
OK
127.0.0.1:6379> get name
"LIULIANJAVA"
127.0.0.1:6379> 

第三部分：Java與Redis集成

3.1 Jedis庫簡介

Jedis是一個流行的Java客戶端庫，用于與Redis數據庫進行通信。它提供了一組用于連接、執行Redis命令和操作數據的API，使Java開發人員能夠輕松地與Redis服務器進行交互。以下是強調Jedis的重要性的幾個方面：

• 簡單易用的API：Jedis提供了直觀且易于理解的API，使Java開發人員能夠輕松地與Redis進行通信。這使得在Java應用程序中使用Redis變得非常容易。
• 高性能：Jedis被設計為高性能的Redis客戶端庫。它使用了連接池和管道技術來提高性能，從而在高并發環境中表現出色。這對于需要快速訪問Redis的應用程序非常重要。
• 廣泛的社區支持：Jedis是一個廣泛采用的庫，擁有龐大的開發者社區和資源。這意味著您可以輕松地找到文檔、教程和解決方案，以解決與Jedis相關的問題。
• Redis功能的完全支持：Jedis支持Redis的所有功能，包括字符串、哈希、列表、集合、有序集合等數據結構。您可以使用Jedis執行所有Redis命令，而無需擔心兼容性問題。
• 事務和管道支持：Jedis支持Redis的事務和管道功能。這允許您將多個命令組合成一個原子性操作，或者批量執行多個命令以提高性能。

Jedis是一個強大、易于使用且高性能的Java庫，用于與Redis數據庫進行通信。它為Java開發人員提供了一個便捷的工具，使他們能夠利用Redis的強大功能來構建高性能、可擴展和可靠的應用程序。因此，對于需要使用Redis的Java應用程序來說，Jedis是一個不可或缺的工具。

3.2 連接Redis

首先，確保已經將Jedis庫添加到Java項目的依賴中。可以使用Maven或Gradle等構建工具來添加Jedis依賴。

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.6.1</version>
</dependency>

import redis.clients.jedis.Jedis;

public class JedisExample {

    public static void mAIn(String[] args) {
        // 創建一個Jedis連接實例，連接到Redis服務器，默認端口為6379
        Jedis jedis = new Jedis("localhost", 6379);
        jedis.auth("liulianJAVA");
        // 執行一些Redis操作
        jedis.set("myKey", "Hello, Redis!");
        String value = jedis.get("myKey");
        System.out.println("Value for 'myKey': " + value);
        // 關閉連接
        jedis.close();
    }
}

在這個示例中，我們首先創建了一個Jedis實例，并指定了要連接的Redis服務器的主機名（localhost）和端口號（6379）。然后，我們使用set方法將一個鍵值對存儲在Redis中，使用get方法檢索該鍵的值，最后關閉了連接。

第四部分：使用Lua腳本實現分布式鎖

4.1 獲取分布式鎖

public static boolean acquireLock(Jedis jedis, String lockName, int lockTimeout) {
        String luaScript = "if redis.call('set', KEYS[1], ARGV[1], 'NX', 'EX', ARGV[2]) then return 1 else return 0 end";
        Object result = jedis.eval(luaScript, 1, lockName, LOCK_VALUE, String.valueOf(lockTimeout));
        return result != null && "1".equals(result.toString());
    }

獲取鎖所需參數:
jedis: redis連接   
lockName: 鎖名稱 
lockTimeout: 鎖超時時間

4.2 釋放分布式鎖

public static void releaseLock(Jedis jedis, String lockName) {
    jedis.del(lockName);
}

釋放鎖所需參數: 
jedis: redis連接   
lockName:  鎖名稱

第五部分：鎖示例和實踐

5.1 分布式鎖示例

LockUtil.java

import redis.clients.jedis.Jedis;

public class LockUtil {
    private static final String LOCK_VALUE = "locked"; // 鎖的值

    // 獲取鎖 所需參數:jedis:redis連接信息    lockName: 鎖名稱 lockTimeout: 鎖超時時間
    public static boolean acquireLock(Jedis jedis, String lockName, int lockTimeout) {
        String luaScript = "if redis.call('set', KEYS[1], ARGV[1], 'NX', 'EX', ARGV[2]) then return 1 else return 0 end";
        Object result = jedis.eval(luaScript, 1, lockName, LOCK_VALUE, String.valueOf(lockTimeout));
        return result != null && "1".equals(result.toString());
    }

    public static boolean acquireLockWithRetry(Jedis jedis, String LOCK_KEY, int maxRetrySeconds) {
        long startTime = System.currentTimeMillis();
        while (true) {
            long currentTime = System.currentTimeMillis();
            if (currentTime - startTime >= maxRetrySeconds * 1000L) {
                // 超過預設的秒數，返回獲取失敗
                return false;
            }

            // 嘗試獲取鎖
            boolean lockAcquired = acquireLock(jedis,LOCK_KEY, 60000);
            if (lockAcquired) {
                return true; // 成功獲取鎖
            }

            // 等待一段時間后重試
            try {
                Thread.sleep(100); // 100毫秒后重試
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return false; // 線程被中斷，返回獲取失敗
            }
        }
    }


    // 釋放鎖所需參數: jedis: redis連接   lockName: 鎖名稱
    public static void releaseLock(Jedis jedis, String lockName) {
        jedis.del(lockName);
    }
}

5.2 實踐模擬

Test.java

import java.util.ArrayList;

public class Test {

    private static Integer number = 10000;

    public static void main(String[] args) {

        ArrayList<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 10000; i ++){
            threads.add(new Thread(()-> Test.number = Test.number -1));
        }

        for (int i = 0; i < 10000; i ++){
            threads.get(i).start();
        }

        threads.forEach(thread -> {
            try {
                thread.join();
            } catch (InterruptedException ignored) {
            }
        });
         System.out.println("number結果: " + number);

    }


}

number結果: 241

引入分布式鎖后:

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.util.ArrayList;
import java.util.List;

public class DistributedLockExample {

    private static Integer number = 1000;

    public static void main(String[] args) {
        List<Thread> threads = new ArrayList<>();
        // 創建Jedis連接池
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(1000);
        JedisPool jedisPool = new JedisPool(poolConfig, "127.0.0.1", 6379, 200000, "liulian");
        String lockName = "liulian";


        for (int i = 0; i < 1000 ; i++){
            threads.add(new Thread(() -> {
                try (Jedis jedis = jedisPool.getResource()) {
                    // 獲取鎖
                    boolean lockAcquired = LockUtil.acquireLockWithRetry(jedis, lockName, 600);
                    if (lockAcquired) {
                        try {
                            // 在鎖內執行關鍵操作
                            number = number - 1;
                        } finally {
                            // 釋放鎖
                            LockUtil.releaseLock(jedis, lockName);
                        }
                    } else {
                        System.out.println("Failed to acquire lock.");
                    }
                }
            }));
        }

        threads.forEach(Thread::start);

        threads.forEach(thread -> {
            try {
                thread.join();
            } catch (InterruptedException ignored) {
            }
        });

        System.out.println("number結果: " + number);

        // 關閉Jedis連接池
        jedisPool.close();
    }

    private static void performCriticalOperation() {
        // 在這里執行關鍵操作，例如訪問共享資源或執行任務
        System.out.println("Critical operation performed.");
    }
}

number結果: 0

分布式鎖在現代分布式系統中扮演了重要的角色，它們確保了并發操作的安全性和一致性。通過使用Redis和Lua腳本，我們已經了解了如何實現一個簡單但有效的分布式鎖。然而，分布式系統中的鎖管理不僅僅局限于此。在實際應用中，我們可能需要處理更多的復雜情況，如鎖的超時、死鎖檢測、鎖的可重入性等。

此外，分布式鎖的性能和可用性也是關鍵因素，需要仔細考慮和優化。在實際生產環境中使用分布式鎖時，請確保全面測試和監控，以確保系統的穩定性和性能。

無論如何，分布式鎖是構建可靠分布式系統的關鍵組成部分，對于確保數據完整性和一致性至關重要。希望本文能夠幫助您更好地理解分布式鎖的基本原理和實現方式，并為大家在構建分布式應用程序時提供有價值的指導。