Java并發(fā)系列之AbstractQueuedSynchronizer源碼分析（共享模式）

更新時間：2018年02月27日 11:07:54 作者：勞夫子

這篇文章主要為大家詳細介紹了Java并發(fā)系列之AbstractQueuedSynchronizer源碼，具有一定的參考價值，感興趣的小伙伴們可以參考一下

通過上一篇的分析，我們知道了獨占模式獲取鎖有三種方式，分別是不響應(yīng)線程中斷獲取，響應(yīng)線程中斷獲取，設(shè)置超時時間獲取。在共享模式下獲取鎖的方式也是這三種，而且基本上都是大同小異，我們搞清楚了一種就能很快的理解其他的方式。雖然說AbstractQueuedSynchronizer源碼有一千多行，但是重復(fù)的也比較多，所以讀者不要剛開始的時候被嚇到，只要耐著性子去看慢慢的自然能夠漸漸領(lǐng)悟。就我個人經(jīng)驗來說，閱讀AbstractQueuedSynchronizer源碼有幾個比較關(guān)鍵的地方需要弄明白，分別是獨占模式和共享模式的區(qū)別，結(jié)點的等待狀態(tài)，以及對條件隊列的理解。理解了這些要點那么后續(xù)源碼的閱讀將會輕松很多。當然這些在我的《Java并發(fā)系列[1]----AbstractQueuedSynchronizer源碼分析之概要分析》這篇文章里都有詳細的介紹，讀者可以先去查閱。本篇對于共享模式的分析也是分為三種獲取鎖的方式和一種釋放鎖的方式。

1. 不響應(yīng)線程中斷的獲取

//以不可中斷模式獲取鎖(共享模式)
public final void acquireShared(int arg) {
  //1.嘗試去獲取鎖
  if (tryAcquireShared(arg) < 0) {
    //2.如果獲取失敗就進入這個方法
    doAcquireShared(arg);
  }
}

//嘗試去獲取鎖(共享模式)
//負數(shù)：表示獲取失敗
//零值：表示當前結(jié)點獲取成功, 但是后繼結(jié)點不能再獲取了
//正數(shù)：表示當前結(jié)點獲取成功, 并且后繼結(jié)點同樣可以獲取成功
protected int tryAcquireShared(int arg) {
  throw new UnsupportedOperationException();
}

調(diào)用acquireShared方法是不響應(yīng)線程中斷獲取鎖的方式。在該方法中，首先調(diào)用tryAcquireShared去嘗試獲取鎖，tryAcquireShared方法返回一個獲取鎖的狀態(tài)，這里AQS規(guī)定了返回狀態(tài)若是負數(shù)代表當前結(jié)點獲取鎖失敗，若是0代表當前結(jié)點獲取鎖成功，但后繼結(jié)點不能再獲取了，若是正數(shù)則代表當前結(jié)點獲取鎖成功，并且這個鎖后續(xù)結(jié)點也同樣可以獲取成功。子類在實現(xiàn)tryAcquireShared方法獲取鎖的邏輯時，返回值需要遵守這個約定。如果調(diào)用tryAcquireShared的返回值小于0，就代表這次嘗試獲取鎖失敗了，接下來就調(diào)用doAcquireShared方法將當前線程添加進同步隊列。我們看到doAcquireShared方法。

//在同步隊列中獲取(共享模式)
private void doAcquireShared(int arg) {
  //添加到同步隊列中
  final Node node = addWaiter(Node.SHARED);
  boolean failed = true;
  try {
    boolean interrupted = false;
    for (;;) {
      //獲取當前結(jié)點的前繼結(jié)點
      final Node p = node.predecessor();
      //如果前繼結(jié)點為head結(jié)點就再次嘗試去獲取鎖
      if (p == head) {
        //再次嘗試去獲取鎖并返回獲取狀態(tài)
        //r < 0, 表示獲取失敗
        //r = 0, 表示當前結(jié)點獲取成功, 但是后繼結(jié)點不能再獲取了
        //r > 0, 表示當前結(jié)點獲取成功, 并且后繼結(jié)點同樣可以獲取成功
        int r = tryAcquireShared(arg);
        if (r >= 0) {
          //到這里說明當前結(jié)點已經(jīng)獲取鎖成功了, 此時它會將鎖的狀態(tài)信息傳播給后繼結(jié)點
          setHeadAndPropagate(node, r);
          p.next = null;
          //如果在線程阻塞期間收到中斷請求, 就在這一步響應(yīng)該請求
          if (interrupted) {
            selfInterrupt();
          }
          failed = false;
          return;
        }
      }
      //每次獲取鎖失敗后都會判斷是否可以將線程掛起, 如果可以的話就會在parkAndCheckInterrupt方法里將線程掛起
      if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) {
        interrupted = true;
      }
    }
  } finally {
    if (failed) {
      cancelAcquire(node);
    }
  }
}

進入doAcquireShared方法首先是調(diào)用addWaiter方法將當前線程包裝成結(jié)點放到同步隊列尾部。這個添加結(jié)點的過程我們在講獨占模式時講過，這里就不再講了。結(jié)點進入同步隊列后，如果它發(fā)現(xiàn)在它前面的結(jié)點就是head結(jié)點，因為head結(jié)點的線程已經(jīng)獲取鎖進入房間里面了，那么下一個獲取鎖的結(jié)點就輪到自己了，所以當前結(jié)點先不會將自己掛起，而是再一次去嘗試獲取鎖，如果前面那人剛好釋放鎖離開了，那么當前結(jié)點就能成功獲得鎖，如果前面那人還沒有釋放鎖，那么就會調(diào)用shouldParkAfterFailedAcquire方法，在這個方法里面會將head結(jié)點的狀態(tài)改為SIGNAL，只有保證前面結(jié)點的狀態(tài)為SIGNAL，當前結(jié)點才能放心的將自己掛起，所有線程都會在parkAndCheckInterrupt方法里面被掛起。如果當前結(jié)點恰巧成功的獲取了鎖，那么接下來就會調(diào)用setHeadAndPropagate方法將自己設(shè)置為head結(jié)點，并且喚醒后面同樣是共享模式的結(jié)點。下面我們看下setHeadAndPropagate方法具體的操作。

//設(shè)置head結(jié)點并傳播鎖的狀態(tài)(共享模式)
private void setHeadAndPropagate(Node node, int propagate) {
  Node h = head;
  //將給定結(jié)點設(shè)置為head結(jié)點
  setHead(node);
  //如果propagate大于0表明鎖可以獲取了
  if (propagate > 0 || h == null || h.waitStatus < 0) {
    //獲取給定結(jié)點的后繼結(jié)點
    Node s = node.next;
    //如果給定結(jié)點的后繼結(jié)點為空, 或者它的狀態(tài)是共享狀態(tài)
    if (s == null || s.isShared()) {
      //喚醒后繼結(jié)點
      doReleaseShared();
    }
  }
}

//釋放鎖的操作(共享模式)
private void doReleaseShared() {
  for (;;) {
    //獲取同步隊列的head結(jié)點
    Node h = head;
    if (h != null && h != tail) {
      //獲取head結(jié)點的等待狀態(tài)
      int ws = h.waitStatus;
      //如果head結(jié)點的狀態(tài)為SIGNAL, 表明后面有人在排隊
      if (ws == Node.SIGNAL) {
        //先把head結(jié)點的等待狀態(tài)更新為0
        if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) {
          continue;
        }
        //再去喚醒后繼結(jié)點
        unparkSuccessor(h);
       //如果head結(jié)點的狀態(tài)為0, 表明此時后面沒人在排隊, 就只是將head狀態(tài)修改為PROPAGATE
      }else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE)) {
        continue;
      }
    }
    //只有保證期間head結(jié)點沒被修改過才能跳出循環(huán)
    if (h == head) {
      break;
    }
  }
}

調(diào)用setHeadAndPropagate方法首先將自己設(shè)置成head結(jié)點，然后再根據(jù)傳入的tryAcquireShared方法的返回值來決定是否要去喚醒后繼結(jié)點。前面已經(jīng)講到當返回值大于0就表明當前結(jié)點成功獲取了鎖，并且后面的結(jié)點也可以成功獲取鎖。這時當前結(jié)點就需要去喚醒后面同樣是共享模式的結(jié)點，注意，每次喚醒僅僅只是喚醒后一個結(jié)點，如果后一個結(jié)點不是共享模式的話，當前結(jié)點就直接進入房間而不會再去喚醒更后面的結(jié)點了。共享模式下喚醒后繼結(jié)點的操作是在doReleaseShared方法進行的，共享模式和獨占模式的喚醒操作基本也是相同的，都是去找到自己座位上的牌子(等待狀態(tài))，如果牌子上為SIGNAL表明后面有人需要讓它幫忙喚醒，如果牌子上為0則表明隊列此時并沒有人在排隊。在獨占模式下是如果發(fā)現(xiàn)沒人在排隊就直接離開隊列了，而在共享模式下如果發(fā)現(xiàn)隊列后面沒人在排隊，當前結(jié)點在離開前仍然會留個小紙條(將等待狀態(tài)設(shè)置為PROPAGATE)告訴后來的人這個鎖的可獲取狀態(tài)。那么后面來的人在嘗試獲取鎖的時候可以根據(jù)這個狀態(tài)來判斷是否直接獲取鎖。

2. 響應(yīng)線程中斷的獲取

//以可中斷模式獲取鎖(共享模式)
public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
  //首先判斷線程是否中斷, 如果是則拋出異常
  if (Thread.interrupted()) {
    throw new InterruptedException();
  }
  //1.嘗試去獲取鎖
  if (tryAcquireShared(arg) < 0) {
    //2. 如果獲取失敗則進人該方法
    doAcquireSharedInterruptibly(arg);
  }
}

//以可中斷模式獲取(共享模式)
private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
  //將當前結(jié)點插入同步隊列尾部
  final Node node = addWaiter(Node.SHARED);
  boolean failed = true;
  try {
    for (;;) {
      //獲取當前結(jié)點的前繼結(jié)點
      final Node p = node.predecessor();
      if (p == head) {
        int r = tryAcquireShared(arg);
        if (r >= 0) {
          setHeadAndPropagate(node, r);
          p.next = null;
          failed = false;
          return;
        }
      }
      if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) {
        //如果線程在阻塞過程中收到過中斷請求, 那么就會立馬在這里拋出異常
        throw new InterruptedException();
      }
    }
  } finally {
    if (failed) {
      cancelAcquire(node);
    }
  }
}

響應(yīng)線程中斷獲取鎖的方式和不響應(yīng)線程中斷獲取鎖的方式在流程上基本是相同的，唯一的區(qū)別就是在哪里響應(yīng)線程的中斷請求。在不響應(yīng)線程中斷獲取鎖時，線程從parkAndCheckInterrupt方法中被喚醒，喚醒后就立馬返回是否收到中斷請求，即使是收到了中斷請求也會繼續(xù)自旋直到獲取鎖后才響應(yīng)中斷請求將自己給掛起。而響應(yīng)線程中斷獲取鎖會才線程被喚醒后立馬響應(yīng)中斷請求，如果在阻塞過程中收到了線程中斷就會立馬拋出InterruptedException異常。

3. 設(shè)置超時時間的獲取

//以限定超時時間獲取鎖(共享模式)
public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException {
  if (Thread.interrupted()) {
    throw new InterruptedException();
  }
  //1.調(diào)用tryAcquireShared嘗試去獲取鎖
  //2.如果獲取失敗就調(diào)用doAcquireSharedNanos
  return tryAcquireShared(arg) >= 0 || doAcquireSharedNanos(arg, nanosTimeout);
}

//以限定超時時間獲取鎖(共享模式)
private boolean doAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException {
  long lastTime = System.nanoTime();
  final Node node = addWaiter(Node.SHARED);
  boolean failed = true;
  try {
    for (;;) {
      //獲取當前結(jié)點的前繼結(jié)點
      final Node p = node.predecessor();
      if (p == head) {
        int r = tryAcquireShared(arg);
        if (r >= 0) {
          setHeadAndPropagate(node, r);
          p.next = null;
          failed = false;
          return true;
        }
      }
      //如果超時時間用完了就結(jié)束獲取, 并返回失敗信息
      if (nanosTimeout <= 0) {
        return false;
      }
      //1.檢查是否滿足將線程掛起要求(保證前繼結(jié)點狀態(tài)為SIGNAL)
      //2.檢查超時時間是否大于自旋時間
      if (shouldParkAfterFailedAcquire(p, node) && nanosTimeout > spinForTimeoutThreshold) {
        //若滿足上面兩個條件就將當前線程掛起一段時間
        LockSupport.parkNanos(this, nanosTimeout);
      }
      long now = System.nanoTime();
      //超時時間每次減去獲取鎖的時間
      nanosTimeout -= now - lastTime;
      lastTime = now;
      //如果在阻塞時收到中斷請求就立馬拋出異常
      if (Thread.interrupted()) {
        throw new InterruptedException();
      }
    }
  } finally {
    if (failed) {
      cancelAcquire(node);
    }
  }
}

如果看懂了上面兩種獲取方式，再來看設(shè)置超時時間的獲取方式就會很輕松，基本流程都是一樣的，主要是理解超時的機制是怎樣的。如果第一次獲取鎖失敗會調(diào)用doAcquireSharedNanos方法并傳入超時時間，進入方法后會根據(jù)情況再次去獲取鎖，如果再次獲取失敗就要考慮將線程掛起了。這時會判斷超時時間是否大于自旋時間，如果是的話就會將線程掛起一段時間，否則就繼續(xù)嘗試獲取，每次獲取鎖之后都會將超時時間減去獲取鎖的時間，一直這樣循環(huán)直到超時時間用盡，如果還沒有獲取到鎖的話就會結(jié)束獲取并返回獲取失敗標識。在整個期間線程是響應(yīng)線程中斷的。

4. 共享模式下結(jié)點的出隊操作

//釋放鎖的操作(共享模式)
public final boolean releaseShared(int arg) {
  //1.嘗試去釋放鎖
  if (tryReleaseShared(arg)) {
    //2.如果釋放成功就喚醒其他線程
    doReleaseShared();
    return true;
  }
  return false;
}

//嘗試去釋放鎖(共享模式)
protected boolean tryReleaseShared(int arg) {
  throw new UnsupportedOperationException();
}

//釋放鎖的操作(共享模式)
private void doReleaseShared() {
  for (;;) {
    //獲取同步隊列的head結(jié)點
    Node h = head;
    if (h != null && h != tail) {
      //獲取head結(jié)點的等待狀態(tài)
      int ws = h.waitStatus;
      //如果head結(jié)點的狀態(tài)為SIGNAL, 表明后面有人在排隊
      if (ws == Node.SIGNAL) {
        //先把head結(jié)點的等待狀態(tài)更新為0
        if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) {
          continue;
        }
        //再去喚醒后繼結(jié)點
        unparkSuccessor(h);
       //如果head結(jié)點的狀態(tài)為0, 表明此時后面沒人在排隊, 就只是將head狀態(tài)修改為PROPAGATE
      }else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE)) {
        continue;
      }
    }
    //只有保證期間head結(jié)點沒被修改過才能跳出循環(huán)
    if (h == head) {
      break;
    }
  }
}

線程在房間辦完事之后就會調(diào)用releaseShared方法釋放鎖，首先調(diào)用tryReleaseShared方法嘗試釋放鎖，該方法的判斷邏輯由子類實現(xiàn)。如果釋放成功就調(diào)用doReleaseShared方法去喚醒后繼結(jié)點。走出房間后它會找到原先的座位(head結(jié)點)，看看座位上是否有人留了小紙條(狀態(tài)為SIGNAL)，如果有就去喚醒后繼結(jié)點。如果沒有(狀態(tài)為0)就代表隊列沒人在排隊，那么在離開之前它還要做最后一件事情，就是在自己座位上留下小紙條(狀態(tài)設(shè)置為PROPAGATE)，告訴后面的人鎖的獲取狀態(tài)，整個釋放鎖的過程和獨占模式唯一的區(qū)別就是在這最后一步操作。

注：以上全部分析基于JDK1.7，不同版本間會有差異，讀者需要注意。

以上就是本文的全部內(nèi)容，希望對大家的學(xué)習有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章: