深刻學習Lock鎖（5）——Condition接口應用與分析

1.對比Object對象的監視器方法

    任意一個Java對象，都擁有一組監視器方法（定義在java.lang.Object上），主要包括wait()、 wait(long timeout)、notify()以及notifyAll()方法，這些方法與synchronized同步關鍵字配合，能夠 實現等待/通知模式。Condition接口也提供了相似Object的監視器方法，與Lock配合能夠實現等 待/通知模式，可是這二者在使用方式以及功能特性上仍是有差異的。

2.Condition接口API與使用

    Condition定義了等待/通知兩種類型的方法，當前線程調用這些方法時，須要提早獲取到 Condition對象關聯的鎖。Condition對象是由Lock對象（調用Lock對象的newCondition()方法）創 建出來的，換句話說，Condition是依賴Lock對象的。Condition的使用方式比較簡單，須要注意在調用方法前獲取鎖。

public class AwaitAndSignal {
	static boolean flag = true;
	static Lock lock = new ReentrantLock();
	static Condition con=lock.newCondition();
	public static void main(String[] args) throws Exception {
		Thread AwaitThread = new Thread(new Await(), "AwaitThread");
		AwaitThread.start();
		TimeUnit.SECONDS.sleep(1);
		Thread SignalThread = new Thread(new Signal(), "SignalThread");
		SignalThread.start();
	}

	static class Await implements Runnable {
		public void run() {
			try{
				lock.lock();
				while(flag&&!Thread.interrupted()){
					try {
						System.out.println(Thread.currentThread() + " flag is true. wait"
								+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
						con.await();
						
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				System.out.println(Thread.currentThread() + " flag is false. running"
						+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
			}finally {
				lock.unlock();
			}
		}
	}

	static class Signal implements Runnable {
		public void run() {
			try{
				lock.lock();
				System.out.println(Thread.currentThread() + " hold lock. notify"
						+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
				con.signalAll();
				flag = false;
			}finally {
				lock.unlock();
			}
			// 再次加鎖
			try{
				lock.lock();
				System.out.println(Thread.currentThread() + " hold lock again. sleep"
						+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
			}finally {
				lock.unlock();
			}
		}
	}
}

    通常都會將Condition對象做爲成員變量。當調用await()方法後，當前線程會釋放鎖並在此等待，而其餘線程調用Condition對象的signal()方法，通知當前線程後，當前線程才從await()方法返回，而且在返回前已經獲取了鎖。

3.實現分析

    ConditionObject是同步器AbstractQueuedSynchronizer的內部類，是Condition接口的實現類，由於Condition的操做須要獲取相關聯的鎖，因此做爲同步器的內部類也較爲合理。每一個Condition對象都包含着一個隊列（如下稱爲等待隊列），該隊列是Condition對象實現等待/通知功能的關鍵。

1.等待隊列

    等待隊列是一個FIFO的隊列，在隊列中的每一個節點都包含了一個線程引用，該線程就是在Condition對象上等待的線程，若是一個線程調用了Condition.await()方法，那麼該線程將會釋放鎖、構形成節點加入等待隊列並進入等待狀態。事實上，節點的定義複用了同步器中節點的定義，也就是說，同步隊列和等待隊列中節點類型都是同步器的靜態內部類 AbstractQueuedSynchronizer.Node。

    一個Condition包含一個等待隊列，Condition擁有首節點（firstWaiter）和尾節點 （lastWaiter）。當前線程調用Condition.await()方法，將會以當前線程構造節點，並將節點從尾部加入等待隊列。Condition擁有首尾節點的引用，而新增節點只須要將原有的尾節點nextWaiter 指向它，而且更新尾節點便可。上述節點引用更新的過程並無使用CAS保證，緣由在於調用 await()方法的線程一定是獲取了鎖的線程，也就是說該過程是由鎖來保證線程安全的。

    在Object的監視器模型上，一個對象擁有一個同步隊列和等待隊列，而併發包中的Lock（更確切地說是同步器）擁有一個同步隊列和多個等待隊列。

2.等待

    調用Condition的await()方法（或者以await開頭的方法），會使當前線程進入等待隊列並釋 放鎖，同時線程狀態變爲等待狀態。當從await()方法返回時，當前線程必定獲取了Condition相關聯的鎖。

    若是從隊列（同步隊列和等待隊列）的角度看await()方法，當調用await()方法時，至關於同步隊列的首節點（獲取了鎖的節點）移動到Condition的等待隊列中。

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);
        }

    調用該方法的線程成功獲取了鎖的線程，也就是同步隊列中的首節點，該方法會將當前線程構形成節點並加入等待隊列中，而後釋放同步狀態，喚醒同步隊列中的後繼節點，而後當前線程會進入等待狀態。 當等待隊列中的節點被喚醒，則喚醒節點的線程開始嘗試獲取同步狀態。若是不是經過其餘線程調用Condition.signal()方法喚醒，而是對等待線程進行中斷，則會拋出 InterruptedException。

3.通知

    調用Condition的signal()方法，將會喚醒在等待隊列中等待時間最長的節點（首節點），在喚醒節點以前，會將節點移到同步隊列中。

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

    調用該方法的前置條件是當前線程必須獲取了鎖，能夠看到signal()方法進行了 isHeldExclusively()檢查，也就是當前線程必須是獲取了鎖的線程。接着獲取等待隊列的首節點，將其移動到同步隊列並使用LockSupport喚醒節點中的線程。

    經過調用同步器的enq(Node node)方法，等待隊列中的頭節點線程安全地移動到同步隊列。當節點移動到同步隊列後，當前線程再使用LockSupport喚醒該節點的線程。被喚醒後的線程，將從await()方法中的while循環中退出（isOnSyncQueue(Node node)方法 返回true，節點已經在同步隊列中），進而調用同步器的acquireQueued()方法加入到獲取同步狀態的競爭中。 成功獲取同步狀態（或者說鎖）以後，被喚醒的線程將從先前調用的await()方法返回，此時該線程已經成功地獲取了鎖。

    而Condition的signalAll()方法，至關於對等待隊列中的每一個節點均執行一次signal()方法，效 果就是將等待隊列中全部節點所有移動到同步隊列中，並喚醒每一個節點的線程。