Condition源碼分析

Condition

在synchronized中通過wait/notify進行線程間通信
在Lock中通過await/signal進行線程間通信
整體圖如下：

一．分析一波condition.await源碼：

 public final void await() throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();
            int savedState = fullyRelease(node);
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }

1.addConditionWaiter()

首先分析addConditionWaiter()：

private Node addConditionWaiter() {
            Node t = lastWaiter;
            // If lastWaiter is cancelled, clean out.
            if (t != null && t.waitStatus != Node.CONDITION) {
                unlinkCancelledWaiters();
                t = lastWaiter;
            }
            Node node = new Node(Thread.currentThread(), Node.CONDITION);
            if (t == null)
                firstWaiter = node;
            else
                t.nextWaiter = node;
            lastWaiter = node;
            return node;
        }

通過這段代碼可推出構建了一個ConditionWaiter隊列：

2. fullyRelease(node)

首先要明白鎖是支持重入的

final int fullyRelease(Node node) {
        boolean failed = true;	
        try {
            int savedState = getState();	//獲得state，state大於等於1
            if (release(savedState)) {    //釋放鎖資源
                failed = false;
                return savedState;
            } else {
                throw new IllegalMonitorStateException();
            }
        } finally {
            if (failed)
                node.waitStatus = Node.CANCELLED;
        }
}

當釋放後，AQS隊列發生以下變化

3. while (!isOnSyncQueue(node))中的isOnSyncQueue(node)

  final boolean isOnSyncQueue(Node node) {
        if (node.waitStatus == Node.CONDITION || node.prev == null)
            return false;
        if (node.next != null) // If has successor, it must be on queue
            return true;
        return findNodeFromTail(node);
}

如果waitStatus爲 Node.CONDITION 說明在condition隊列||node.prev==null說明node爲head節點，head節點表明鎖已被釋放，所以 while (!isOnSyncQueue(node)) 意思是隻要node不在AQS隊列中就會被掛起，在condition隊列掛起此時等待被喚醒。

二．分析喚醒源碼

public final void signal() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignal(first);
        }

1.doSignal(first)

private void doSignal(Node first) {
            do {
                if ( (firstWaiter = first.nextWaiter) == null)
                    lastWaiter = null;
                first.nextWaiter = null;
            } while (!transferForSignal(first) &&
                     (first = firstWaiter) != null);
        }

#① while (!transferForSignal(first) && (first = firstWaiter) != null)

final boolean transferForSignal(Node node) {
  if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))//將狀態爲CONDITION轉換爲0
      return false;
  Node p = enq(node); //p爲原tail
  int ws = p.waitStatus;
  if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))//將p的ws改爲SIGNAL
      LockSupport.unpark(node.thread);
  return true;
}

通過transferForSignal(first)將Condition等待隊列中的第一個需要喚醒的傳輸到AQS隊列

② if ( (firstWaiter = first.nextWaiter) == null)

                lastWaiter = null;
            first.nextWaiter = null;

這裏是將等待隊列中的節點移除，下面就是到了剛纔線程await被掛起那裏的源碼分析了

三．await被park那裏繼續分析

while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);

接上在LockSupport.park(this)被掛起了，由於喚醒了，所以繼續執行，現在分析if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)進而分析checkInterruptWhileWaiting(node) node爲調用await的node節點
CheckInterruptWhileWaiting代碼如下:

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

判斷線程是否被中斷過，若被中斷過會去判斷是在await前後中斷的，若在調用await之前被中斷則拋出異常，否則重新中斷去使得可以接下來響應；分析transferAfterCancelledWait(node)：

final boolean transferAfterCancelledWait(Node node) {
        if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) { //這裏做一下說明，當一個線程處於sleep或park等阻塞狀態時，interrupt可以喚醒線程，下圖說明
            enq(node);
            return true;
        }
        while (!isOnSyncQueue(node))
            Thread.yield();
        return false;
}

若上面分析的if成立，則是由於中斷喚醒線程，沒有正常的走流程，則表明是在喚醒前中斷的，所以會拋異常。