通過一個經(jīng)典的例子—生產(chǎn)者與消費者模型來理解一下線程的協(xié)作：

當(dāng)隊列滿時，生產(chǎn)者需要等待隊列有空間才能繼續(xù)往里面放入商品，而在等待的期間內(nèi)，生產(chǎn)者必須釋放對臨界資源（即隊列）的占用權(quán)。因為生產(chǎn)者如果不釋放對臨界資源的占用權(quán)，那么消費者就無法消費隊列中的商品，就不會讓隊列有空間，那么生產(chǎn)者就會一直無限等待下去。因此，一般情況下，當(dāng)隊列滿時，會讓生產(chǎn)者交出對臨界資源的占用權(quán)，并進入掛起狀態(tài)。然后等待消費者消費了商品，然后消費者通知生產(chǎn)者隊列有空間了。同樣地，當(dāng)隊列空時，消費者也必須等待，等待生產(chǎn)者通知它隊列中有商品了。這種互相通信的過程就是線程間的協(xié)作。

java中線程協(xié)作的兩種方式：

1、利用Object.wait()、Object.notify()；
2、使用Condition；

第一種：利用Object.wait()、Object.notify()；

1）wait()、notify()和notifyAll()方法是本地方法，并且為final方法，無法被重寫。

2）調(diào)用某個對象的wait()方法能讓當(dāng)前線程阻塞，并且當(dāng)前線程必須擁有此對象的monitor（即鎖）;

3）調(diào)用某個對象的notify()方法能夠喚醒一個正在等待這個對象的monitor的線程，如果有多個線程都在等待這個對象的monitor，則只能喚醒其中一個線程；

4）調(diào)用notifyAll()方法能夠喚醒所有正在等待這個對象的monitor的線程；

注意：

1、這三個方法不是Thread類聲明中的方法，而是Object類中聲明的方法（當(dāng)然由于Thread類繼承了Object類，所以Thread也可以調(diào)用者三個方法；）由于每個對象都擁有monitor（即鎖），所以讓當(dāng)前線程等待某個對象的鎖，當(dāng)然應(yīng)該通過這個對象來操作了。而不是用當(dāng)前線程來操作，因為當(dāng)前線程可能會等待多個線程的鎖，如果通過線程來操作，就非常復(fù)雜了。

2、wait()

如果調(diào)用某個對象的wait()方法，當(dāng)前線程必須擁有這個對象的monitor（即鎖），因此調(diào)用wait()方法必須在同步塊或者同步方法中進行（synchronized塊或者synchronized方法）。同時，調(diào)用某個對象的wait()方法，相當(dāng)于讓當(dāng)前線程交出此對象的monitor，然后進入等待狀態(tài)，等待后續(xù)再次獲得此對象的鎖（Thread類中的sleep方法使當(dāng)前線程暫停執(zhí)行一段時間，從而讓其他線程有機會繼續(xù)執(zhí)行，但它并不釋放對象鎖）；

3、wait（long）和wait（long,int）

顯然，這兩個方法是設(shè)置等待超時時間的，后者在超值時間上加上ns，精度也難以達到，因此，該方法很少使用。對于前者，如果在等待線程接到通知或被中斷之前，已經(jīng)超過了指定的毫秒數(shù)，則它通過競爭重新獲得鎖，并從wait（long）返回。另外，需要知道，如果設(shè)置了超時時間，當(dāng)wait（）返回時，我們不能確定它是因為接到了通知還是因為超時而返回的，因為wait（）方法不會返回任何相關(guān)的信息。但一般可以通過設(shè)置標(biāo)志位來判斷，在notify之前改變標(biāo)志位的值，在wait（）方法后讀取該標(biāo)志位的值來判斷，當(dāng)然為了保證notify不被遺漏，我們還需要另外一個標(biāo)志位來循環(huán)判斷是否調(diào)用wait（）方法。

4、notify()

notify()方法能夠喚醒一個正在等待該對象的monitor的線程，當(dāng)有多個線程都在等待該對象的monitor的話，則只能喚醒其中一個線程，具體喚醒哪個線程則不得而知。同樣地，調(diào)用某個對象的notify()方法，當(dāng)前線程也必須擁有這個對象的monitor，因此調(diào)用notify()方法必須在同步塊或者同步方法中進行（synchronized塊或者synchronized方法）。

5、nofityAll()

nofityAll()方法能夠喚醒所有正在等待該對象的monitor的線程，這一點與notify()方法是不同的。notify()和notifyAll()方法只是喚醒等待該對象的monitor的線程，并不決定哪個線程能夠獲取到monitor。

6、一個線程被喚醒不代表立即獲取了對象的monitor，只有等調(diào)用完notify()或者notifyAll()并退出synchronized塊，釋放對象鎖后，其余線程才可獲得鎖執(zhí)行。

　　舉個簡單的例子：假如有三個線程Thread1、Thread2和Thread3都在等待對象objectA的monitor，此時Thread4擁有對象objectA的monitor，當(dāng)在Thread4中調(diào)用objectA.notify()方法之后，Thread1、Thread2和Thread3只有一個能被喚醒。注意，被喚醒不等于立刻就獲取了objectA的monitor。假若在Thread4中調(diào)用objectA.notifyAll()方法，則Thread1、Thread2和Thread3三個線程都會被喚醒，至于哪個線程接下來能夠獲取到objectA的monitor就具體依賴于操作系統(tǒng)的調(diào)度了。

舉例如下：

TestThread.java

public class TestThread {public static Object object = new Object();static class Thread-0 extends Thread{public void run() {synchronized (object) {try {object.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("線程"+Thread.currentThread().getName()+"獲取到了鎖");}}}static class Thread-1 extends Thread{public void run() {synchronized (object) {object.notify();//將處于等待狀態(tài)的線程(Thread-0)喚醒System.out.println("線程"+Thread.currentThread().getName()+"調(diào)用了object.notify()");}System.out.println("線程"+Thread.currentThread().getName()+"釋放了鎖");}}public static void main(String[] args) {Thread-0 thread-0 = new Thread-0();Thread-1 thread-1 = new Thread-1();thread-0.start();try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}thread-1.start();} }

運行結(jié)果：
線程Thread-1調(diào)用了object.notify()
線程Thread-1釋放了鎖
線程Thread-0獲取到了鎖

第二種：利用condition；

1、Condition是在java 1.5中才出現(xiàn)的，它用來替代傳統(tǒng)的Object的wait()、notify()實現(xiàn)線程間的協(xié)作，相比使用Object的wait()、notify()，使用Condition1的await()、signal()這種方式實現(xiàn)線程間協(xié)作更加安全和高效。Lock 替代了 synchronized 方法和語句的使用，Condition 替代了 Object 監(jiān)視器方法的使用。因此通常來說比較推薦使用Condition，在阻塞隊列那一篇博文中就講述到了，阻塞隊列實際上是使用了Condition來模擬線程間協(xié)作。

2、Condition是個接口，基本的方法就是await()和signal()方法；

3、Condition依賴于Lock接口，生成一個Condition的基本代碼是lock.newCondition()

4、 調(diào)用Condition的await()和signal()方法，都必須在lock保護之內(nèi)，就是說必須在lock.lock()和lock.unlock之間才可以使用

5、Conditon中的await()對應(yīng)Object的wait()；

6、Condition中的signal()對應(yīng)Object的notify()；

7、Condition中的signalAll()對應(yīng)Object的notifyAll()。

8、條件（也稱為條件隊列 或條件變量）為線程提供了一個含義，以便在某個狀態(tài)條件現(xiàn)在可能為 true 的另一個線程通知它之前，一直掛起該線程（即讓其“等待”）。因為訪問此共享狀態(tài)信息發(fā)生在不同的線程中，所以它必須受保護，因此要將某種形式的鎖與該條件相關(guān)聯(lián)。等待提供一個條件的主要屬性是：釋放相關(guān)的鎖，并掛起當(dāng)前線程，就像 Object.wait 做的那樣。 Condition 實例實質(zhì)上被綁定到一個鎖上。要為特定 Lock 實例獲得 Condition 實例，請使用其 newCondition() 方法。

注意：

Condition 實例只是一些普通的對象，它們自身可以用作 synchronized 語句中的目標(biāo)，并且可以調(diào)用自己的 wait 和 notification 監(jiān)視器方法。獲取 Condition 實例的監(jiān)視器鎖或者使用其監(jiān)視器方法，與獲取和該 Condition 相關(guān)的 Lock 或使用其 waiting 和 signalling 方法沒有什么特定的關(guān)系。為了避免混淆，建議除了在其自身的實現(xiàn)中之外，切勿以這種方式使用 Condition 實例。 除非另行說明，否則為任何參數(shù)傳遞 null 值將導(dǎo)致拋出 NullPointerException。

有關(guān)condition的詳細(xì)用法請查看相關(guān)API；

分別用以上兩種方法實現(xiàn)生產(chǎn)者—消費者模式：

示例一：利用object.wait和object.notify實現(xiàn)生產(chǎn)者-消費者模式

　
Test01.java

import java.util.PriorityQueue;public class Test01{private int queueSize = 10;private PriorityQueue<Integer queue = new PriorityQueue<Integer(queueSize);public static void main(String[] args) {Test01 test = new Test01();Producer producer = test.new Producer();Consumer consumer = test.new Consumer();producer.start();consumer.start();}class Consumer extends Thread{public void run() {consume();}private void consume() {while(true){synchronized (queue) {while(queue.size() == 0){try {System.out.println("隊列空，等待數(shù)據(jù)");queue.wait();} catch (InterruptedException e) {e.printStackTrace();queue.notify();}}queue.poll(); //每次移走隊首元素queue.notify();System.out.println("從隊列取走一個元素，隊列剩余"+queue.size()+"個元素");}}}}class Producer extends Thread{public void run() {produce();}private void produce() {while(true){synchronized (queue) {while(queue.size() == queueSize){try {System.out.println("隊列滿，等待有空余空間");queue.wait();} catch (InterruptedException e) {e.printStackTrace();queue.notify();}}queue.offer(1); //每次插入一個元素queue.notify();System.out.println("向隊列取中插入一個元素，隊列剩余空間："+(queueSize-queue.size()));}}}} }

示例二：利用condition實現(xiàn)生產(chǎn)者-消費者模式

　
Test02 .java

import java.util.PriorityQueue; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;public class Test02 {private int queueSize = 10;private PriorityQueue<Integer> queue = new PriorityQueue<Integer(queueSize);private Lock lock = new ReentrantLock();private Condition notFull = lock.newCondition();private Condition notEmpty = lock.newCondition();public static void main(String[] args) {Test02 test = new Test02();Producer producer = test.new Producer();Consumer consumer = test.new Consumer();producer.start();consumer.start();}class Consumer extends Thread{public void run() {consume();}private void consume() {while(true){lock.lock();try {while(queue.size() == 0){try {System.out.println("隊列空，等待數(shù)據(jù)");notEmpty.await();//讓當(dāng)前線程(消費者線程)在接到信號或被中斷之前一直處于等待狀態(tài)} catch (InterruptedException e) {e.printStackTrace();}}queue.poll(); //每次移走隊首元素notFull.signal();//喚醒消費者線程System.out.println("從隊列取走一個元素，隊列剩余"+queue.size()+"個元素");} finally{lock.unlock();}}}}class Producer extends Thread{public void run() {produce();}private void produce() {while(true){lock.lock();try {while(queue.size() == queueSize){try {System.out.println("隊列滿，等待有空余空間");notFull.await();//讓當(dāng)前線程(生產(chǎn)者線程)在接到信號或被中斷之前一直處于等待狀態(tài)} catch (InterruptedException e) {e.printStackTrace();}}queue.offer(1); //每次插入一個元素notEmpty.signal();//喚醒生產(chǎn)者線程System.out.println("向隊列取中插入一個元素，隊列剩余空間："+(queueSize-queue.size()));} finally{lock.unlock();}}}} } 超強干貨來襲 云風(fēng)專訪：近40年碼齡，通宵達旦的技術(shù)人生

總結(jié)

以上是生活随笔為你收集整理的【Java线程】线程协作的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。