自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

一文看懂JUC之AQS機制

作者：佚名
開發(fā) 后端
本文注重講解其不同衍生類的使用場景以及其內(nèi)部AQS的原理。

 為了解決原子性的問題，Java加入了鎖機制，同時保證了可見性和順序性。JDK1.5的并發(fā)包中新增了Lock接口以及相關(guān)實現(xiàn)類來實現(xiàn)鎖功能，比synchronized更加靈活，開發(fā)者可根據(jù)實際的場景選擇相應(yīng)的實現(xiàn)類。

本文注重講解其不同衍生類的使用場景以及其內(nèi)部AQS的原理。并發(fā)問題引入以及synchronized相關(guān)的知識請看上一篇文章一文看懂Java鎖機制。

Lock特性

可重入

像synchronized和ReentrantLock都是可重入鎖，可重入性表明了鎖的分配機制是基于線程的分配，而不是基于方法調(diào)用的分配。

舉個簡單的例子，當(dāng)一個線程已經(jīng)獲取到鎖，當(dāng)后續(xù)再獲取同一個鎖，直接獲取成功。但獲取鎖和釋放鎖必須要成對出現(xiàn)。

可響應(yīng)中斷

當(dāng)線程因為獲取鎖而進入阻塞狀態(tài)，外部是可以中斷該線程的，調(diào)用方通過捕獲InterruptedException可以捕獲中斷

可設(shè)置超時時間

獲取鎖時，可以指定超時時間，可以通過返回值來判斷是否成功獲取鎖

公平性

提供公平性鎖和非公平鎖（默認(rèn)）兩種選擇。

  •  公平鎖，線程將按照他們發(fā)出請求的順序來獲取鎖，不允許插隊；
  •  非公平鎖，則允許插隊：當(dāng)一個線程發(fā)生獲取鎖的請求的時刻，如果這個鎖是可用的，那這個線程將跳過所在隊列里等待線程并獲得鎖。

考慮這么一種情況：A線程持有鎖，B線程請求這個鎖，因此B線程被掛起；A線程釋放這個鎖時，B線程將被喚醒，因此再次嘗試獲取鎖；與此同時，C線程也請求獲取這個鎖，那么C線程很可能在B線程被完全喚醒之前獲得、使用以及釋放這個鎖。

這是種雙贏的局面，B獲取鎖的時刻（B被喚醒后才能獲取鎖）并沒有推遲，C更早地獲取了鎖，并且吞吐量也獲得了提高。在大多數(shù)情況下，非公平鎖的性能要高于公平鎖的性能。

另外，這個公平性是針對線程而言的，不能依賴此來實現(xiàn)業(yè)務(wù)上的公平性，應(yīng)該由開發(fā)者自己控制，比如通過FIFO隊列來保證公布。

讀寫鎖

允許讀鎖和寫鎖分離，讀鎖與寫鎖互斥，但是多個讀鎖可以共存，適用于讀頻次遠(yuǎn)大于寫頻次的場景

豐富的API

提供了多個方法來獲取鎖相關(guān)的信息，可以幫助開發(fā)者監(jiān)控和排查問題

  •  isFair()：判斷鎖是否是公平鎖
  •  isLocked()：判斷鎖是否被任何線程獲取了
  •  isHeldByCurrentThread()：判斷鎖是否被當(dāng)前線程獲取了
  •  hasQueuedThreads()：判斷是否有線程在等待該鎖
  •  getHoldCount()：查詢當(dāng)前線程占有l(wèi)ock鎖的次數(shù)
  •  getQueueLength()：獲取正在等待此鎖的線程數(shù)

鎖的使用

ReentrantLock

獨占鎖的實現(xiàn)，擁有上面列舉的除讀寫鎖之外的所有特性，使用比較簡單 

  1. class X {  
  2.    // 創(chuàng)建獨占鎖實例  
  3.    private final ReentrantLock lock = new ReentrantLock();  
  4.    // ...  
  5.    public void m() {  
  6.      lock.lock();  // block until condition holds  
  7.      try {  
  8.        // ... method body  
  9.      } finally {  
  10.        // 必須要釋放鎖，unlock與lock成對出現(xiàn)  
  11.        lock.unlock()  
  12.      } 
  13.    }  
  14.  } 

ReentrantReadWriteLock

讀寫鎖的實現(xiàn)，擁有上面列舉的所有特性。并且寫鎖可降級為讀鎖，反之不行。 

  1. class CachedData {  
  2.    Object data;  
  3.    volatile boolean cacheValid;  
  4.    final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();  
  5.    void processCachedData() {  
  6.      rwl.readLock().lock();  
  7.      if (!cacheValid) {  
  8.        // Must release read lock before acquiring write lock  
  9.        rwl.readLock().unlock();  
  10.        rwl.writeLock().lock(); 
  11.         try {  
  12.          // Recheck state because another thread might have  
  13.          // acquired write lock and changed state before we did.  
  14.          if (!cacheValid) {  
  15.            data = ...  
  16.            cacheValid = true;  
  17.          }  
  18.          // Downgrade by acquiring read lock before releasing write lock  
  19.          rwl.readLock().lock();  
  20.        } finally { 
  21.          rwl.writeLock().unlock(); // Unlock write, still hold read  
  22.        }  
  23.      }  
  24.      try {  
  25.        use(data);  
  26.      } finally {  
  27.        rwl.readLock().unlock();  
  28.      }  
  29.    }  
  30.  } 

StampedLock

StampedLock也是一種讀寫鎖，提供兩種讀模式：樂觀讀和悲觀讀。樂觀讀允許讀的過程中也可以獲取寫鎖后寫入！這樣一來，我們讀的數(shù)據(jù)就可能不一致，所以，需要一點額外的代碼來判斷讀的過程中是否有寫入。

樂觀鎖的意思就是樂觀地估計讀的過程中大概率不會有寫入，因此被稱為樂觀鎖。反過來，悲觀鎖則是讀的過程中拒絕有寫入，也就是寫入必須等待。顯然樂觀鎖的并發(fā)效率更高，但一旦有小概率的寫入導(dǎo)致讀取的數(shù)據(jù)不一致，需要能檢測出來，再讀一遍就行。 

  1. public class Point {  
  2.     private final StampedLock stampedLock = new StampedLock();  
  3.     private double x;  
  4.     private double y; 
  5.     public void move(double deltaX, double deltaY) {  
  6.         long stamp = stampedLock.writeLock(); // 獲取寫鎖  
  7.         try {  
  8.             x += deltaX;  
  9.             y += deltaY;  
  10.         } finally {  
  11.             stampedLock.unlockWrite(stamp); // 釋放寫鎖  
  12.         }  
  13.     }  
  14.     public double distanceFromOrigin() { 
  15.         long stamp = stampedLock.tryOptimisticRead(); // 獲得一個樂觀讀鎖  
  16.         // 注意下面兩行代碼不是原子操作  
  17.         // 假設(shè)x,y = (100,200)  
  18.         double currentX = x;  
  19.         // 此處已讀取到x=100，但x,y可能被寫線程修改為(300,400)  
  20.         double currentY = y;  
  21.         // 此處已讀取到y(tǒng)，如果沒有寫入，讀取是正確的(100,200)  
  22.         // 如果有寫入，讀取是錯誤的(100,400)  
  23.         if (!stampedLock.validate(stamp)) { // 檢查樂觀讀鎖后是否有其他寫鎖發(fā)生  
  24.             stamp = stampedLock.readLock(); // 獲取一個悲觀讀鎖  
  25.             try {  
  26.                 currentX = x;  
  27.                 currentY = y;  
  28.             } finally {  
  29.                 stampedLock.unlockRead(stamp); // 釋放悲觀讀鎖 
  30.             }  
  31.         }  
  32.         return Math.sqrt(currentX * currentX + currentY * currentY);  
  33.     }  
  34. } 

Condition

Condition成為條件隊列或條件變量，為一個線程掛起執(zhí)行（等待）提供了一種方法，直到另一線程通知某些狀態(tài)條件現(xiàn)在可能為真為止。由于對該共享狀態(tài)信息的訪問發(fā)生在不同的線程中，因此必須由互斥鎖對其其進行保護。

await方法：必須在獲取鎖之后的調(diào)用，表示釋放當(dāng)前鎖，阻塞當(dāng)前線程；等待其他線程調(diào)用鎖的signal或signalAll方法，線程喚醒重新獲取鎖。

Lock配合Condition，可以實現(xiàn)synchronized 與 對象（wait，notify）同樣的效果，來進行線程間基于共享變量的通信。但優(yōu)勢在于同一個鎖可以由多個條件隊列，當(dāng)某個條件滿足時，只需要喚醒對應(yīng)的條件隊列即可，避免無效的競爭。 

  1. // 此類實現(xiàn)類似阻塞隊列（ArrayBlockingQueue）  
  2. class BoundedBuffer {  
  3.  final Lock lock = new ReentrantLock();  
  4.  final Condition notFull  = lock.newCondition();   
  5.  final Condition notEmpty = lock.newCondition();   
  6.  final Object[] items = new Object[100];  
  7.  int putptr, takeptr, count;  
  8.  public void put(Object x) throws InterruptedException {  
  9.    lock.lock();  
  10.    try {  
  11.      while (count == items.length)  
  12.        notFull.await();  
  13.      items[putptr] = x;  
  14.      if (++putptr == items.length) putptr = 0;  
  15.      ++count;  
  16.      notEmpty.signal();  
  17.    } finally {  
  18.      lock.unlock();  
  19.    }  
  20.  }  
  21.  public Object take() throws InterruptedException {  
  22.    lock.lock();  
  23.    try {  
  24.      while (count == 0)  
  25.        notEmpty.await();  
  26.      Object x = items[takeptr];  
  27.      if (++takeptr == items.length) takeptr = 0;  
  28.      --count;  
  29.      notFull.signal();  
  30.      return x;  
  31.    } finally {  
  32.      lock.unlock();  
  33.    }  
  34.  }  
  35. } 

BlockingQueue

BlockingQueue阻塞隊列實際上是一個生產(chǎn)者/消費者模型，當(dāng)隊列長度大于指定的最大值，生產(chǎn)線程就會被阻塞；反之當(dāng)隊列元素為空時，消費線程就會被阻塞；同時當(dāng)消費成功時，就會喚醒阻塞的生產(chǎn)者線程；生產(chǎn)成功就會喚醒消費者線程；

內(nèi)部使用就是ReentrantLock + Condition來實現(xiàn)的，可以參照上面的示例。

CountDownLatch

稱之為倒計時器鎖，初始化指定數(shù)值，調(diào)用countDown可以對數(shù)值減一，當(dāng)數(shù)值減為0時，就會喚醒所有因為調(diào)用await方法而阻塞的線程。

可以達到一組線程等待另外一組線程都完成任務(wù)的效果。 

  1. class Driver { // ...  
  2.    void main() throws InterruptedException { 
  3.      CountDownLatch startSignal = new CountDownLatch(1);  
  4.      CountDownLatch doneSignal = new CountDownLatch(N);  
  5.      for (int i = 0; i < N; ++i) // create and start threads  
  6.        new Thread(new Worker(startSignal, doneSignal)).start();  
  7.      doSomethingElse();            // don't let run yet  
  8.      startSignal.countDown();      // let all threads proceed  
  9.      doSomethingElse();  
  10.      doneSignal.await();           // wait for all to finish  
  11.    }  
  12. }  
  13. class Worker implements Runnable {  
  14.    private final CountDownLatch startSignal;  
  15.    private final CountDownLatch doneSignal;  
  16.    Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {  
  17.      this.startSignal = startSignal;  
  18.      this.doneSignal = doneSignal;  
  19.    }  
  20.    public void run() {  
  21.      try {  
  22.        startSignal.await();  
  23.        doWork();  
  24.        doneSignal.countDown(); 
  25.      } catch (InterruptedException ex) {} // return;  
  26.    }  
  27.    void doWork() { ... }  
  28. } 

CyclicBarrier

稱之為同步屏障，它使得一組線程互相等待，直到到達某個公共屏障點。

初始化指定數(shù)值，調(diào)用await方法會使得線程阻塞，直到指定數(shù)量的線程都調(diào)用await方法時，所有被阻塞的線程會被喚醒，繼續(xù)執(zhí)行。

與CountDownLatch的區(qū)別是，CountDownLatch是一組線程等待另外一組線程，而CyclicBarrier是一組線程之間相互等待。

Semaphore

稱之為信號量，與互斥鎖ReentrantLock用法類似，區(qū)別就是Semaphore共享的資源是多個，允許多個線程同時競爭成功。

AQS原理

AQS 是 AbstractQueuedSynchronizer的縮寫，中文 抽象隊列同步器，是構(gòu)建各類鎖和同步器的基礎(chǔ)實現(xiàn)。內(nèi)部維護了共享變量state （int類型） 和 雙向隊列 （包含頭指針和尾指針）

并發(fā)問題解決

原子性

Unsafe.compareAndSwapXXX 實現(xiàn)CAS更改 state 和 隊列指針 內(nèi)部依賴CPU提供的原子指令

可見性與有序性

volatile 修飾 state 與 隊列指針 （prev/next/head/tail）

線程阻塞與喚醒

Unsafe.park Unsafe.parkNanos Unsafe.unpark

Unsafe類是在sun.misc包下，不屬于Java標(biāo)準(zhǔn)。提供了內(nèi)存管理、對象實例化、數(shù)組操作、CAS操作、線程掛起與恢復(fù)等功能，Unsafe類提升了Java運行效率，增強了Java語言底層的操作能力。很多Java的基礎(chǔ)類庫，包括一些被廣泛使用的高性能開發(fā)庫都是基于Unsafe類開發(fā)的，比如Netty、Cassandra、Hadoop、Kafka等

AQS內(nèi)部有兩種模式：獨占模式和共享模式

AQS 的設(shè)計是基于模板方法的，使用者需要繼承 AQS 并重寫指定的方法。不同的自定義同步器爭用共享資源的方式不同，比如可重入、公平性等都是子類來實現(xiàn)。

自定義同步器在實現(xiàn)時只需要實現(xiàn)共享資源state的獲取與釋放方式即可，至于具體線程等待隊列的維護（如獲取資源失敗入隊/喚醒出隊等），由AQS內(nèi)部處理。

獨占模式

  •  只有一個線程都能夠獲取到鎖
  •  鎖釋放后需要喚醒后繼節(jié)點

AQS提供的獨占模式相關(guān)的方法 

  1. // 獲取獨占鎖（線程阻塞直至獲取成功）  
  2. public final void acquire(int)  
  3. // 獲取獨占鎖，可被中斷  
  4. public final void acquireInterruptibly(int)   
  5. // 獲取獨占鎖，可被中斷 和 指定超時時間  
  6. public final boolean tryAcquireNanos(int, long)   
  7. // 釋放獨占鎖（釋放鎖后，將等待隊列中第一個等待節(jié)點喚醒 ）  
  8. public final boolean release(int)  

AQS子類需要實現(xiàn)的獨占模式相關(guān)的方法 

  1. // 嘗試獲取獨占鎖  
  2. protected boolean tryAcquire(int)  
  3. // 嘗試釋放獨占鎖  
  4. protected boolean tryRelease(int) 

獲取獨占鎖的流程

  •  調(diào)用子類tryAcquire嘗試獲取鎖，獲取成功，直接返回
  •  通過自旋CAS將當(dāng)前線程封裝成節(jié)點加入隊列末尾
  •  循環(huán)等待或嘗試tryAcquire獲取鎖
    •   判斷前置節(jié)點如果為head，則嘗試獲取鎖
    •   根據(jù)隊列中節(jié)點狀態(tài)，決定是否需要阻塞當(dāng)前線程
    •   tryAcquire獲取鎖成功后，將當(dāng)前節(jié)點設(shè)置為head 并 返回
  •  如果當(dāng)前線程中斷或超時，則執(zhí)行cancelAcquire
    •   將當(dāng)前節(jié)點狀態(tài)置為CANCELED，并從隊列刪除
    •   如果前置節(jié)點為Head，則將后置節(jié)點喚醒

釋放獨占鎖的流程

共享模式

  •  多個線程都能夠獲取到鎖
  •  鎖釋放后需要喚醒后繼節(jié)點
  •  鎖獲取后如果還有資源需要喚醒后繼共享節(jié)點

AQS提供的共享模式相關(guān)的方法 

  1. // 獲取共享鎖（線程阻塞直至獲取成功）  
  2. public final void acquireShared(int)   
  3. // 獲取共享鎖，可被中斷  
  4. public final acquireSharedInterruptibly(int)   
  5. // 獲取共享鎖，可被中斷 和 指定超時時間  
  6. public final tryAcquireSharedNanos(int, long)    
  7. // 獲取共享鎖  
  8. public final boolean releaseShared(int)  

AQS子類需要實現(xiàn)的共享模式相關(guān)的方法 

  1. // 嘗試獲取共享鎖  
  2. protected int tryAcquireShared(int) 
  3. // 嘗試釋放共享鎖  
  4. protected boolean tryReleaseShared(int) 

獲取共享鎖的流程

1.調(diào)用子類tryAcquireShared嘗試獲取鎖，獲取成功，直接返回

2.通過自旋CAS將當(dāng)前線程封裝成節(jié)點加入隊列末尾

3.循環(huán)等待或嘗試tryAcquireShared獲取鎖

  •  判斷前置節(jié)點如果為head，則嘗試獲取鎖
  •  根據(jù)隊列中節(jié)點狀態(tài)，決定是否需要阻塞當(dāng)前線程
  •  tryAcquireShared獲取鎖成功后，將當(dāng)前節(jié)點設(shè)置為head
    •   如果資源有剩余或者原先的head節(jié)點狀態(tài)為SIGNAL/PROPAGATE，則調(diào)用doReleaseShared
    •   如果當(dāng)前head節(jié)點狀態(tài)為SIGNAL，喚醒后繼節(jié)點
    •   如果當(dāng)前head節(jié)點狀態(tài)為ZERO，將head節(jié)點狀態(tài)置為PROPAGATE
  •  如果當(dāng)前線程中斷或超時，則執(zhí)行cancelAcquire
    •   將當(dāng)前節(jié)點狀態(tài)置為CANCELED，并從隊列刪除
    •   如果前置節(jié)點為Head，則將后置節(jié)點喚醒

釋放共享鎖的流程

等待隊列中節(jié)點的狀態(tài)變化

ReentrantLock示例

tryAcquire邏輯

tryRelease邏輯

 

 

責(zé)任編輯：龐桂玉 來源： Java知音
JUCAQSJava
相關(guān)推薦

2021-05-12 15:16:17

JUCAQSJava

2022-04-26 13:41:16

區(qū)塊鏈比特幣數(shù)據(jù)庫

2021-08-30 11:13:28

內(nèi)存交換機制

2020-03-31 14:40:24

HashMap源碼Java

2016-08-18 00:21:12

網(wǎng)絡(luò)爬蟲抓取網(wǎng)絡(luò)

2024-08-12 12:30:27

2025-01-20 09:15:00

iOS 18.3蘋果iOS 18

2021-08-02 06:56:19

TypeScript編程語言編譯器

2019-07-01 09:22:15

Linux操作系統(tǒng)硬件

2019-05-22 09:50:42

Python沙箱逃逸網(wǎng)絡(luò)攻擊

2019-09-11 09:37:17

數(shù)據(jù)庫MySQL系統(tǒng)

2021-02-21 11:25:17

云計算IaaSPaaS

2024-10-10 17:55:57

LinuxACL訪問控制列表

2023-12-18 10:45:31

2019-02-13 15:38:09

存儲虛擬化云計算

2025-03-25 09:06:11

2023-04-10 11:35:31

評估模型業(yè)務(wù)流程

2022-12-07 07:38:07

存儲管理HSM

2024-12-30 07:30:00

PLC通訊協(xié)議

2022-03-29 08:02:01

數(shù)字孿生能源程序
點贊
收藏

51CTO技術(shù)棧公眾號