StampedLock：JDK1.8中新增，比ReadWriteLock還快的鎖

華為雲開發者聯盟發表於2023-04-07
JDK
摘要：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會永遠阻塞。這裡，冰河為你畫了一張執行緒的生命週期圖，如下所示。

StampedLock：JDK1.8中新增，比ReadWriteLock還快的鎖

這下明白了吧？線上程的生命週期中，有幾個重要的狀態需要說明一下。

  • 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的使用方式和背後原理與核心思想。

 

點選關注，第一時間瞭解華為雲新鮮技術~

相關文章