今天我們就來探討一下Java中線程協作的最常見的兩種方式：利用Object.wait()、Object.notify()和使用Condition
以下是本文目錄大綱：
一.wait()、notify()和notifyAll()
二.Condition
一.wait()、notify()和notifyAll()
在Java中，可以通過配合調用Object對象的wait（）方法和notify（）方法或notifyAll（）方法來實現線程間的通信。在線程中調用wait（）方法，將阻塞等待其他線程的通知（其他線程調用notify（）方法或notifyAll（）方法），在線程中調用notify（）方法或notifyAll（）方法，將通知其他線程從wait（）方法處返回。
Object是所有類的超類，它有5個方法組成了等待/通知機制的核心：notify（）、notifyAll（）、wait（）、wait（long）和wait（long，int）。在Java中，所有的類都從Object繼承而來，因此，所有的類都擁有這些共有方法可供使用。而且，由於他們都被聲明爲final，因此在子類中不能覆寫任何一個方法。
這裏詳細說明一下各個方法在使用中需要注意的幾點：
1、wait（）
public final void wait() throws InterruptedException,IllegalMonitorStateException
該方法用來將當前線程置入休眠狀態，直到接到通知或被中斷爲止。在調用wait（）之前，線程必須要獲得該對象的對象級別鎖，即只能在同步方法或同步塊中調用wait（）方法。進入wait（）方法後，當前線程釋放鎖。在從wait（）返回前，線程與其他線程競爭重新獲得鎖。如果調用wait（）時，沒有持有適當的鎖，則拋出IllegalMonitorStateException，它是RuntimeException的一個子類，因此，不需要try-catch結構。
2、notify（）
public final native void notify() throws IllegalMonitorStateException
該方法也要在同步方法或同步塊中調用，即在調用前，線程也必須要獲得該對象的對象級別鎖，的如果調用notify（）時沒有持有適當的鎖，也會拋出IllegalMonitorStateException。
該方法用來通知那些可能等待該對象的對象鎖的其他線程。如果有多個線程等待，則線程規劃器任意挑選出其中一個wait（）狀態的線程來發出通知，並使它等待獲取該對象的對象鎖（notify後，當前線程不會馬上釋放該對象鎖，wait所在的線程並不能馬上獲取該對象鎖，要等到程序退出synchronized代碼塊後，當前線程纔會釋放鎖，wait所在的線程也纔可以獲取該對象鎖），但不驚動其他同樣在等待被該對象notify的線程們。當第一個獲得了該對象鎖的wait線程運行完畢以後，它會釋放掉該對象鎖，此時如果該對象沒有再次使用notify語句，則即便該對象已經空閒，其他wait狀態等待的線程由於沒有得到該對象的通知，會繼續阻塞在wait狀態，直到這個對象發出一個notify或notifyAll。這裏需要注意：它們等待的是被notify或notifyAll，而不是鎖。這與下面的notifyAll（）方法執行後的情況不同。
3、notifyAll（）
public final native void notifyAll() throws IllegalMonitorStateException
該方法與notify（）方法的工作方式相同，重要的一點差異是：
notifyAll使所有原來在該對象上wait的線程統統退出wait的狀態（即全部被喚醒，不再等待notify或notifyAll，但由於此時還沒有獲取到該對象鎖，因此還不能繼續往下執行），變成等待獲取該對象上的鎖，一旦該對象鎖被釋放（notifyAll線程退出調用了notifyAll的synchronized代碼塊的時候），他們就會去競爭。如果其中一個線程獲得了該對象鎖，它就會繼續往下執行，在它退出synchronized代碼塊，釋放鎖後，其他的已經被喚醒的線程將會繼續競爭獲取該鎖，一直進行下去，直到所有被喚醒的線程都執行完畢。
4、wait（long）和wait（long,int）
顯然，這兩個方法是設置等待超時時間的，後者在超值時間上加上ns，精度也難以達到，因此，該方法很少使用。對於前者，如果在等待線程接到通知或被中斷之前，已經超過了指定的毫秒數，則它通過競爭重新獲得鎖，並從wait（long）返回。另外，需要知道，如果設置了超時時間，當wait（）返回時，我們不能確定它是因爲接到了通知還是因爲超時而返回的，因爲wait（）方法不會返回任何相關的信息。但一般可以通過設置標誌位來判斷，在notify之前改變標誌位的值，在wait（）方法後讀取該標誌位的值來判斷，當然爲了保證notify不被遺漏，我們還需要另外一個標誌位來循環判斷是否調用wait（）方法。
深入理解：
如果線程調用了對象的wait（）方法，那麼線程便會處於該對象的等待池中，等待池中的線程不會去競爭該對象的鎖。
當有線程調用了對象的notifyAll（）方法（喚醒所有wait線程）或notify（）方法（只隨機喚醒一個wait線程），被喚醒的的線程便會進入該對象的鎖池中，鎖池中的線程會去競爭該對象鎖。
優先級高的線程競爭到對象鎖的概率大，假若某線程沒有競爭到該對象鎖，它還會留在鎖池中，唯有線程再次調用wait（）方法，它纔會重新回到等待池中。而競爭到對象鎖的線程則繼續往下執行，直到執行完了synchronized代碼塊，它會釋放掉該對象鎖，這時鎖池中的線程會繼續競爭該對象鎖。
二.Condition
Condition是在java 1.5中才出現的，它用來替代傳統的Object的wait()、notify()實現線程間的協作，相比使用Object的wait()、notify()，使用Condition1的await()、signal()這種方式實現線程間協作更加安全和高效。因此通常來說比較推薦使用Condition，在阻塞隊列那一篇博文中就講述到了，阻塞隊列實際上是使用了Condition來模擬線程間協作。
- Condition是個接口，基本的方法就是await()和signal()方法；
- Condition依賴於Lock接口，生成一個Condition的基本代碼是lock.newCondition()
- 調用Condition的await()和signal()方法，都必須在lock保護之內，就是說必須在lock.lock()和lock.unlock之間纔可以使用
Conditon中的await()對應Object的wait()；
Condition中的signal()對應Object的notify()；
Condition中的signalAll()對應Object的notifyAll()。
Lock可以更好的解決線程同步問題，使之更面向對象，並且ReadWriteLock在處理同步時更強大，那麼同樣，線程間僅僅互斥是不夠的，還需要通信，本篇的內容是基於上篇之上，使用Lock如何處理線程通信。
那麼引入本篇的主角，Condition，Condition 將 Object 監視器方法（wait、notify 和 notifyAll）分解成截然不同的對象，以便通過將這些對象與任意 Lock 實現組合使用，爲每個對象提供多個等待 set （wait-set）。其中，Lock 替代了 synchronized 方法和語句的使用，Condition 替代了 Object 監視器方法的使用。下面將之前寫過的一個線程通信的例子替換成用Condition實現(Java線程(三))，代碼如下：
- public class ThreadTest2 {
- public static void main(String[] args) {
- final Business business = new Business();
- new Thread(new Runnable() {
- @Override
- public void run() {
- threadExecute(business, "sub");
- }
- }).start();
- threadExecute(business, "main");
- }
- public static void threadExecute(Business business, String threadType) {
- for(int i = 0; i < 100; i++) {
- try {
- if("main".equals(threadType)) {
- business.main(i);
- } else {
- business.sub(i);
- }
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- }
- class Business {
- private boolean bool = true;
- private Lock lock = new ReentrantLock();
- private Condition condition = lock.newCondition();
- public void main(int loop) throws InterruptedException {
- lock.lock();
- try {
- while(bool) {
- condition.await();//this.wait();
- }
- for(int i = 0; i < 100; i++) {
- System.out.println("main thread seq of " + i + ", loop of " + loop);
- }
- bool = true;
- condition.signal();//this.notify();
- } finally {
- lock.unlock();
- }
- }
- public void sub(int loop) throws InterruptedException {
- lock.lock();
- try {
- while(!bool) {
- condition.await();//this.wait();
- }
- for(int i = 0; i < 10; i++) {
- System.out.println("sub thread seq of " + i + ", loop of " + loop);
- }
- bool = false;
- condition.signal();//this.notify();
- } finally {
- lock.unlock();
- }
- }
- }
在Condition中，用await()替換wait()，用signal()替換notify()，用signalAll()替換notifyAll()，傳統線程的通信方式，Condition都可以實現，這裏注意，Condition是被綁定到Lock上的，要創建一個Lock的Condition必須用newCondition()方法。
這樣看來，Condition和傳統的線程通信沒什麼區別，Condition的強大之處在於它可以爲多個線程間建立不同的Condition，下面引入API中的一段代碼，加以說明。
- class BoundedBuffer {
- final Lock lock = new ReentrantLock();//鎖對象
- final Condition notFull = lock.newCondition();//寫線程條件
- final Condition notEmpty = lock.newCondition();//讀線程條件
- final Object[] items = new Object[100];//緩存隊列
- int putptr, takeptr, count;
- public void put(Object x) throws InterruptedException {
- lock.lock();
- try {
- while (count == items.length)//如果隊列滿了
- notFull.await();//阻塞寫線程
- items[putptr] = x;//賦值
- if (++putptr == items.length) putptr = 0;//如果寫索引寫到隊列的最後一個位置了，那麼置爲0
- ++count;//個數++
- notEmpty.signal();//喚醒讀線程
- } finally {
- lock.unlock();
- }
- }
- public Object take() throws InterruptedException {
- lock.lock();
- try {
- while (count == 0)//如果隊列爲空
- notEmpty.await();//阻塞讀線程
- Object x = items[takeptr];//取值
- if (++takeptr == items.length) takeptr = 0;//如果讀索引讀到隊列的最後一個位置了，那麼置爲0
- --count;//個數--
- notFull.signal();//喚醒寫線程
- return x;
- } finally {
- lock.unlock();
- }
- }
- }
這是一個處於多線程工作環境下的緩存區，緩存區提供了兩個方法，put和take，put是存數據，take是取數據，內部有個緩存隊列，具體變量和方法說明見代碼，這個緩存區類實現的功能：有多個線程往裏面存數據和從裏面取數據，其緩存隊列(先進先出後進後出)能緩存的最大數值是100，多個線程間是互斥的，當緩存隊列中存儲的值達到100時，將寫線程阻塞，並喚醒讀線程，當緩存隊列中存儲的值爲0時，將讀線程阻塞，並喚醒寫線程，下面分析一下代碼的執行過程：
1. 一個寫線程執行，調用put方法；
2. 判斷count是否爲100，顯然沒有100；
3. 繼續執行，存入值；
4. 判斷當前寫入的索引位置++後，是否和100相等，相等將寫入索引值變爲0，並將count+1；
5. 僅喚醒讀線程阻塞隊列中的一個；
6. 一個讀線程執行，調用take方法；
7. ……
8. 僅喚醒寫線程阻塞隊列中的一個。
這就是多個Condition的強大之處，假設緩存隊列中已經存滿，那麼阻塞的肯定是寫線程，喚醒的肯定是讀線程，相反，阻塞的肯定是讀線程，喚醒的肯定是寫線程，那麼假設只有一個Condition會有什麼效果呢，緩存隊列中已經存滿，這個Lock不知道喚醒的是讀線程還是寫線程了，如果喚醒的是讀線程，皆大歡喜，如果喚醒的是寫線程，那麼線程剛被喚醒，又被阻塞了，這時又去喚醒，這樣就浪費了很多時間。