public final void await() throws InterruptedException {
		//判斷是否當前線程是否被中斷中斷則拋出中斷異常
      if (Thread.interrupted())
        throw new InterruptedException();
		//加入等待隊列
      Node node = addConditionWaiter();
		//釋放當前線程鎖
      int savedState = fullyRelease(node);
      int interruptMode = 0;
		//判斷是否在同步阻塞隊列，如果不在一直循環(huán)到被加入
      while (!isOnSyncQueue(node)) {
		//阻塞當前線程
        LockSupport.park(this);
		//判斷是否被中斷
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
          break;
      }
		//獲取鎖，如果獲取中被中斷則設(shè)置中斷狀態(tài)
      if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
		//清除等待隊列中被"激活"的節(jié)點
      if (node.nextWaiter != null) // clean up if cancelled
        unlinkCancelledWaiters();
		//如果當前線程被中斷，處理中斷邏輯
      if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
    }

private Node addConditionWaiter() {
 		//獲取等待隊列尾部節(jié)點
      Node t = lastWaiter;
      //如果尾部狀態(tài)不為CONDITION，如果已經(jīng)被"激活"，清理之，然后重新獲取尾部節(jié)點
      if (t != null && t.waitStatus != Node.CONDITION) {
        unlinkCancelledWaiters();
        t = lastWaiter;
      }
		//創(chuàng)建以當前線程為基礎(chǔ)的節(jié)點，并將節(jié)點模式設(shè)置成CONDITION
      Node node = new Node(Thread.currentThread(), Node.CONDITION);
		//如果尾節(jié)點不存在，說明隊列為空，將頭節(jié)點設(shè)置成當前節(jié)點
      if (t == null)
        firstWaiter = node;
		//如果尾節(jié)點存在，將此節(jié)點設(shè)置成尾節(jié)點的下個節(jié)點
      else
        t.nextWaiter = node;
		//將尾節(jié)點設(shè)置成當前節(jié)點
      lastWaiter = node;
      return node;
    }

final int fullyRelease(Node node) {
    boolean failed = true;
    try {
		//獲取阻塞隊列中當前線程節(jié)點的鎖狀態(tài)值
      int savedState = getState();
		//釋放當前線程節(jié)點鎖
      if (release(savedState)) {
        failed = false;
        return savedState;
      } else {
        throw new IllegalMonitorStateException();
      }
    } finally {
		//釋放失敗講節(jié)點等待狀態(tài)設(shè)置成關(guān)閉
      if (failed)
        node.waitStatus = Node.CANCELLED;
    }
  }

final boolean isOnSyncQueue(Node node) {
		//判斷當前節(jié)點是否是CONDITION或者前置節(jié)點是否為空如果為空直接返回false
    if (node.waitStatus == Node.CONDITION || node.prev == null)
      return false;
		//如果下個節(jié)點存在，則在同步阻塞隊列中返回true
    if (node.next != null) // If has successor, it must be on queue
      return true;
		//遍歷查找當前節(jié)點是否在同步阻塞隊列中
    return findNodeFromTail(node);
  }
  private boolean findNodeFromTail(Node node) {
    Node t = tail;
    for (;;) {
      if (t == node)
        return true;
      if (t == null)
        return false;
      t = t.prev;
    }
  }

private int checkInterruptWhileWaiting(Node node) {
      return Thread.interrupted() ?
        (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
        0;
    }

final boolean transferAfterCancelledWait(Node node) {
    if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) {
      enq(node);
      return true;
    }
    while (!isOnSyncQueue(node))
      Thread.yield();
    return false;
  }

private void unlinkCancelledWaiters() {
		//獲取等待隊列頭節(jié)點
      Node t = firstWaiter;
      Node trail = null;
      while (t != null) {
		//獲取下個節(jié)點
        Node next = t.nextWaiter;
		//如果狀態(tài)不為CONDITION說明已經(jīng)加入阻塞隊列需要清理掉
        if (t.waitStatus != Node.CONDITION) {
          t.nextWaiter = null;
          if (trail == null)
            firstWaiter = next;
          else
			//獲取下個節(jié)點
            trail.nextWaiter = next;
          if (next == null)
            lastWaiter = trail;
        }
        else
          trail = t;
        t = next;
      }
    }

private void reportInterruptAfterWait(int interruptMode)
      throws InterruptedException {
		//如果是THROW_IE模式直接拋出異常
      if (interruptMode == THROW_IE)
        throw new InterruptedException();
		//如果是REINTERRUPT模式標記線程中斷由上層處理中斷
      else if (interruptMode == REINTERRUPT)
        selfInterrupt();
    }

public final void signal() {
		//是否當前線程持有鎖
      if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
      Node first = firstWaiter;
		//通知"激活"頭節(jié)點線程
      if (first != null)
        doSignal(first);
    }

 protected final boolean isHeldExclusively() {
      return getExclusiveOwnerThread() == Thread.currentThread();
    }

private void doSignal(Node first) {
      do {
		//頭指頭后移一位，如果后面的節(jié)點為空，則將尾指頭也指向空，說明隊列為空了
        if ( (firstWaiter = first.nextWaiter) == null)
          lastWaiter = null;
		//清空頭節(jié)點的下個節(jié)點
        first.nextWaiter = null;
		//如果"激活"失敗者取下個繼續(xù)，直到成功或者遍歷完
      } while (!transferForSignal(first) &&
           (first = firstWaiter) != null);
    }

final boolean transferForSignal(Node node) {
		//將CONDITION狀態(tài)設(shè)置成0
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
      return false;
		//加入到同步阻塞隊列
    Node p = enq(node);
    int ws = p.waitStatus;
		//狀態(tài)異常直接激活
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
      LockSupport.unpark(node.thread);
    return true;
  }