2. 程式人生 > >基於redis的分散式鎖 | 併發程式設計網

基於redis的分散式鎖 | 併發程式設計網

阿新 • • 發佈：2018-12-14

1 介紹

這篇博文講介紹如何一步步構建一個基於Redis的分散式鎖。會從最原始的版本開始，然後根據問題進行調整，最後完成一個較為合理的分散式鎖。

本篇文章會將分散式鎖的實現分為兩部分，一個是單機環境，另一個是叢集環境下的Redis鎖實現。在介紹分散式鎖的實現之前，先來了解下分散式鎖的一些資訊。

2 分散式鎖

2.1 什麼是分散式鎖？

分散式鎖是控制分散式系統或不同系統之間共同訪問共享資源的一種鎖實現，如果不同的系統或同一個系統的不同主機之間共享了某個資源時，往往需要互斥來防止彼此干擾來保證一致性。

2.2 分散式鎖需要具備哪些條件

  1. 互斥性：在任意一個時刻，只有一個客戶端持有鎖。
  2. 無死鎖：即便持有鎖的客戶端崩潰或者其他意外事件，鎖仍然可以被獲取。
  3. 容錯：只要大部分Redis節點都活著，客戶端就可以獲取和釋放鎖

2.4 分散式鎖的實現有哪些？

  1. 資料庫
  2. Memcached（add命令）
  3. Redis（setnx命令）
  4. Zookeeper（臨時節點）
  5. 等等

3 單機Redis的分散式鎖

3.1 準備工作

3.1.1 定義常量類

public class LockConstants {
    public static final String OK = "OK";

    /** NX|XX, NX -- Only set the key if it does not already exist. XX -- Only set the key if it already exist. **/
 

    public static final String NOT_EXIST = "NX";
    public static final String EXIST = "XX";

    /** expx EX|PX, expire time units: EX = seconds; PX = milliseconds **/
    public static final String SECONDS = "EX";
    public static final String MILLISECONDS = "PX";

    private LockConstants
 
() {}
}
複製程式碼

3.1.2 定義鎖的抽象類

抽象類RedisLock實現java.util.concurrent包下的Lock介面，然後對一些方法提供預設實現，子類只需實現lock方法和unlock方法即可。程式碼如下

public abstract class RedisLock implements Lock {

    protected Jedis jedis;
    protected String lockKey;

    public RedisLock(Jedis jedis,String lockKey) {
        this(jedis, lockKey);
    }


    public void sleepBySencond(int sencond){
        try {
            Thread.sleep(sencond*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    @Override
    public void lockInterruptibly(){}

    @Override
    public Condition newCondition() {
        return null;
    }

    @Override
    public boolean tryLock() {
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit){
        return false;
    }

}
複製程式碼

3.2 最基礎的版本1

先來一個最基礎的版本，程式碼如下

public class LockCase1 extends RedisLock {

    public LockCase1(Jedis jedis, String name) {
        super(jedis, name);
    }

    @Override
    public void lock() {
        while(true){
            String result = jedis.set(lockKey, "value", NOT_EXIST);
            if(OK.equals(result)){
                System.out.println(Thread.currentThread().getId()+"加鎖成功!");
                break;
            }
        }
    }

    @Override
    public void unlock() {
        jedis.del(lockKey);
    }
}
複製程式碼

LockCase1類提供了lock和unlock方法。 其中lock方法也就是在reids客戶端執行如下命令

SET lockKey value NX
複製程式碼

而unlock方法就是呼叫DEL命令將鍵刪除。 好了，方法介紹完了。現在來想想這其中會有什麼問題？ 假設有兩個客戶端A和B，A獲取到分散式的鎖。A執行了一會，突然A所在的伺服器斷電了（或者其他什麼的），也就是客戶端A掛了。這時出現一個問題，這個鎖一直存在，且不會被釋放，其他客戶端永遠獲取不到鎖。如下示意圖

可以通過設定過期時間來解決這個問題

3.3 版本2-設定鎖的過期時間

public void lock() {
    while(true){
        String result = jedis.set(lockKey, "value", NOT_EXIST,SECONDS,30);
        if(OK.equals(result)){
            System.out.println(Thread.currentThread().getId()+"加鎖成功!");
            break;
        }
    }
}
複製程式碼

類似的Redis命令如下

SET lockKey value NX EX 30
複製程式碼

注：要保證設定過期時間和設定鎖具有原子性

這時又出現一個問題，問題出現的步驟如下

  1. 客戶端A獲取鎖成功，過期時間30秒。
  2. 客戶端A在某個操作上阻塞了50秒。
  3. 30秒時間到了，鎖自動釋放了。
  4. 客戶端B獲取到了對應同一個資源的鎖。
  5. 客戶端A從阻塞中恢復過來，釋放掉了客戶端B持有的鎖。

示意圖如下

這時會有兩個問題

  1. 過期時間如何保證大於業務執行時間?
  2. 如何保證鎖不會被誤刪除?

先來解決如何保證鎖不會被誤刪除這個問題。 這個問題可以通過設定value為當前客戶端生成的一個隨機字串，且保證在足夠長的一段時間內在所有客戶端的所有獲取鎖的請求中都是唯一的。

3.4 版本3-設定鎖的value

抽象類RedisLock增加lockValue欄位，lockValue欄位的預設值為UUID隨機值假設當前執行緒ID。

public abstract class RedisLock implements Lock {

    //...
    protected String lockValue;

    public RedisLock(Jedis jedis,String lockKey) {
        this(jedis, lockKey, UUID.randomUUID().toString()+Thread.currentThread().getId());
    }

    public RedisLock(Jedis jedis, String lockKey, String lockValue) {
        this.jedis = jedis;
        this.lockKey = lockKey;
        this.lockValue = lockValue;
    }

    //...
}
複製程式碼

加鎖程式碼

public void lock() {
    while(true){
        String result = jedis.set(lockKey, lockValue, NOT_EXIST,SECONDS,30);
        if(OK.equals(result)){
            System.out.println(Thread.currentThread().getId()+"加鎖成功!");
            break;
        }
    }
}
複製程式碼

解鎖程式碼

public void unlock() {
    String lockValue = jedis.get(lockKey);
    if (lockValue.equals(lockValue)){
        jedis.del(lockKey);
    }
}
複製程式碼

這時看看加鎖程式碼，好像沒有什麼問題啊。 再來看看解鎖的程式碼，這裡的解鎖操作包含三步操作：獲取值、判斷和刪除鎖。這時你有沒有想到在多執行緒環境下的i++操作?

3.4.1 i++問題

i++操作也可分為三個步驟：讀i的值，進行i+1，設定i的值。 如果兩個執行緒同時對i進行i++操作，會出現如下情況

  1. i設定值為0
  2. 執行緒A讀到i的值為0
  3. 執行緒B也讀到i的值為0
  4. 執行緒A執行了+1操作，將結果值1寫入到記憶體
  5. 執行緒B執行了+1操作，將結果值1寫入到記憶體
  6. 此時i進行了兩次i++操作，但是結果卻為1

在多執行緒環境下有什麼方式可以避免這類情況發生? 解決方式有很多種，例如用AtomicInteger、CAS、synchronized等等。 這些解決方式的目的都是要確保i++ 操作的原子性。那麼回過頭來看看解鎖，同理我們也是要確保解鎖的原子性。我們可以利用Redis的lua指令碼來實現解鎖操作的原子性。

3.5 版本4-具有原子性的釋放鎖

lua指令碼內容如下

if redis.call("get",KEYS[1]) == ARGV[1] then
    return redis.call("del",KEYS[1])
else
    return 0
end
複製程式碼

這段Lua指令碼在執行的時候要把的lockValue作為ARGV[1]的值傳進去，把lockKey作為KEYS[1]的值傳進去。現在來看看解鎖的java程式碼

public void unlock() {
    // 使用lua指令碼進行原子刪除操作
    String checkAndDelScript = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                                "return redis.call('del', KEYS[1]) " +
                                "else " +
                                "return 0 " +
                                "end";
    jedis.eval(checkAndDelScript, 1, lockKey, lockValue);
}
複製程式碼

好了，解鎖操作也確保了原子性了，那麼是不是單機Redis環境的分散式鎖到此就完成了? 別忘了版本2-設定鎖的過期時間還有一個，過期時間如何保證大於業務執行時間問題沒有解決。

3.6 版本5-確保過期時間大於業務執行時間

抽象類RedisLock增加一個boolean型別的屬性isOpenExpirationRenewal，用來標識是否開啟定時重新整理過期時間。 在增加一個scheduleExpirationRenewal方法用於開啟重新整理過期時間的執行緒。

public abstract class RedisLock implements Lock {
	//...

    protected volatile boolean isOpenExpirationRenewal = true;

    /**
     * 開啟定時重新整理
     */
    protected void scheduleExpirationRenewal(){
        Thread renewalThread = new Thread(new ExpirationRenewal());
        renewalThread.start();
    }

    /**
     * 重新整理key的過期時間
     */
    private class ExpirationRenewal implements Runnable{
        @Override
        public void run() {
            while (isOpenExpirationRenewal){
                System.out.println("執行延遲失效時間中...");

                String checkAndExpireScript = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                        "return redis.call('expire',KEYS[1],ARGV[2]) " +
                        "else " +
                        "return 0 end";
                jedis.eval(checkAndExpireScript, 1, lockKey, lockValue, "30");

                //休眠10秒
                sleepBySencond(10);
            }
        }
    }
}
複製程式碼

加鎖程式碼在獲取鎖成功後將isOpenExpirationRenewal置為true，並且呼叫scheduleExpirationRenewal方法，開啟重新整理過期時間的執行緒。

public void lock() {
    while (true) {
        String result = jedis.set(lockKey, lockValue, NOT_EXIST, SECONDS, 30);
        if (OK.equals(result)) {
            System.out.println("執行緒id:"+Thread.currentThread().getId() + "加鎖成功!時間:"+LocalTime.now());

            //開啟定時重新整理過期時間
            isOpenExpirationRenewal = true;
            scheduleExpirationRenewal();
            break;
        }
        System.out.println("執行緒id:"+Thread.currentThread().getId() + "獲取鎖失敗，休眠10秒!時間:"+LocalTime.now());
        //休眠10秒
        sleepBySencond(10);
    }
}
複製程式碼

解鎖程式碼增加一行程式碼，將isOpenExpirationRenewal屬性置為false，停止重新整理過期時間的執行緒輪詢。

public void unlock() {
    //...
    isOpenExpirationRenewal = false;
}

複製程式碼

3.7 測試

測試程式碼如下

public void testLockCase5() {
    //定義執行緒池
    ThreadPoolExecutor pool = new ThreadPoolExecutor(0, 10,
                                                    1, TimeUnit.SECONDS,
                                                    new SynchronousQueue<>());

    //新增10個執行緒獲取鎖
    for (int i = 0; i < 10; i++) {
        pool.submit(() -> {
            try {
                Jedis jedis = new Jedis("localhost");
                LockCase5 lock = new LockCase5(jedis, lockName);
                lock.lock();

                //模擬業務執行15秒
                lock.sleepBySencond(15);

                lock.unlock();
            } catch (Exception e){
                e.printStackTrace();
            }
        });
    }

    //當執行緒池中的執行緒數為0時，退出
    while (pool.getPoolSize() != 0) {}
}
複製程式碼

測試結果

或許到這裡基於單機Redis環境的分散式就介紹完了。但是使用java的同學有沒有發現一個鎖的重要特性

那就是鎖的重入，那麼分散式鎖的重入該如何實現呢？這裡就留一個坑了

4 叢集Redis的分散式鎖

在Redis的分散式環境中，Redis 的作者提供了RedLock 的演算法來實現一個分散式鎖。

4.1 加鎖

RedLock演算法加鎖步驟如下

  1. 獲取當前Unix時間，以毫秒為單位。
  2. 依次嘗試從N個例項，使用相同的key和隨機值獲取鎖。在步驟2，當向Redis設定鎖時,客戶端應該設定一個網路連線和響應超時時間，這個超時時間應該小於鎖的失效時間。例如你的鎖自動失效時間為10秒，則超時時間應該在5-50毫秒之間。這樣可以避免伺服器端Redis已經掛掉的情況下，客戶端還在死死地等待響應結果。如果伺服器端沒有在規定時間內響應，客戶端應該儘快嘗試另外一個Redis例項。
  3. 客戶端使用當前時間減去開始獲取鎖時間（步驟1記錄的時間）就得到獲取鎖使用的時間。當且僅當從大多數（這裡是3個節點）的Redis節點都取到鎖，並且使用的時間小於鎖失效時間時，鎖才算獲取成功。
  4. 如果取到了鎖，key的真正有效時間等於有效時間減去獲取鎖所使用的時間（步驟3計算的結果）。
  5. 如果因為某些原因，獲取鎖失敗（沒有在至少N/2+1個Redis例項取到鎖或者取鎖時間已經超過了有效時間），客戶端應該在所有的Redis例項上進行解鎖（即便某些Redis例項根本就沒有加鎖成功）。

4.2 解鎖

向所有的Redis例項傳送釋放鎖命令即可，不用關心之前有沒有從Redis例項成功獲取到鎖.

關於RedLock演算法，還有一個小插曲，就是Martin Kleppmann 和 RedLock 作者 antirez的對RedLock演算法的互懟。 官網原話如下

更多關於RedLock演算法這裡就不在說明，有興趣的可以到官網閱讀相關文章。

5 總結

這篇文章講述了一個基於Redis的分散式鎖的編寫過程及解決問題的思路，但是本篇文章實現的分散式鎖並不適合用於生產環境。java環境有 Redisson 可用於生產環境，但是分散式鎖還是Zookeeper會比較好一些（可以看Martin Kleppmann 和 RedLock的分析）。

整個專案的地址存放在Github上，有需要的可以看看：Github地址

相關推薦

基於redis的分散式鎖 | 併發程式設計網

1 介紹 這篇博文講介紹如何一步步構建一個基於Redis的分散式鎖。會從最原始的版本開始，然後根據問題進行調整，最後完成一個較為合理的分散式鎖。 本篇文章會將分散式鎖的實現分為兩部分，一個是單機環境，另一個是叢集環境下的Redis鎖實現。在介紹分散式鎖的實現之前，先來了解下分散式鎖的一些資訊。 2 分散式

基於Redis分散式鎖（獲取鎖及解鎖）

　　目前幾乎很多大型網站及應用都是分散式部署的，分散式場景中的資料一致性問題一直是一個比較重要的話題。分散式的CAP理論告訴我們“任何一個分散式系統都無法同時滿足一致性(Consistency)、可用性(Availability)和分割槽容錯性(Partition tolerance)，最多隻能同時滿足兩項。

基於redis分散式鎖實現“秒殺”

最近在專案中遇到了類似“秒殺”的業務場景，在本篇部落格中，我將用一個非常簡單的demo，闡述實現所謂“秒殺”的基本思路。 業務場景 所謂秒殺，從業務角度看，是短時間內多個使用者“爭搶”資源，這裡的資源在大部分秒殺場景裡是商品；將業務抽象，技術角度看，秒殺就是

【隨筆】Java 基於Redis分散式鎖

定義介面 public interface IDistributedLock { boolean tryLock(String var1, Object var2); boolean tryLock(String var1, Object var2, i

基於redis分散式鎖

錯誤方法：setnx獲取鎖，拿到鎖用expire給鎖加一個過期時間，防止鎖忘記釋放。如果setnx執行之後expire執行之前，執行緒死掉，那鎖就永遠得不到釋放，發生死鎖。Long result = jedis.setnx(lockKey, requestId);if (re

基於Redis分散式鎖的正確開啟方式

分散式鎖是在分散式環境下（多個JVM程序）控制多個客戶端對某一資源的同步訪問的一種實現，與之相對應的是執行緒鎖，執行緒鎖控制的是同一個JVM程序內多個執行緒之間的同步。分散式鎖的一般實現方法是在應用伺服器之外通過一個共享的儲存伺服器儲存鎖資源，同一時刻只有一個客戶端能佔有鎖資源來完成。通常有基於Zookeep

基於SpringBoot AOP面向切面程式設計實現Redis分散式鎖

![](https://img2020.cnblogs.com/other/1815316/202007/1815316-20200708094430273-1467040799.png) **基於SpringBoot AOP面向切面程式設計實現Redis分散式鎖** **基於SpringBoot AOP面

基於官方推薦的Redisson實現Redis分散式鎖

RedLock 簡介 在不同程序需要互斥地訪問共享資源時，分散式鎖是一種非常有用的技術手段。實現高效的分散式鎖有三個屬性需要考慮： 安全屬性：互斥，不管什麼時候，只有一個客戶端持有鎖 效率屬性A:不會死鎖 效率屬性B：容錯，只要大多數redis節點能夠正常工作，客戶端端都能獲取和

高併發架構系列：分散式鎖的由來、特點及Redis分散式鎖的實現詳解

標題Redis記憶體回收機制 Redis的記憶體回收主要圍繞以下兩個方面： 1.Redis過期策略 刪除過期時間的key值 2.Redis淘汰策略 記憶體使用到達maxmemory上限時觸發記憶體淘汰資料 Redis的過期策略和記憶體淘汰策略不是一件事，實際研發中不要弄混淆了

基於AOP實現redis分散式鎖

如果你的系統是分散式叢集部署的，那麼傳統的synchorinzed或者jdk1.5提供的Lock都是依賴本地的jvm虛擬機器提供鎖服務，分散式服務中多jvm是無法同享鎖資訊的，故無法提供鎖。 分散式場景中資料一致性問題一直是一個比較重要的話題。分散式的CAP理論告訴我們任何一

redis分散式鎖處理併發問題

redis鎖處理併發問題 redis鎖處理高併發問題十分常見，使用的時候常見有幾種錯誤，和對應的解決辦法，在此進行自己的總結和整理。 set方式 setnx方式 setnx+getset方式 set方式 作為redis小白，一開始能想到的使用redi

使用redis分散式鎖解決併發執行緒資源共享問題

眾所周知, 在多執行緒中，因為共享全域性變數,會導致資源修改結果不一致，所以需要加鎖來解決這個問題，保證同一時間只有一個執行緒對資源進行操作 但是在分散式架構中，我們的服務可能會有n個例項，但執行緒鎖只對同一個例項有效，就需要用到分散式鎖----redis setnx   原理： 　　修改某

如何設計redis分散式鎖

文章目錄 分散式鎖的實現有哪些？ 1.Memcached分散式鎖 2.Redis分散式鎖 3.Zookeeper分散式鎖 4.Chubby 如何用Redis實現分散式鎖？ 1.加鎖 2.解鎖

註解形式實現,Redis分散式鎖

Redis工具類參考我的博文:https://blog.csdn.net/weixin_38399962/article/details/82753763 一個註解就可以實現分散式鎖?這麼神奇麼? 首先定義註解: /** * Description:分散式Redis鎖 * User:

redis分散式鎖的實現方式

    前言：分散式鎖的實現方式一般有三種，1：基於資料庫的樂觀鎖。2：基於redis的分散式鎖。3：基於zk的分散式鎖，本文主要介紹第二種實現，由於以前一直是單機寫筆記，所以第一次寫有寫的不好的地方歡迎大家指正。     網上對於redis分散式鎖的實現

Redis實踐 -使用Redis分散式鎖

使用Redis來實現分散式鎖 public class LockTest { private final Jedis jedis; public LockTest() { jedis=new Jedis("localhost",6379); je

redis-分散式鎖的正確實現方式

分散式鎖一般有三種實現方式：1. 資料庫樂觀鎖；2. 基於Redis的分散式鎖；3. 基於ZooKeeper的分散式鎖。本篇部落格將介紹第二種方式，基於Redis實現分散式鎖。雖然網上已經有各種介紹Redis分散式鎖實現的部落格，然而他們的實現卻有著各種各樣的問題，為了避免誤人子弟，本篇部落格將詳細

Redis 分散式鎖(二)

續上篇 Redis 分散式鎖 超時問題 Redis 的分散式鎖不能解決超時問題，如果在加鎖和釋放鎖之間的邏輯執行的太長，以至於超出了鎖的超時限制，就會出現問題。因為這時候鎖A過期了，第二個執行緒重新持有了這把鎖A，但是緊接著第一個執行緒執行完了業務邏輯，就把鎖A給釋放了,問題是第

redis - 分散式鎖的正確實現方式2

分散式應用進行邏輯處理時經常會遇到併發問題。 比如一個操作要修改使用者的狀態，修改狀態需要先讀出使用者的狀態，在記憶體裡進行修改，改完了再存回去。如果這樣的操作同時進行了，就會出現併發問題，因為讀取和儲存狀態這兩個操作不是原子的。（Wiki 解釋：所謂原子操作是指不會被執行緒排程機制打斷的操作；

redis - 分散式鎖的正確實現方式

前言 分散式鎖一般有三種實現方式：1. 資料庫樂觀鎖；2. 基於Redis的分散式鎖；3. 基於ZooKeeper的分散式鎖。本篇部落格將介紹第二種方式，基於Redis實現分散式鎖。雖然網上已經有各種介紹Redis分散式鎖實現的部落格，然而他們的實現卻有著各種各樣的問題，為了避免誤人子弟，本篇部