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

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

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

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

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

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

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

//以可中斷模式獲取(共享模式)
private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
  //將當(dāng)前結(jié)點(diǎn)插入同步隊(duì)列尾部
  final Node node = addWaiter(Node.SHARED);
  boolean failed = true;
  try {
    for (;;) {
      //獲取當(dāng)前結(jié)點(diǎn)的前繼結(jié)點(diǎn)
      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()) {
        //如果線程在阻塞過程中收到過中斷請(qǐng)求, 那么就會(huì)立馬在這里拋出異常
        throw new InterruptedException();
      }
    }
  } finally {
    if (failed) {
      cancelAcquire(node);
    }
  }
}

//以限定超時(shí)時(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);
}

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

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