原文作者：Matrix海 子

原文地址：Java并發(fā)編程：線程間協(xié)作的兩種方式：wait、notify、notifyAll和Condition

目錄

一.wait()、notify()和notifyAll()

二.Condition

三.生產(chǎn)者-消費者模型的實現(xiàn)

---

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

今天我們就來探討一下Java中線程協(xié)作的最常見的兩種方式：利用Object.wait()、Object.notify()和使用Condition

一.wait()、notify()和notifyAll()

wait()、notify()和notifyAll()是Object類中的方法：

/*** Wakes up a single thread that is waiting on this object's* monitor. If any threads are waiting on this object, one of them* is chosen to be awakened. The choice is arbitrary and occurs at* the discretion of the implementation. A thread waits on an object's* monitor by calling one of the wait methods*/ public final native void notify();/*** Wakes up all threads that are waiting on this object's monitor. A* thread waits on an object's monitor by calling one of the* wait methods.*/ public final native void notifyAll();/*** Causes the current thread to wait until either another thread invokes the* {@link java.lang.Object#notify()} method or the* {@link java.lang.Object#notifyAll()} method for this object, or a* specified amount of time has elapsed.* <p>* The current thread must own this object's monitor.*/ public final native void wait(long timeout) throws InterruptedException;

從這三個方法的文字描述可以知道以下幾點信息：

• wait()、notify()和notifyAll()方法是本地方法，并且為final方法，無法被重寫。
• 調(diào)用某個對象的wait()方法能讓當前線程阻塞，并且當前線程必須擁有此對象的monitor鎖
• 調(diào)用某個對象的notify()方法能夠喚醒一個正在等待這個對象的monitor的線程，如果有多個線程都在等待這個對象的monitor，則只能喚醒其中一個線程；
• 調(diào)用notifyAll()方法能夠喚醒所有正在等待這個對象的monitor的線程；

有朋友可能會有疑問：為何這三個不是Thread類聲明中的方法，而是Object類中聲明的方法（當然由于Thread類繼承了Object類，所以Thread也可以調(diào)用者三個方法）？其實這個問題很簡單，由于每個對象都擁有monitor（即鎖），所以讓當前線程等待某個對象的鎖，當然應(yīng)該通過這個對象來操作了。而不是用當前線程來操作，因為當前線程可能會等待多個線程的鎖，如果通過線程來操作，就非常復(fù)雜了。上面已經(jīng)提到，如果調(diào)用某個對象的wait()方法，當前線程必須擁有這個對象的monitor（即鎖），因此調(diào)用wait()方法必須在同步塊或者同步方法中進行（synchronized塊或者synchronized方法）。調(diào)用某個對象的wait()方法，相當于讓當前線程交出此對象的monitor，然后進入等待狀態(tài)，等待后續(xù)再次獲得此對象的鎖（Thread類中的sleep方法使當前線程暫停執(zhí)行一段時間，從而讓其他線程有機會繼續(xù)執(zhí)行，但它并不釋放對象鎖）；

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

nofityAll()方法能夠喚醒所有正在等待該對象的monitor的線程，這一點與notify()方法是不同的。

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

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

下面看一個例子就明白了：

public class Test {public static Object object = new Object();public static void main(String[] args) {Thread1 thread1 = new Thread1();Thread2 thread2 = new Thread2();thread1.start();try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}thread2.start();}static class Thread1 extends Thread{@Overridepublic void run() {synchronized (object) {try {object.wait();} catch (InterruptedException e) {}System.out.println("線程"+Thread.currentThread().getName()+"獲取到了鎖");}}}static class Thread2 extends Thread{@Overridepublic void run() {synchronized (object) {object.notify();System.out.println("線程"+Thread.currentThread().getName()+"調(diào)用了object.notify()");}System.out.println("線程"+Thread.currentThread().getName()+"釋放了鎖");}} }

無論運行多少次，運行結(jié)果必定是：

線程Thread-1調(diào)用了object.notify() 線程Thread-1釋放了鎖 線程Thread-0獲取到了鎖

二.Condition

Condition是在java 1.5中才出現(xiàn)的，它用來替代傳統(tǒng)的Object的wait()、notify()實現(xiàn)線程間的協(xié)作，相比使用Object的wait()、notify()，使用Condition的await()、signal()這種方式實現(xiàn)線程間協(xié)作更加安全和高效。因此通常來說比較推薦使用Condition，阻塞隊列實際上是使用了Condition來模擬線程間協(xié)作。

• Condition是個接口，基本的方法就是await()和signal()方法；
• Condition依賴于Lock接口，生成一個Condition的基本代碼是lock.newCondition()?
• ?調(diào)用Condition的await()和signal()方法，都必須在lock保護之內(nèi)，就是說必須在lock.lock()和lock.unlock之間才可以使用

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

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

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

三.生產(chǎn)者-消費者模型的實現(xiàn)

1.使用Object的wait()和notify()實現(xiàn)：

public class Test {private int queueSize = 10;private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);public static void main(String[] args) {Test test = new Test();Producer producer = test.new Producer();Consumer consumer = test.new Consumer();producer.start();consumer.start();}class Consumer extends Thread{@Overridepublic 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{@Overridepublic 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()));}}}} }

?2.使用Condition實現(xiàn)

public class Test {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) {Test test = new Test();Producer producer = test.new Producer();Consumer consumer = test.new Consumer();producer.start();consumer.start();}class Consumer extends Thread{@Overridepublic void run() {consume();}private void consume() {while(true){lock.lock();try {while(queue.size() == 0){try {System.out.println("隊列空，等待數(shù)據(jù)");notEmpty.await();} catch (InterruptedException e) {e.printStackTrace();}}queue.poll(); //每次移走隊首元素notFull.signal();System.out.println("從隊列取走一個元素，隊列剩余"+queue.size()+"個元素");} finally{lock.unlock();}}}}class Producer extends Thread{@Overridepublic void run() {produce();}private void produce() {while(true){lock.lock();try {while(queue.size() == queueSize){try {System.out.println("隊列滿，等待有空余空間");notFull.await();} catch (InterruptedException e) {e.printStackTrace();}}queue.offer(1); //每次插入一個元素notEmpty.signal();System.out.println("向隊列取中插入一個元素，隊列剩余空間："+(queueSize-queue.size()));} finally{lock.unlock();}}}} }

參考資料：

《Java編程思想》

http://blog.csdn.net/ns_code/article/details/17225469

http://blog.csdn.net/ghsau/article/details/7481142

總結(jié)

以上是生活随笔為你收集整理的Java并发编程—线程间协作方式wait()、notify()、notifyAll()和Condition的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

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