Object类wait,notify,notifyAll的使用

这三个方法是java的基础类Object中定义的。

Java所有的类都具有线程的潜力，Java赋予的每个对象一个锁，在计算机内部工作在同一时间，只有一个对象可以持有锁，也就是说程序在同一时间只有一个程序可以运行，这里我把对象比作是一个小的程序。而多处理器，那么就另当别论了。

在这里我们首先学习一下公共方法wait,notify,notifyAll。

wait方法可以使在当前线程的对象等待，直到别的线程调用此对象的notify或notifyAll方法（注意：调用的是此对象的notify和notifyAll），并且当前运行的线程必须具有此对象的对象监视器，对象监视器我们可以从三个方法中获得，如下：

1.在执行对象实例同步方法体中，可以获得此对象的对象监视器，例子伪代码如下：

synchronized void aMethod(){

while(condition)

this.wait();

//other mothed;
}

2.通过执行对象同步synchronized正文，例子伪代码如下：

synchronized(this){

while(condition)

this.wait();

//other mothed;
}

3.对于 Class 类型的对象，可以通过执行该类的同步静态方法

这个方法可以使当前对象满足条件condition后，执行等待，当前线程对象放弃锁，cpu记录当前线程状态，以备下次回复。然后让其他线程运行,直到其他线程调用此对象的notify或notifyAll方法，此对象才会重新获得此对象的对象监视器，此对象才能重新运行。

注意:调用这个方法，必须具有对象监视器，也就是说我们必须在这三种方法选一种来获得对象监视器，如果调用此方法wait，却没用对象监视器，那么运行时会抛出IllegalMonitorStateException.

而且，在静态方法中也无法获得对象监视器，只能在Class类型的对象中，我们才可以通过调用该类的同步静态方法来获得对象监视器。

wait()

JDk文档写道

在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。
当前线程必须拥有此对象监视器 。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。

对于某一个参数的版本，实现中断和虚假唤醒是可能的，而且此方法应始终在循环中使用：

1 2 3 4 5

synchronized (obj) { while (<condition does not hold>) obj.wait(); ... // Perform action appropriate to condition }

此方法只应由作为此对象监视器的所有者的线程来调用。

抛出：

IllegalMonitorStateException - 如果当前线程不是此对象监视器的所有者。

InterruptedException - 如果在当前线程等待通知之前或者正在等待通知时，任何线程中断了当前线程。在抛出此异常时，当前线程的中断状态 被清除。

对于红色部分的内容，个人曾一直都不是很理解，什么叫做拥有此对象的监视器。下面我们看看代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

DateFormat format = new SimpleDateFormat("yyyy-MM-dd:hh:mm:ss"); private String getTime(){ return format.format(Calendar.getInstance().getTime()); } private Object monitor = new Object(); public void waitOnce(String thread, final long ms) { Thread waitThread = new Thread() { public void run() { synchronized (monitor) {//获得对象监视器 try { System.out.println("Thread " + Thread.currentThread().getName() + " Wait at " + getTime()); monitor.wait(ms); System.out.println("Thread " + Thread.currentThread().getName() + " Waked at " + getTime()); } catch (InterruptedException e) { } } }; }; waitThread.setName(thread); waitThread.start(); }

如果我们去掉synchronized(monitor) ，运行则会出现异常IllegalMonitorStateException。

1 2	WaitAndNotifyTest test = new WaitAndNotifyTest(); test.waitOnce("1", Long.MAX_VALUE);

写道

Exception in thread “1″ java.lang.IllegalMonitorStateException

而加上以后就没问题了。因此个人觉得使用synchronized关键字锁定对象，也就是获得了对象的监视器了。

notify()

JDK文档 写道

唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程 。选择是任意性 的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。

直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程 。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。

此方法只应由作为此对象监视器的所有者的线程来调用。通过以下三种方法之一，线程可以成为此对象监视器的所有者：

通过执行此对象的同步实例方法。
通过执行在此对象上进行同步的 synchronized 语句的正文。
对于 Class 类型的对象，可以通过执行该类的同步静态方法。

一次只能有一个线程拥有对象的监视器。

抛出：
IllegalMonitorStateException – 如果当前线程不是此对象监视器的所有者。

首先理解一下获得对象的监视器，简单的说就是取得了当前对象的“加锁”使用权，最简单的就是使用synchronized关键字。另外使用 synchronized修饰的方法也行。

notify方法还有一个值得提出的是它会在当前线程释放了对象锁以后随机唤醒一个在该对象上等待的线程 。

看看一个例子：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

public void awakeAndWait(String thread, final long ms) { Thread notifyThread = new Thread() { public void run() { synchronized (monitor) { monitor.notify(); System.out.println("Thread " + Thread.currentThread().getName() + " Notify at " + getTime()); //保持了对象锁的等待 try { Thread.sleep(ms); } catch (InterruptedException e) { } } //释放了对象锁之后的等待 try { Thread.sleep(ms); } catch (InterruptedException e) { } }; }; notifyThread.setName(thread); notifyThread.start(); }

这个方法会唤醒一个在对象上等待的线程，并在两次sleep后退出，注意的是一个sleep是在对象锁内，而另一次则是在释放了对象锁以后，这时候运行上面2个方法得到：

1 2 3 4 5 6 7 8 9 10 11

WaitAndNotifyTest test = new WaitAndNotifyTest(); test.waitOnce("1", Long.MAX_VALUE);// 在对象上等待无限长 test.waitOnce("2", Long.MAX_VALUE);// 在对象上等待无限长 test.waitOnce("3", Long.MAX_VALUE);// 在对象上等待无限长 try {// 延迟2s Thread.sleep(2000); } catch (InterruptedException e) { } // 在唤醒一个在对象上等待的线程，本身执行时间4s，2s是在对象锁内 //，2s是在释放了对象锁以后 test.awakeAndWait("3", 2000);

执行结果为：

写道

Thread 1 Wait at 2011-05-06:10:57:04
Thread 2 Wait at 2011-05-06:10:57:04
Thread 3 Wait at 2011-05-06:10:57:04
Thread 3 Notify at 2011-05-06:10:57:06
Thread 1 Waked at 2011-05-06:10:57:08

2秒后唤醒了线程1，尽管它自己执行花了4s，在释放了对象锁之后的2s不会影响线程1的执行。

notifyAll()

JDK文档 写道

唤醒在此对象监视器上等待的所有线程 。线程通过调用其中一个 wait 方法，在对象的监视器上等待。
直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。

此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述，请参阅 notify 方法。

抛出：
IllegalMonitorStateException – 如果当前线程不是此对象监视器的所有者。

与notify稍微有一点差别的是，它会唤醒所有的等待线程。

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public void awakeAll(String thread) { Thread notifyThread = new Thread() { public void run() { synchronized (monitor) { monitor.notifyAll(); System.out.println("Thread " + Thread.currentThread().getName() + " Notify all at " + getTime()); } }; }; notifyThread.setName(thread); notifyThread.start(); }

执行一下代码：

1 2 3 4 5 6 7 8 9

WaitAndNotifyTest test = new WaitAndNotifyTest(); test.waitOnce("1", Long.MAX_VALUE);// 在对象上等待无限长 test.waitOnce("2", Long.MAX_VALUE);// 在对象上等待无限长 test.waitOnce("3", Long.MAX_VALUE);// 在对象上等待无限长 try {// 延迟2s Thread.sleep(2000); } catch (InterruptedException e) { } test.awakeAll("4");

结果为：

写道

Thread 1 Wait at 2011-05-06:10:59:15
Thread 3 Wait at 2011-05-06:10:59:15
Thread 2 Wait at 2011-05-06:10:59:15
Thread 4 Notify all at 2011-05-06:10:59:17
Thread 2 Waked at 2011-05-06:10:59:17
Thread 3 Waked at 2011-05-06:10:59:17
Thread 1 Waked at 2011-05-06:10:59:17

全部唤醒了。

总结

总结一下：大概有以下几点：

1. wait(),notify(),notifyAll()都需要在拥有对象监视器的前提下执行，否则会出现异常IllegalMonitorStateException。
2. 多个线程可以同时在一个对象上等待。
3. notify()将随机唤醒一个在对象上等待的线程，没有一个都没有，则什么都不做。
4. notify()唤醒的线程，将在notify()线程释放了对象监视器以后才执行，并不是notify了以后马上执行。
5. Object的这些方法与Thread的sleep、interrupt相差还是很远的，不要混为一谈了。