等待/通知机制

一.wait(),wait(long),wait(long,int),notify(),notifyAll()方法说明

注：等待/通知的相关方法是任意 Java 对象都具备的，因为这些方法被定义在所有对象的超类 java.lang.Object 上

notify():通知一个在对象上等待的线程，使其从wait()方法返回，而返回的前提是该线程获取到了对象的锁
notifyAll():通知所有等待在该对象上的线程
wait():调用该方法的线程进入WAITING状态，只有等待另外线程的通知或被中断才会返回，需要注意，调用wait()方法后，会释放对象的锁
wait(long):超时等待一段时间，这里的参数时间是毫秒，也就是等待长达n毫秒，如果没有通知就超时返回
wait(long,int):对于超时时间更细粒度的控制，可以达到纳秒

二：等待/通知机制 概念

等待/通知机制，是指一个线程 A 调用了对象 O 的 wait()方法进入等待状态，而另一个线程 B 调用了对象 O 的 notify()或者 notifyAll()方法，线程 A 收到通知后从对象 O 的wait()方法返回，进而执行后续操作。上述两个线程通过对象 O 来完成交互，而对象上的wait()和 notify/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。

三：示例

创建了两个线程——WaitThread 和 NotifyThread，前者检查 flag 值是否为 false，如果符合要求，进行后续操作，否则在 lock 上等待，后者在睡眠了一段时间后对 lock 进行通知，示例如下所示：

public class Concurrency {
 static boolean flag = true;
 static Object lock = new Object();
 public static void main(String[] args) throws Exception {
 Thread waitThread = new Thread(new Wait(), "WaitThread");
 waitThread.start();
 TimeUnit.SECONDS.sleep(1);
 Thread notifyThread = new Thread(new Notify(), "NotifyThread");
 notifyThread.start();
 }
 public static String getDate() {
 return new SimpleDateFormat(" HH: mm: ss ").format(new Date());
 }
 static class Wait implements Runnable {
 public void run() {
 // 加锁，拥有 lock 的 Monitor
 synchronized (lock) {
 // 当条件不满足时，继续 wait，同时释放了 lock 的锁
 while (flag) {
 try {
 System.out.println(Thread.currentThread() + " flag is true. wa @ " + getDate());
 lock.wait();
 } catch (InterruptedException e) {
 }
 }
 // 条件满足时，完成工作
 System.out.println(Thread.currentThread() + " flag is false. running @ " + getDate());
 }
 }
 }
 static class Notify implements Runnable {
 public void run() {
 // 加锁，拥有 lock 的 Monitor
 synchronized (lock) {
 // 获取 lock 的锁，然后进行通知，通知时不会释放 lock 的锁，
 // 直到当前线程释放了 lock 后，WaitThread 才能从 wait 方法中返回
 System.out.println(Thread.currentThread() + " hold lock. notify @ " + getDate());
 lock.notifyAll();
flag = false;
 SleepUtils.second(5);
 }
 // 再次加锁
 synchronized (lock) {
 System.out.println(Thread.currentThread() + " hold lock again. sleep @ " + getDate());
 SleepUtils.second(5);
 }
 }
 }
}

输出：

Thread[WaitThread,5,main] flag is true. wa @ 13: 44: 41 
Thread[NotifyThread,5,main] hold lock. notify @ 13: 44: 42 
Thread[NotifyThread,5,main] hold lock again. sleep @ 13: 44: 47 
Thread[WaitThread,5,main] flag is false. running @ 13: 44: 52

注：上面WaitThread 可以在循环条件加一个超时时间的判断，避免有可能等待时间过长,如下代码：

long future = System.currentTimeMillis() + mills;
long remaining = mills;
while (remaining > 0) {
     remaining = future - System.currentTimeMillis();
}else {
     return null;
}

上述第 3 行和第 4 行输出的顺序可能会互换，而上述例子主要说明了调用 wait()、notify()以及 notifyAll()时需要注意的细节，如下。

1. 使用 wait()、notify()和 notifyAll()时需要先对调用对象加锁。
2. 调用 wait()方法后，线程状态由 RUNNING 变为 WAITING，并将当前线程放置到对象的等待队列。
3. notify()或 notifyAll()方法调用后，等待线程依旧不会从 wait()返回，需要调用notify()或 notifAll()的线程释放锁之后，等待线程才有机会从 wait()返回。
4. notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll() 方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由 WAITING 变为 BLOCKED。
5. 从 wait()方法返回的前提是获得了调用对象的锁。

四：总结

从上述细节中可以看到，等待/通知机制依托于同步机制，其目的就是确保等待线程从 wait()方法返回时能够感知到通知线程对变量做出的修改