<sub id="gqw76"><listing id="gqw76"></listing></sub>
      <sub id="gqw76"><listing id="gqw76"></listing></sub>

    1. <form id="gqw76"><legend id="gqw76"></legend></form>
    2. 深入淺出ReentrantLock源碼解析

      ReentrantLock不但是可重入鎖,而且還是公平或非公平鎖,在工作中會經常使用到,將自己對這兩種鎖的理解記錄下來,希望對大家有幫助。

      前提條件

      在理解ReentrantLock時需要具備一些基本的知識

      理解AQS的實現原理

      之前有寫過一篇《深入淺出AQS源碼解析》關于AQS的文章,對AQS原理不了解的同學可以先看一下

      什么是可重入鎖

      當一個線程已經持有鎖,如果該現在再次獲取鎖,是否可以獲取成功?如果能獲取成功則說明該鎖是可重入的,否則是不可重入的

      什么是公平鎖和非公平鎖

      公平與非公平的一個很本質的區別就是,是否遵守FIFO(也就是先來后到)。當有多個線程來申請鎖的時候,是否先申請的線程先獲取鎖,后申請的線程后獲取鎖?如果是的,則是公平鎖,否則是非公平鎖

      更準確地說,先申請鎖的線程先獲得鎖競爭的權利。對于公平的排他鎖而言,先申請鎖的線程會先獲取鎖,但是對于公平的共享鎖而言,先申請鎖的線程會先擁有獲取鎖競爭的權利,其他等待共享鎖的線程也會被喚醒,有可能后喚醒的線程先獲取鎖。

      ReentrantLock 源碼解析

      ReentrantLock的功能主要是通過3個內部類SyncFairSyncNonfairSync來實現的,這3個內部類繼承了AbstractQueuedSynchronizer,其中FairSyncNonfairSync類繼承了Sync,接下來我們一一解讀這幾個內部類。

      ReentrantLock.Sync類源碼解析

      由于ReentrantLock.Sync類中的核心代碼比較少,原理也比較簡單,所以就直接在代碼中通過詳細注釋的方式來解讀

      abstract static class Sync extends AbstractQueuedSynchronizer {
      
          /**
           * 定義了一個抽象方法,用來獲取鎖
           */
          abstract void lock();
      
          /**
           * NonfairSync中tryAcquire和、ReentrantLock.tryLock會使用到
           * 重要功能:快速嘗試獲取鎖,如果能夠獲取鎖返回true,否則返回false
           * 在嘗試獲取鎖的過程中,不會阻塞當前線程,一般情況下是當前線程已經持有鎖時
           * 才有可能是可以直接獲取鎖,這也是可重入功能的核心實現
           */
          final boolean nonfairTryAcquire(int acquires) {
              // 獲取當前線程
              final Thread current = Thread.currentThread();
              /**
               * state是AQS對外提供的一個變量,讓不同的實現類可以通過這個變量
               * 來控制鎖被線程獲取鎖的次數
               */
              int c = getState();
              // 當state為0表示該鎖是沒有被任何線程持有
              if (c == 0) {
                 /**
                  * CAS操作如果成功,說明當前線程競爭到了鎖資源,
                  * 否則被其他線程競爭到了,當前線程需要進入AQS的同步隊列
                  * 對于嘗試修改state的值的線程可以同時是多個,
                  * 他們之間沒有先后順序,這也是非公平的重要體現
                  */
                  if (compareAndSetState(0, acquires)) {
                    /**
                      * 當前線程已經持有鎖了,設置鎖的占有者
                      */
                      setExclusiveOwnerThread(current);
                      return true;
                  }
              }
            /**
              * 如果持有鎖的線程是當前線程,可以繼續嘗試獲取鎖
              * 這也是可重入的重要體現
              */
              else if (current == getExclusiveOwnerThread()) {
                  int nextc = c + acquires;
                 /**
                  * state是int類型,也就是可重入次數不能低于Integer.MAX_VALUE
                  */
                  if (nextc < 0) // overflow
                      throw new Error("Maximum lock count exceeded");
                 /**
                  * 獲取鎖以后直接設置state的值
                  */
                  setState(nextc);
                  return true;
              }
             /**
              * 如果一個線程既不是第一次獲取鎖,又不是已經獲取鎖,
              * 則該線程無法獲取鎖,需要進入AQS的同步隊列排隊
              */
              return false;
          }
      
          protected final boolean tryRelease(int releases) {
             /**
              * 計算釋放releases個資源后state的值
              */
              int c = getState() - releases;
             /**
              * 持有鎖的線程如果不是當前線程,無法釋放資源
              */
              if (Thread.currentThread() != getExclusiveOwnerThread())
                  throw new IllegalMonitorStateException();
              boolean free = false;
             /**
              * 當所有的資源全部釋放掉(c=0)時,鎖的持有者需要設置為null,
              * 讓后續線程可以來競爭鎖
              */
              if (c == 0) {
                  free = true;
                  setExclusiveOwnerThread(null);
              }
             /**
              * 修改state的狀態
              */
              setState(c);
              return free;
          }
      
          protected final boolean isHeldExclusively() {
              /**
              * 當前線程是否持有鎖
              */
              return getExclusiveOwnerThread() == Thread.currentThread();
          }
      
      

      ReentrantLock.NonfairSync類源碼解析

      static final class NonfairSync extends Sync {
          /**
           * 非公平鎖,對外獲取鎖的步驟:
           * 首先,嘗試修改state的狀態(從0修改成1),如果修改成功說明當前沒有任何線程持有鎖
           * 如果線程獲取到鎖,則把鎖的持有線程設置為當前線程
           * 如果無法獲取鎖,說明鎖已經被線程持有,有兩種情況:
           * 情況1:持有鎖的線程是當前線程,可以走可重入的流程
           * 情況2:持有鎖的線程不是當前線程,需要進入AQS去排隊
           */
          final void lock() {
              if (compareAndSetState(0, 1))
                  setExclusiveOwnerThread(Thread.currentThread());
              else
                  acquire(1);
          }
      
          /**
           * 嘗試快速獲取鎖
           */
          protected final boolean tryAcquire(int acquires) {
              return nonfairTryAcquire(acquires);
          }
      }
      

      ReentrantLock.FairSync類源碼解析

      static final class FairSync extends Sync {
          /**
           * 阻塞方式獲取鎖
           */
          final void lock() {
              acquire(1);
          }
      
          /**
           * 嘗試獲取公平鎖,與上面分析的nonfairTryAcquire方法很類似,
           * 重點描述彼此之間的區別
           */
          protected final boolean tryAcquire(int acquires) {
              final Thread current = Thread.currentThread();
              int c = getState();
              if (c == 0) {
                  /**
                   * 公平鎖與非公平鎖很大的一個區別是:
                   * 在嘗試獲取鎖的時候,如果AQS的同步隊列中有其他線程在等待獲取鎖
                   * 則嘗試獲取鎖失敗,需要進入AQS的同步隊列排隊
                   * hasQueuedPredecessors方法判斷AQS的同步隊列是否有線程在等待
                   */
                  if (!hasQueuedPredecessors() &&
                      compareAndSetState(0, acquires)) {
                      setExclusiveOwnerThread(current);
                      return true;
                  }
              }
              else if (current == getExclusiveOwnerThread()) {
                  int nextc = c + acquires;
                  if (nextc < 0)
                      throw new Error("Maximum lock count exceeded");
                  setState(nextc);
                  return true;
              }
              return false;
          }
      }
      

      ReentrantLock類源碼解析

      ReentrantLock類的實現方式比較簡單,主要是依靠NonfairSyncFairSync實現的功能

      public class ReentrantLock implements Lock, java.io.Serializable {
      
          private final Sync sync;
      
          /**
           * 默認是非公平鎖
           */
          public ReentrantLock() {
              sync = new NonfairSync();
          }
      
          /**
           * 獲取鎖,獲取的時候申請1個資源
           */
          public void lock() {
              sync.lock();
          }
      
          /**
           * 可中斷的方式獲取鎖
           */
          public void lockInterruptibly() throws InterruptedException {
              sync.acquireInterruptibly(1);
          }
      
          /**
           * 
           * 嘗試獲取鎖,公平鎖和非公平鎖都是直接去嘗試獲取鎖
           * 一般在使用該方法的時候,如果嘗試獲取鎖失敗,會有后續操作,
           * 可能是直接調用lock以阻塞的方式來獲取鎖
           */
          public boolean tryLock() {
              return sync.nonfairTryAcquire(1);
          }
      
          /**
           * 帶有超時時間的方式嘗試獲取鎖
           */
          public boolean tryLock(long timeout, TimeUnit unit)
                  throws InterruptedException {
              return sync.tryAcquireNanos(1, unit.toNanos(timeout));
          }
      
          /**
           * 釋放鎖,釋放掉1個資源
           */
          public void unlock() {
              sync.release(1);
          }
      }
      

      總結

      • 對于已經持有鎖的線程,優先申請到資源
      • 對與沒有持有鎖的線程,需要等待持有鎖的線程釋放掉所有資源,包括可重入時申請到的資源
      • 公平鎖在申請資源的時候要先檢查AQS同步隊列中是否有等待的線程,也就線程獲取鎖是按照FIFO的方式
      posted @ 2020-07-15 16:00  PinXiong  閱讀(275)  評論(0編輯  收藏
      最新chease0ldman老人|无码亚洲人妻下载|大香蕉在线看好吊妞视频这里有精品www|亚洲色情综合网

        <sub id="gqw76"><listing id="gqw76"></listing></sub>
        <sub id="gqw76"><listing id="gqw76"></listing></sub>

      1. <form id="gqw76"><legend id="gqw76"></legend></form>