//不響應(yīng)中斷方式獲取(獨占模式)
public final void acquire(int arg) {
  if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
    selfInterrupt();
  }
}

 //嘗試去獲取鎖(獨占模式)
protected boolean tryAcquire(int arg) {
  throw new UnsupportedOperationException();
}

//將當(dāng)前線程包裝成結(jié)點并添加到同步隊列尾部
private Node addWaiter(Node mode) {
  //指定持有鎖的模式
  Node node = new Node(Thread.currentThread(), mode);
  //獲取同步隊列尾結(jié)點引用
  Node pred = tail;
  //如果尾結(jié)點不為空, 表明同步隊列已存在結(jié)點
  if (pred != null) {
    //1.指向當(dāng)前尾結(jié)點
    node.prev = pred;
    //2.設(shè)置當(dāng)前結(jié)點為尾結(jié)點
    if (compareAndSetTail(pred, node)) {
      //3.將舊的尾結(jié)點的后繼指向新的尾結(jié)點
      pred.next = node;
      return node;
    }
  }
  //否則表明同步隊列還沒有進行初始化
  enq(node);
  return node;
}

//結(jié)點入隊操作
private Node enq(final Node node) {
  for (;;) {
    //獲取同步隊列尾結(jié)點引用
    Node t = tail;
    //如果尾結(jié)點為空說明同步隊列還沒有初始化
    if (t == null) {
      //初始化同步隊列
      if (compareAndSetHead(new Node())) {
        tail = head;
      }
    } else {
      //1.指向當(dāng)前尾結(jié)點
      node.prev = t;
      //2.設(shè)置當(dāng)前結(jié)點為尾結(jié)點
      if (compareAndSetTail(t, node)) {
        //3.將舊的尾結(jié)點的后繼指向新的尾結(jié)點
        t.next = node;
        return t;
      }
    }
  }
}

//以不可中斷方式獲取鎖(獨占模式)
final boolean acquireQueued(final Node node, int arg) {
  boolean failed = true;
  try {
    boolean interrupted = false;
    for (;;) {
      //獲取給定結(jié)點的前繼結(jié)點的引用
      final Node p = node.predecessor();
      //如果當(dāng)前結(jié)點是同步隊列的第一個結(jié)點, 就嘗試去獲取鎖
      if (p == head && tryAcquire(arg)) {
        //將給定結(jié)點設(shè)置為head結(jié)點
        setHead(node);
        //為了幫助垃圾收集, 將上一個head結(jié)點的后繼清空
        p.next = null;
        //設(shè)置獲取成功狀態(tài)
        failed = false;
        //返回中斷的狀態(tài), 整個循環(huán)執(zhí)行到這里才是出口
        return interrupted;
      }
      //否則說明鎖的狀態(tài)還是不可獲取, 這時判斷是否可以掛起當(dāng)前線程
      //如果判斷結(jié)果為真則掛起當(dāng)前線程, 否則繼續(xù)循環(huán), 在這期間線程不響應(yīng)中斷
      if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) {
        interrupted = true;
      }
    }
  } finally {
    //在最后確保如果獲取失敗就取消獲取
    if (failed) {
      cancelAcquire(node);
    }
  }
}

//判斷是否可以將當(dāng)前結(jié)點掛起
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
  //獲取前繼結(jié)點的等待狀態(tài)
  int ws = pred.waitStatus;
  //如果前繼結(jié)點狀態(tài)為SIGNAL, 表明前繼結(jié)點會喚醒當(dāng)前結(jié)點, 所以當(dāng)前結(jié)點可以安心的掛起了
  if (ws == Node.SIGNAL) {
    return true;
  }
  
  if (ws > 0) {
    //下面的操作是清理同步隊列中所有已取消的前繼結(jié)點
    do {
      node.prev = pred = pred.prev;
    } while (pred.waitStatus > 0);
    pred.next = node;
  } else {
    //到這里表示前繼結(jié)點狀態(tài)不是SIGNAL, 很可能還是等于0, 這樣的話前繼結(jié)點就不會去喚醒當(dāng)前結(jié)點了
    //所以當(dāng)前結(jié)點必須要確保前繼結(jié)點的狀態(tài)為SIGNAL才能安心的掛起自己
    compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
  }
  return false;
}

//掛起當(dāng)前線程
private final boolean parkAndCheckInterrupt() {
  LockSupport.park(this);
  return Thread.interrupted();
}

 //當(dāng)前線程將自己中斷
 private static void selfInterrupt() {
   Thread.currentThread().interrupt();
 }

//以可中斷模式獲取鎖(獨占模式)
private void doAcquireInterruptibly(int arg) throws InterruptedException {
  //將當(dāng)前線程包裝成結(jié)點添加到同步隊列中
  final Node node = addWaiter(Node.EXCLUSIVE);
  boolean failed = true;
  try {
    for (;;) {
      //獲取當(dāng)前結(jié)點的前繼結(jié)點
      final Node p = node.predecessor();
      //如果p是head結(jié)點, 那么當(dāng)前線程就再次嘗試獲取鎖
      if (p == head && tryAcquire(arg)) {
        setHead(node);
        p.next = null; // help GC
        failed = false;
        //獲取鎖成功后返回
        return;
      }
      //如果滿足條件就掛起當(dāng)前線程, 此時響應(yīng)中斷并拋出異常
      if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) {
        //線程被喚醒后如果發(fā)現(xiàn)中斷請求就拋出異常
        throw new InterruptedException();
      }
    }
  } finally {
    if (failed) {
      cancelAcquire(node);
    }
  }
}

//以限定超時時間獲取鎖(獨占模式)
private boolean doAcquireNanos(int arg, long nanosTimeout) throws InterruptedException {
  //獲取系統(tǒng)當(dāng)前時間
  long lastTime = System.nanoTime();
  //將當(dāng)前線程包裝成結(jié)點添加到同步隊列中
  final Node node = addWaiter(Node.EXCLUSIVE);
  boolean failed = true;
  try {
    for (;;) {
      //獲取當(dāng)前結(jié)點的前繼結(jié)點
      final Node p = node.predecessor();
      //如果前繼是head結(jié)點, 那么當(dāng)前線程就再次嘗試獲取鎖
      if (p == head && tryAcquire(arg)) {
        //更新head結(jié)點
        setHead(node);
        p.next = null;
        failed = false;
        return true;
      }
      //超時時間用完了就直接退出循環(huán)
      if (nanosTimeout <= 0) {
        return false;
      }
      //如果超時時間大于自旋時間, 那么等判斷可以掛起線程之后就會將線程掛起一段時間
      if (shouldParkAfterFailedAcquire(p, node) && nanosTimeout > spinForTimeoutThreshold) {
        //將當(dāng)前線程掛起一段時間, 之后再自己醒來
        LockSupport.parkNanos(this, nanosTimeout);
      }
      //獲取系統(tǒng)當(dāng)前時間
      long now = System.nanoTime();
      //超時時間每次都減去獲取鎖的時間間隔
      nanosTimeout -= now - lastTime;
      //再次更新lastTime
      lastTime = now;
      //在獲取鎖的期間收到中斷請求就拋出異常
      if (Thread.interrupted()) {
        throw new InterruptedException();
      }
    }
  } finally {
    if (failed) {
      cancelAcquire(node);
    }
  }
}

//釋放鎖的操作(獨占模式)
public final boolean release(int arg) {
  //撥動密碼鎖, 看看是否能夠開鎖
  if (tryRelease(arg)) {
    //獲取head結(jié)點
    Node h = head;
    //如果head結(jié)點不為空并且等待狀態(tài)不等于0就去喚醒后繼結(jié)點
    if (h != null && h.waitStatus != 0) {
      //喚醒后繼結(jié)點
      unparkSuccessor(h);
    }
    return true;
  }
  return false;
}

//喚醒后繼結(jié)點
private void unparkSuccessor(Node node) {
  //獲取給定結(jié)點的等待狀態(tài)
  int ws = node.waitStatus;
  //將等待狀態(tài)更新為0
  if (ws < 0) {
    compareAndSetWaitStatus(node, ws, 0);
  }
  //獲取給定結(jié)點的后繼結(jié)點
  Node s = node.next;
  //后繼結(jié)點為空或者等待狀態(tài)為取消狀態(tài)
  if (s == null || s.waitStatus > 0) {
    s = null;
    //從后向前遍歷隊列找到第一個不是取消狀態(tài)的結(jié)點
    for (Node t = tail; t != null && t != node; t = t.prev) {
      if (t.waitStatus <= 0) {
        s = t;
      }
    }
  }
  //喚醒給定結(jié)點后面首個不是取消狀態(tài)的結(jié)點
  if (s != null) {
    LockSupport.unpark(s.thread);
  }
}