高并發場景下一種比讀寫鎖更快的鎖，看完我徹底折服了！！（建議收藏）-有解無憂

大家好，我是冰河~~

最近公司的事情比較多，拖了很久的書稿終于和貓大人一起在這個周末寫完了，總體就一個字：累，剩下的就是對稿件的修修補補了，后面的進度就應該會很快了，前段時間原本想著續更【精通高并發系列】專題，一直沒時間，所以，這個事情也被一直擱淺著，現在，書稿寫完了，就有一些時間續更這個專題了，之前，我把【精通高并發系列】專題的文章整理成了一本電子書——《深入理解高并發編程》，全書內容如下所示，

這本電子書全網一度下載高達 35W+，目前這個數字仍然在上升，如果你還沒下載的話，那就在 CSDN 私信我回復 并發編程 領取下載鏈接吧，

從今天開始，我們繼續更新【精通高并發系列】專題，今天為大家介紹一個在高并發環境下，比讀寫鎖性能更高的鎖，可能很多小伙伴都不知道StampedLock是啥，至少我身邊的很多小伙伴都沒使用過StampedLock鎖，今天，我們就一起來聊聊這個在高并發環境下比ReadWriteLock更快的鎖——StampedLock，

什么是StampedLock?

ReadWriteLock鎖允許多個執行緒同時讀取共享變數，但是在讀取共享變數的時候，不允許另外的執行緒多共享變數進行寫操作，更多的適合于讀多寫少的環境中，那么，在讀多寫少的環境中，有沒有一種比ReadWriteLock更快的鎖呢？

答案當然是有！那就是我們今天要介紹的主角——JDK1.8中新增的StampedLock！沒錯，就是它！

StampedLock與ReadWriteLock相比，在讀的程序中也允許后面的一個執行緒獲取寫鎖對共享變數進行寫操作，為了避免讀取的資料不一致，使用StampedLock讀取共享變數時，需要對共享變數進行是否有寫入的檢驗操作，并且這種讀是一種樂觀讀，

總之，StampedLock是一種在讀取共享變數的程序中，允許后面的一個執行緒獲取寫鎖對共享變數進行寫操作，使用樂觀讀避免資料不一致的問題，并且在讀多寫少的高并發環境下，比ReadWriteLock更快的一種鎖，

StampedLock三種鎖模式

這里，我們可以簡單對比下StampedLock與ReadWriteLock，ReadWriteLock支持兩種鎖模式：一種是讀鎖，另一種是寫鎖，并且ReadWriteLock允許多個執行緒同時讀共享變數，在讀時，不允許寫，在寫時，不允許讀，讀和寫是互斥的，所以，ReadWriteLock中的讀鎖，更多的是指悲觀讀鎖，

StampedLock支持三種鎖模式：寫鎖、讀鎖（這里的讀鎖指的是悲觀讀鎖）和樂觀讀（很多資料和書籍寫的是樂觀讀鎖，這里我個人覺得更準確的是樂觀讀，為啥呢？我們繼續往下看啊），其中，寫鎖和讀鎖與ReadWriteLock中的語意類似，允許多個執行緒同時獲取讀鎖，但是只允許一個執行緒獲取寫鎖，寫鎖和讀鎖也是互斥的，

另一個與ReadWriteLock不同的地方在于：StampedLock在獲取讀鎖或者寫鎖成功后，都會回傳一個Long型別的變數，之后在釋放鎖時，需要傳入這個Long型別的變數，例如，下面的偽代碼所示的邏輯演示了StampedLock如何獲取鎖和釋放鎖，

public class StampedLockDemo{
    //創建StampedLock鎖物件
    public StampedLock stampedLock = new StampedLock();
    
    //獲取、釋放讀鎖
    public void testGetAndReleaseReadLock(){
        long stamp = stampedLock.readLock();
        try{
            //執行獲取讀鎖后的業務邏輯
        }finally{
            //釋放鎖
            stampedLock.unlockRead(stamp);
        }
    }
    
    //獲取、釋放寫鎖
    public void testGetAndReleaseWriteLock(){
        long stamp = stampedLock.writeLock();
        try{
            //執行獲取寫鎖后的業務邏輯，
        }finally{
            //釋放鎖
            stampedLock.unlockWrite(stamp);
        }
    }
}

StampedLock支持樂觀讀，這是它比ReadWriteLock性能要好的關鍵所在， ReadWriteLock在讀取共享變數時，所有對共享變數的寫操作都會被阻塞，而StampedLock提供的樂觀讀，在多個執行緒讀取共享變數時，允許一個執行緒對共享變數進行寫操作，

我們再來看一下JDK官方給出的StampedLock示例，如下所示，

class Point {
    private double x, y;
    private final StampedLock sl = new StampedLock();

    void move(double deltaX, double deltaY) { // an exclusively locked method
        long stamp = sl.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            sl.unlockWrite(stamp);
        }
    }

    double distanceFromOrigin() { // A read-only method
        long stamp = sl.tryOptimisticRead();
        double currentX = x, currentY = y;
        if (!sl.validate(stamp)) {
            stamp = sl.readLock();
            try {
                currentX = x;
                currentY = y;
            } finally {
                sl.unlockRead(stamp);
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }

    void moveIfAtOrigin(double newX, double newY) { // upgrade
        // Could instead start with optimistic, not read mode
        long stamp = sl.readLock();
        try {
            while (x == 0.0 && y == 0.0) {
                long ws = sl.tryConvertToWriteLock(stamp);
                if (ws != 0L) {
                    stamp = ws;
                    x = newX;
                    y = newY;
                    break;
                }
                else {
                    sl.unlockRead(stamp);
                    stamp = sl.writeLock();
                }
            }
        } finally {
            sl.unlock(stamp);
        }
    }
}

在上述代碼中，如果在執行樂觀讀操作時，另外的執行緒對共享變數進行了寫操作，則會把樂觀讀升級為悲觀讀鎖，如下代碼片段所示，

double distanceFromOrigin() { // A read-only method
    //樂觀讀
    long stamp = sl.tryOptimisticRead();
    double currentX = x, currentY = y;
    //判斷是否有執行緒對變數進行了寫操作
    //如果有執行緒對共享變數進行了寫操作
    //則sl.validate(stamp)會回傳false
    if (!sl.validate(stamp)) {
        //將樂觀讀升級為悲觀讀鎖
        stamp = sl.readLock();
        try {
            currentX = x;
            currentY = y;
        } finally {
            //釋放悲觀鎖
            sl.unlockRead(stamp);
        }
    }
    return Math.sqrt(currentX * currentX + currentY * currentY);
}

這種將樂觀讀升級為悲觀讀鎖的方式相比一直使用樂觀讀的方式更加合理，如果不升級為悲觀讀鎖，則程式會在一個回圈中反復執行樂觀讀操作，直到樂觀讀操作期間沒有執行緒執行寫操作，而在回圈中不斷的執行樂觀讀會消耗大量的CPU資源，升級為悲觀讀鎖是更加合理的一種方式，

StampedLock實作思想

StampedLock內部是基于CLH鎖實作的，CLH是一種自旋鎖，能夠保證沒有“饑餓現象”的發生，并且能夠保證FIFO（先進先出）的服務順序，

在CLH中，鎖維護一個等待執行緒佇列，所有申請鎖，但是沒有成功的執行緒都會存入這個佇列中，每一個節點代表一個執行緒，保存一個標記位(locked)，用于判斷當前執行緒是否已經釋放鎖，當locked標記位為true時，表示獲取到鎖，當locked標記位為false時，表示成功釋放了鎖，

當一個執行緒試圖獲得鎖時，取得等待佇列的尾部節點作為其前序節點，并使用類似如下代碼判斷前序節點是否已經成功釋放鎖:

while (pred.locked) {
    //省略操作 
}

只要前序節點(pred)沒有釋放鎖，則表示當前執行緒還不能繼續執行，因此會自旋等待；反之，如果前序執行緒已經釋放鎖，則當前執行緒可以繼續執行，

釋放鎖時，也遵循這個邏輯，執行緒會將自身節點的locked位置標記為false，后續等待的執行緒就能繼續執行了，也就是已經釋放了鎖，

StampedLock的實作思想總體來說，還是比較簡單的，這里就不展開講了，

StampedLock的注意事項

在讀多寫少的高并發環境下，StampedLock的性能確實不錯，但是它不能夠完全取代ReadWriteLock，在使用的時候，也需要特別注意以下幾個方面，

StampedLock不支持重入

沒錯，StampedLock是不支持重入的，也就是說，在使用StampedLock時，不能嵌套使用，這點在使用時要特別注意，

StampedLock不支持條件變數

第二個需要注意的是就是StampedLock不支持條件變數，無論是讀鎖還是寫鎖，都不支持條件變數，

StampedLock使用不當會導致CPU飆升

這點也是最重要的一點，在使用時需要特別注意：如果某個執行緒阻塞在StampedLock的readLock()或者writeLock()方法上時，此時呼叫阻塞執行緒的interrupt()方法中斷執行緒，會導致CPU飆升到100%，例如，下面的代碼所示，

public void testStampedLock() throws Exception{
    final StampedLock lock = new StampedLock();
    Thread thread01 = new Thread(()->{
        // 獲取寫鎖
        lock.writeLock();
        // 永遠阻塞在此處，不釋放寫鎖
        LockSupport.park();
    });
    thread01.start();
    // 保證thread01獲取寫鎖
    Thread.sleep(100);
    Thread thread02 = new Thread(()->
                           //阻塞在悲觀讀鎖
                           lock.readLock()
                          );
    thread02.start();
    // 保證T2阻塞在讀鎖
    Thread.sleep(100);
    //中斷執行緒thread02
    //會導致執行緒thread02所在CPU飆升
    thread02.interrupt();
    thread02.join();
}

運行上面的程式，會導致thread02執行緒所在的CPU飆升到100%，

這里，有很多小伙伴不太明白為啥LockSupport.park();會導致thread01會永遠阻塞，這里，冰河為你畫了一張執行緒的生命周期圖，如下所示，

這下明白了吧？在執行緒的生命周期中，有幾個重要的狀態需要說明一下，

NEW：初始狀態，執行緒被構建，但是還沒有呼叫start()方法，
RUNNABLE：可運行狀態，可運行狀態可以包括：運行中狀態和就緒狀態，
BLOCKED：阻塞狀態，處于這個狀態的執行緒需要等待其他執行緒釋放鎖或者等待進入synchronized，
WAITING：表示等待狀態，處于該狀態的執行緒需要等待其他執行緒對其進行通知或中斷等操作，進而進入下一個狀態，
TIME_WAITING：超時等待狀態，可以在一定的時間自行回傳，
TERMINATED：終止狀態，當前執行緒執行完畢，

看完這個執行緒的生命周期圖，知道為啥呼叫LockSupport.park();會使thread02阻塞了吧？

所以，在使用StampedLock時，一定要注意避免執行緒所在的CPU飆升的問題，那如何避免呢？

那就是使用StampedLock的readLock()方法或者讀鎖和使用writeLock()方法獲取寫鎖時，一定不要呼叫執行緒的中斷方法來中斷執行緒，如果不可避免的要中斷執行緒的話，一定要用StampedLock的readLockInterruptibly()方法獲取可中斷的讀鎖和使用StampedLock的writeLockInterruptibly()方法獲取可中斷的悲觀寫鎖，

最后，對于StampedLock的使用，JDK官方給出的StampedLock示例本身就是一個最佳實踐了，小伙伴們可以多看看JDK官方給出的StampedLock示例，多多體會下StampedLock的使用方式和背后原理與核心思想，

寫在最后

如果你想進大廠，想升職加薪，或者對自己現有的作業比較迷茫，都可以私信我交流，希望我的一些經歷能夠幫助到大家~~

推薦閱讀：

《全網最全性能優化總結！！（冰河吐血整理，建議收藏）》
《三天擼完了MyBatis，各位隨便問！！（冰河吐血整理，建議收藏）》
《奉勸那些剛參加作業的學弟學妹們：要想進大廠，這些核心技能是你必須要掌握的！完整學習路線！！（建議收藏）》
《奉勸那些剛參加作業的學弟學妹們：這些計算機與作業系統基礎知識越早知道越好！萬字長文太頂了！！（建議收藏）》
《我用三天時間開發了一款老少皆宜的國民級游戲，支持播放音樂，現開放完整源代碼和注釋（建議收藏）！！》
《我是全網最硬核的高并發編程作者，CSDN最值得關注的博主，大家同意嗎？（建議收藏）》
《畢業五年，從月薪3000到年薪百萬，我掌握了哪些核心技能？（建議收藏）》
《我入侵了隔壁妹子的Wifi，發現，，，（全程實戰干貨，建議收藏）》
《千萬不要輕易嘗試“熊貓燒香”，這不，我后悔了！》
《清明節偷偷訓練“熊貓燒香”，結果我的電腦為熊貓“獻身了”！》
《7.3萬字肝爆Java8新特性，我不信你能看完！（建議收藏）》
《在業務高峰期拔掉服務器電源是一種怎樣的體驗？》
《全網最全Linux命令總結！！（史上最全，建議收藏）》
《用Python寫了個工具，完美破解了MySQL！！（建議收藏）》
《SimpleDateFormat類到底為啥不是執行緒安全的？（附六種解決方案，建議收藏）》

好了，今天就到這兒吧，小伙伴們點贊、收藏、評論，一鍵三連走起呀，我是冰河，我們下期見~~

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/289355.html

標籤：其他

上一篇：創業擼Java多年，老王準備換50萬的車了

下一篇：那些被裁掉的大齡程式員，為什么不聯合起來成立一個專收大齡程式員的公司？