Object类wait,notify,notifyAll的使用

Object类waitnotifynotifyAll的使用

wait

notify

notifyAll

总结

Object类wait,notify,notifyAll的使用

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

wait()

JDk文档写道

在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。换句话说，此方法的行为就好像它仅执行 wait(0)

调用一样。

当前线程必须拥有此对象监视器 。该线程发布对此监视器的所有权并等待，直到其他线程通过调用

notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。

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

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

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

抛出：

IllegalMonitorStateException

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

InterruptedException

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

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

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。

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

看看一个例子：

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个方法得到：

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稍微有一点差别的是，它会唤醒所有的等待线程。

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();
}

执行一下代码：

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

全部唤醒了。

总结

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

wait(),notify(),notifyAll()都需要在拥有对象监视器的前提下执行，否则会出现异常

IllegalMonitorStateException。

多个线程可以同时在一个对象上等待。

notify()将随机唤醒一个在对象上等待的线程，没有一个都没有，则什么都不做。

notify()唤醒的线程，将在notify()线程释放了对象监视器以后才执行，并不是notify了以后马上执行。

Object的这些方法与Thread的sleep、interrupt相差还是很远的，不要混为一谈了。

关于对象的锁，这里补充一下：

锁有两种，一种是类锁，其实是类的Class实例锁，另一种是类的实例的锁

锁是通过对象监视器实现的，而对象监视器由JVM负责

同一个线程可以对一个对象多次加锁

线程同步中，会有等待区、入口区和监视器区域三部分，只有监视器区域的线程获取监视器，也就是对象锁