java多线程之 wait(),notify(),notifyAll() 整理

java多线程之 wait(),notify(),notifyAll() 整理

转自：http://hi.baidu.com/zhizhesky/blog/item/3665de62b1d03ccde6113af9.html

wait(),notify(),notifyAll()不属于Thread类,而是属于Object基础类,也就是说每个对像都有wait(),notify(),notifyAll()的功能.因为都个对像都有锁,锁是每个对像的基础,当然操作锁的方法也是最基础了.

先看java doc怎么说:
wait导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。当前的线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行.

notify唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。此方法只应由作为此对象监视器的所有者的线程来调用.

"当前的线程必须拥有此对象监视器"与"此方法只应由作为此对象监视器的所有者的线程来调用"说明wait方法与notify方法必须在同步块内执行,即synchronized(obj之内).

调用对像wait方法后,当前线程释放对像锁,进入等待状态.直到其他线程(也只能是其他线程)通过notify 方法，或 notifyAll.该线程重新获得对像锁.


继续执行,记得线程必须重新获得对像锁才能继续执行.因为synchronized代码块内没有锁是寸步不能走的.看一个很经典的例子:



package ProductAndConsume;

import java.util.List;

public class Consume implements Runnable {
private List container = null;
private int count;

public Consume(List lst) {
   this.container = lst;
}

public void run() {

   while (true) {
    synchronized (container) {
     if (container.size() == 0) {
      try {
       container.wait();// 放弃锁
      } catch (InterruptedException e) {
       e.printStackTrace();
      }
     }
     try {
      Thread.sleep(100);
     } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
     container.remove(0);
     container.notify();
     System.out.println("我吃了" + (++count) + "个");
    }
   }

}

}

package ProductAndConsume;

import java.util.List;

public class Product implements Runnable {
private List container = null;
private int count;

public Product(List lst) {
   this.container = lst;
}

public void run() {
   while (true) {
    synchronized (container) {
     if (container.size() > MultiThread.MAX) {
      try {
       container.wait();
      } catch (InterruptedException e) {
       e.printStackTrace();
      }
     }
     try {
      Thread.sleep(100);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
     container.add(new Object());
     container.notify();
     System.out.println("我生产了" + (++count) + "个");
    }
   }

}

}

package ProductAndConsume;

import java.util.ArrayList;
import java.util.List;

public class MultiThread {
private List container = new ArrayList();

public final static int MAX = 5;

public static void main(String args[]) {

   MultiThread m = new MultiThread();

   new Thread(new Consume(m.getContainer())).start();
   new Thread(new Product(m.getContainer())).start();
   new Thread(new Consume(m.getContainer())).start();
   new Thread(new Product(m.getContainer())).start();
}

public List getContainer() {
   return container;
}

public void setContainer(List container) {
   this.container = container;
}
}

通常，多线程之间需要协调工作。例如，浏览器的一个显示图片的线程displayThread想要执行显示图片的任务，必须等待下载线程downloadThread将该图片下载完毕。如果图片还没有下载完，displayThread可以暂停，当downloadThread完成了任务后，再通知displayThread“图片准备完毕，可以显示了”，这时，displayThread继续执行。

　　以上逻辑简单的说就是：如果条件不满足，则等待。当条件满足时，等待该条件的线程将被唤醒。在Java中，这个机制的实现依赖于wait/notify。等待机制与锁机制是密切关联的。例如：

synchronized(obj) {
while(!condition) {
obj.wait();
}
obj.doSomething();
}

　　当线程A获得了obj锁后，发现条件condition不满足，无法继续下一处理，于是线程A就wait()。

　　在另一线程B中，如果B更改了某些条件，使得线程A的condition条件满足了，就可以唤醒线程A：

synchronized(obj) {
condition = true;
obj.notify();
}

　　需要注意的概念是：

　　◆调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) {...} 代码段内。

　　◆调用obj.wait()后，线程A就释放了obj的锁，否则线程B无法获得obj锁，也就无法在synchronized(obj) {...} 代码段内唤醒A。

　　◆当obj.wait()方法返回后，线程A需要再次获得obj锁，才能继续执行。

　　◆如果A1,A2,A3都在obj.wait()，则B调用obj.notify()只能唤醒A1,A2,A3中的一个（具体哪一个由JVM决定）。

　　◆obj.notifyAll()则能全部唤醒A1,A2,A3，但是要继续执行obj.wait()的下一条语句，必须获得obj锁，因此，A1,A2,A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj锁之后才能继续执行。

　　◆当B调用obj.notify/notifyAll的时候，B正持有obj锁，因此，A1,A2,A3虽被唤醒，但是仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1,A2,A3中的一个才有机会获得锁继续执行。

wait/notify 还可以用来让线程执行完：

class ThreadA
{
public static void main(String[] args)
{
    ThreadB b=new ThreadB();
    b.start();
    System.out.println("b is start....");
    synchronized(b){ // 同步块，锁定 b 对象资源，从而可以使用 b.wait()
      try
      {
         System.out.println("Waiting for b to complete...");
        b.wait();//让当前主线程wait，等待 ThreadB b 调用 他自身的 notify
        System.out.println("Completed.Now back to main thread");
      }catch (InterruptedException e){}
    }
    System.out.println("Total is :"+b.total);
   }
}

class ThreadB extends Thread
{
int total;
public void run()
{
    synchronized(this)
    {
      System.out.println("ThreadB is running..");
      for (int i=0;i<100;i++ )
      {
        total +=i;
        System.out.println("total is "+total);
      }
      notify();
    }
}
}