在前面我們將了很多關於同步的問題，然而在現實中，需要線程之間的協作。比如說最經典的生產者-消費者模型：當隊列滿時，生產者需要等待隊列有空間才能繼續往里面放入商品，而在等待的期間內，生產者必須釋放對臨界資源（即隊列）的占用權。因為生產者如果不釋放對臨界資源的占用權，那么消費者就無法消費隊列中的商品，就不會讓隊列有空間，那么生產者就會一直無限等待下去。因此，一般情況下，當隊列滿時，會讓生產者交出對臨界資源的占用權，並進入掛起狀態。然后等待消費者消費了商品，然后消費者通知生產者隊列有空間了。同樣地，當隊列空時，消費者也必須等待，等待生產者通知它隊列中有商品了。這種互相通信的過程就是線程間的協作。
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;
從這三個方法的文字描述可以知道以下幾點信息：
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。
舉個簡單的例子：假如有三個線程Thread1、Thread2和Thread3都在等待對象objectA的monitor，此時Thread4擁有對象objectA的monitor，當在Thread4中調用objectA.notify()方法之后，Thread1、Thread2和Thread3只有一個能被喚醒。注意，被喚醒不等於立刻就獲取了objectA的monitor。假若在Thread4中調用objectA.notifyAll()方法，則Thread1、Thread2和Thread3三個線程都會被喚醒，至於哪個線程接下來能夠獲取到objectA的monitor就具體依賴於操作系統的調度了。
上面尤其要注意一點，一個線程被喚醒不代表立即獲取了對象的monitor，只有等調用完notify()或者notifyAll()並退出synchronized塊，釋放對象鎖后，其余線程才可獲得鎖執行。
下面看一個例子就明白了：
package com.csu.thread;
public class test4 {
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{
@Override
public void run() {
synchronized (object) {
try {
object.wait();
} catch (InterruptedException e) {
}
System.out.println("線程"+Thread.currentThread().getName()+"獲取到了鎖");
}
}
}
static class Thread2 extends Thread{
@Override
public void run() {
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()實現：
package com.csu.thread;
import java.util.PriorityQueue;
public class PCByObject {
private PriorityQueue<Integer> queue=new PriorityQueue<>(10);
public static void main(String[] args) {
// TODO Auto-generated method stub
PCByObject object=new PCByObject();
Producer producer=object.new Producer();
Consumer consumer=object.new Consumer();
producer.start();
consumer.start();
}
class Consumer extends Thread
{
@Override
public void run()
{
consume();
}
private void consume()
{
while(true)
{
synchronized (queue) {
while(queue.size()==0)
{
try {
System.out.println("隊列為空");
queue.wait();
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
queue.notify();
}
}
queue.poll();
queue.notify();
System.out.println("取走一個元素,還有："+queue.size());
}
}
}
}
class Producer extends Thread
{
@Override
public void run()
{
produce();
}
private void produce()
{
while(true)
{
synchronized (queue) {
while(queue.size()==10)
{
try {
System.out.println("隊列已經滿了");
queue.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
queue.offer(1);
queue.notify();
System.out.println("向隊列中插入一個元素，長度為"+queue.size());
}
}
}
}
}
2:使用Condition實現
package com.csu.thread;
import java.util.PriorityQueue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class PCByCondition {
private PriorityQueue<Integer> queue=new PriorityQueue<>(10);
private ReentrantLock lock=new ReentrantLock();
private Condition notFull=lock.newCondition();
private Condition notEmpty=lock.newCondition();
public static void main(String[] args) {
// TODO Auto-generated method stub
PCByCondition object=new PCByCondition();
Producer producer=object.new Producer();
Consumer consumer=object.new Consumer();
producer.start();
consumer.start();
}
class Consumer extends Thread
{
@Override
public void run()
{
consume();
}
private void consume()
{
while(true)
{
lock.lock();
try {
while(queue.size()==0)
{
try {
System.out.println("隊列為空");
notEmpty.await();
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
queue.poll();
notFull.signal();
System.out.println("取走一個元素,還有："+queue.size());
}finally
{
lock.unlock();
}
}
}
}
class Producer extends Thread
{
@Override
public void run()
{
produce();
}
private void produce()
{
while(true)
{
lock.lock();
try{
while(queue.size()==10)
{
try {
System.out.println("隊列已經滿了");
notFull.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
queue.offer(1);
notEmpty.signal();
System.out.println("向隊列中插入一個元素，長度為"+queue.size());
}finally
{
lock.unlock();
}
}
}
}
}