Java併發編程：線程間協做的兩種方式：wait、notify、notifyAll和Condition

在前面咱們將了不少關於同步的問題，然而在現實中，須要線程之間的協做。好比說最經典的生產者-消費者模型：當隊列滿時，生產者須要等待隊列有空間才能繼續往裏面放入商品，而在等待的期間內，生產者必須釋放對臨界資源（即隊列）的佔用權。由於生產者若是不釋放對臨界資源的佔用權，那麼消費者就沒法消費隊列中的商品，就不會讓隊列有空間，那麼生產者就會一直無限等待下去。所以，通常狀況下，當隊列滿時，會讓生產者交出對臨界資源的佔用權，並進入掛起狀態。而後等待消費者消費了商品，而後消費者通知生產者隊列有空間了。一樣地，當隊列空時，消費者也必須等待，等待生產者通知它隊列中有商品了。這種互相通訊的過程就是線程間的協做。

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

如下是本文目錄大綱：

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

二.Condition

三.生產者-消費者模型的實現

如有不正之處請多多諒解，並歡迎批評指正。

請尊重做者勞動成果，轉載請標明原文連接：

http://www.cnblogs.com/dolphin0520/p/3920385.html

一.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

*/

publicfinalnativevoidnotify();

/**

* 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.

*/

publicfinalnativevoidnotifyAll();

/**

* 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.

*/

publicfinalnativevoidwait(longtimeout)throwsInterruptedException;

  從這三個方法的文字描述能夠知道如下幾點信息：

1）wait()、notify()和notifyAll()方法是本地方法，而且爲final方法，沒法被重寫。

2）調用某個對象的wait()方法能讓當前線程阻塞，而且當前線程必須擁有此對象的monitor（即鎖）

3）調用某個對象的notify()方法可以喚醒一個正在等待這個對象的monitor的線程，若是有多個線程都在等待這個對象的monitor，則只能喚醒其中一個線程；

4）調用notifyAll()方法可以喚醒全部正在等待這個對象的monitor的線程；

有朋友可能會有疑問：爲什麼這三個不是Thread類聲明中的方法，而是Object類中聲明的方法（固然因爲Thread類繼承了Object類，因此Thread也能夠調用者三個方法）？其實這個問題很簡單，因爲每一個對象都擁有monitor（即鎖），因此讓當前線程等待某個對象的鎖，固然應該經過這個對象來操做了。而不是用當前線程來操做，由於當前線程可能會等待多個線程的鎖，若是經過線程來操做，就很是複雜了。

上面已經提到，若是調用某個對象的wait()方法，當前線程必須擁有這個對象的monitor（即鎖），所以調用wait()方法必須在同步塊或者同步方法中進行（synchronized塊或者synchronized方法）。

調用某個對象的wait()方法，至關於讓當前線程交出此對象的monitor，而後進入等待狀態，等待後續再次得到此對象的鎖（Thread類中的sleep方法使當前線程暫停執行一段時間，從而讓其餘線程有機會繼續執行，但它並不釋放對象鎖）；

notify()方法可以喚醒一個正在等待該對象的monitor的線程，當有多個線程都在等待該對象的monitor的話，則只能喚醒其中一個線程，具體喚醒哪一個線程則不得而知。

一樣地，調用某個對象的notify()方法，當前線程也必須擁有這個對象的monitor，所以調用notify()方法必須在同步塊或者同步方法中進行（synchronized塊或者synchronized方法）。

nofityAll()方法可以喚醒全部正在等待該對象的monitor的線程，這一點與notify()方法是不一樣的。

這裏要注意一點：notify()和notifyAll()方法只是喚醒等待該對象的monitor的線程，並不決定哪一個線程可以獲取到monitor。

舉個簡單的例子：假若有三個線程Thread一、Thread2和Thread3都在等待對象objectA的monitor，此時Thread4擁有對象objectA的monitor，當在Thread4中調用objectA.notify()方法以後，Thread一、Thread2和Thread3只有一個能被喚醒。注意，被喚醒不等於馬上就獲取了objectA的monitor。倘若在Thread4中調用objectA.notifyAll()方法，則Thread一、Thread2和Thread3三個線程都會被喚醒，至於哪一個線程接下來可以獲取到objectA的monitor就具體依賴於操做系統的調度了。

上面尤爲要注意一點，一個線程被喚醒不表明當即獲取了對象的monitor，只有等調用完notify()或者notifyAll()並退出synchronized塊，釋放對象鎖後，其他線程纔可得到鎖執行。

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

publicclassTest {

publicstaticObject object =newObject();

publicstaticvoidmain(String[] args) {

Thread1 thread1 =newThread1();

Thread2 thread2 =newThread2();

thread1.start();

try{

Thread.sleep(200);

}catch(InterruptedException e) {

e.printStackTrace();

}

thread2.start();

}

staticclassThread1extendsThread{

@Override

publicvoidrun() {

synchronized(object) {

try{

object.wait();

}catch(InterruptedException e) {

}

System.out.println("線程"+Thread.currentThread().getName()+"獲取到了鎖");

}

}

}

staticclassThread2extendsThread{

@Override

publicvoidrun() {

synchronized(object) {

object.notify();

System.out.println("線程"+Thread.currentThread().getName()+"調用了object.notify()");

}

System.out.println("線程"+Thread.currentThread().getName()+"釋放了鎖");

}

}

}

  不管運行多少次，運行結果一定是：

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

二.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()。

三.生產者-消費者模型的實現

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

publicclassTest {

privateintqueueSize =10;

privatePriorityQueue<Integer> queue =newPriorityQueue<Integer>(queueSize);

publicstaticvoidmain(String[] args)  {

Test test =newTest();

Producer producer = test.newProducer();

Consumer consumer = test.newConsumer();

producer.start();

consumer.start();

}

classConsumerextendsThread{

@Override

publicvoidrun() {

consume();

}

privatevoidconsume() {

while(true){

synchronized(queue) {

while(queue.size() ==0){

try{

System.out.println("隊列空，等待數據");

queue.wait();

}catch(InterruptedException e) {

e.printStackTrace();

queue.notify();

}

}

queue.poll();         //每次移走隊首元素

queue.notify();

System.out.println("從隊列取走一個元素，隊列剩餘"+queue.size()+"個元素");

}

}

}

}

classProducerextendsThread{

@Override

publicvoidrun() {

produce();

}

privatevoidproduce() {

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實現

publicclassTest {

privateintqueueSize =10;

privatePriorityQueue<Integer> queue =newPriorityQueue<Integer>(queueSize);

privateLock lock =newReentrantLock();

privateCondition notFull = lock.newCondition();

privateCondition notEmpty = lock.newCondition();

publicstaticvoidmain(String[] args)  {

Test test =newTest();

Producer producer = test.newProducer();

Consumer consumer = test.newConsumer();

producer.start();

consumer.start();

}

classConsumerextendsThread{

@Override

publicvoidrun() {

consume();

}

privatevoidconsume() {

while(true){

lock.lock();

try{

while(queue.size() ==0){

try{

System.out.println("隊列空，等待數據");

notEmpty.await();

}catch(InterruptedException e) {

e.printStackTrace();

}

}

queue.poll();               //每次移走隊首元素

notFull.signal();

System.out.println("從隊列取走一個元素，隊列剩餘"+queue.size()+"個元素");

}finally{

lock.unlock();

}

}

}

}

classProducerextendsThread{

@Override

publicvoidrun() {

produce();

}

privatevoidproduce() {

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

來源： <http://www.cnblogs.com/dolphin0520/p/3920385.html>