Java wait notify 笔记

在Java API（本文以下提到到所有API都是基于JDK 1.6 API）中，Object类提供了wait() & notify() 方法来帮我们解决多线程并发的部分需求，在API中，他是这样描述的：

notify

public final void notify()

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

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

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

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

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

抛出：

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

 

wait

public final void wait(long timeout) throws InterruptedException

在其他线程调用此对象的  notify() 方法或  notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。

当前线程必须拥有此对象监视器。

此方法导致当前线程（称之为 T）将其自身放置在对象的等待集中，然后放弃此对象上的所有同步要求。出于线程调度目的，在发生以下四种情况之一前，线程 T 被禁用，且处于休眠状态：

• 其他某个线程调用此对象的 notify 方法，并且线程 T 碰巧被任选为被唤醒的线程。
• 其他某个线程调用此对象的 notifyAll 方法。
• 其他某个线程中断线程 T。
• 大约已经到达指定的实际时间。但是，如果 timeout 为零，则不考虑实际时间，在获得通知前该线程将一直等待。

然后，从对象的等待集中删除线程  T，并重新进行线程调度。然后，该线程以常规方式与其他线程竞争，以获得在该对象上同步的权利；一旦获得对该对象的控制权，该对象上的所有其同步声明都将被恢复到以前的状态，这就是调用  wait 方法时的情况。然后，线程  T 从  wait 方法的调用中返回。所以，从  wait 方法返回时，该对象和线程  T 的同步状态与调用  wait 方法时的情况完全相同。

在没有被通知、中断或超时的情况下，线程还可以唤醒一个所谓的虚假唤醒 (spurious wakeup)。虽然这种情况在实践中很少发生，但是应用程序必须通过以下方式防止其发生，即对应该导致该线程被提醒的条件进行测试，如果不满足该条件，则继续等待。换句话说，等待应总是发生在循环中，如下面的示例：

synchronized (obj) { while () obj.wait(timeout); ... // Perform action appropriate to condition }

（有关这一主题的更多信息，请参阅 Doug Lea 撰写的 Concurrent Programming in Java (Second Edition) (Addison-Wesley, 2000) 中的第 3.2.3 节或 Joshua Bloch 撰写的 Effective Java Programming Language Guide (Addison-Wesley, 2001) 中的第 50 项。

如果当前线程在等待之前或在等待时被任何线程中断，则会抛出 InterruptedException。在按上述形式恢复此对象的锁定状态时才会抛出此异常。

注意，由于 wait 方法将当前线程放入了对象的等待集中，所以它只能解除此对象的锁定；可以同步当前线程的任何其他对象在线程等待时仍处于锁定状态。

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

参数：

timeout - 要等待的最长时间（以毫秒为单位）。

抛出：

IllegalArgumentException - 如果超时值为负。

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

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

从API描述可以看出，wait和notify主要是解决线程之间通讯，阻塞和唤醒的问题。

 

• 问题：

Q1：

wait和notify的基本语法？

Q2：

当调用wait方法到时候，到底谁被阻塞？

Q3：

使用wait和notify的注意事项有哪些？

 

• 解决

A1：

wait的基本语法在API中详细到描述如下：

synchronized (obj) { 

     while () 

            obj.wait(timeout); 

            ... // Perform action appropriate to condition 

}；

对obj对象上锁，while循环某个条件，如果条件为假，则让obj对象做出wait动作，并设置一定的超时时间，等到时间过了，则自动放弃阻塞，继续执行，else，一直等待其他线程的操作，直到invocation obj对象的notify方法，当前线程继续执行。

A2：

当调用了某个对象的wait方法后，当前调用的这个线程将被阻塞！

A3：

一般wait和notify的调用，推荐定义一个专门的Object来完成协调工作。

• Simple Demo

public class WaitAndNotifyClass {
	public static Object lock = new Object();

	@SuppressWarnings("static-access")
	public static void main(String[] args) {
		System.out.println("WaitAndNotifyClass - main() - starting...");
		// create a thread to run AA class.
		new Thread(new AA(), "AA-thread").start();
		System.out
				.println("WaitAndNotifyClass - main() - main thread to do sleep 3s");
		try {
			// 主线程休眠3s 更好到看到结果
			Thread.currentThread().sleep(3000L);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out
				.println("WaitAndNotifyClass - main() - do notify lock object");
		// 唤醒AA-thread线程
		synchronized (lock) {
			lock.notify();
		}
	}
}

class AA implements Runnable {

	@Override
	public void run() {
		synchronized (WaitAndNotifyClass.lock) {
			try {
				System.out.println("AA - run() - I am invoke");
				// wait
				WaitAndNotifyClass.lock.wait();
				System.out.println("AA - run() - I am notified");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

 

 

 

 

运行结果如下：

WaitAndNotifyClass - main() - starting...

WaitAndNotifyClass - main() - main thread to do sleep 3s

AA - run() - I am invoke

WaitAndNotifyClass - main() - do notify lock object

AA - run() - I am notified

 

WaitAndNotifyClass开启一个线程AA，AA被执行后立即wait，WaitAndNotifyClass休眠3s后唤醒，AA被唤醒后立即执行