wait notify notifyAll

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

示例代码如下

public class WaitNotify {
    static boolean flag = true;
    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread waitThread = new Thread(new Wait(),"WaitThread");
        waitThread.start();
        TimeUnit.SECONDS.sleep(1);
        Thread notifyThread = new Thread(new Notify(),"NotifyThread");
        notifyThread.start();
    }

    static class Wait implements Runnable{

        @Override
        public void run() {
            synchronized (lock){
                while (flag){
                    System.out.println(Thread.currentThread()+" flag is true,wait @"+ DateFormatUtils.format(new Date(),DateFormatUtils.ISO_DATETIME_FORMAT.getPattern()));
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread()+" flag is false,running @"+ DateFormatUtils.format(new Date(),DateFormatUtils.ISO_DATETIME_FORMAT.getPattern()));
            }
        }
    }

    static class Notify implements Runnable{

        @Override
        public void run() {
            synchronized (lock){
                System.out.println(Thread.currentThread()+" hold lock:notify @"+ DateFormatUtils.format(new Date(),DateFormatUtils.ISO_DATETIME_FORMAT.getPattern()));
                lock.notifyAll();
                flag = false;
                SleepUtils.second(5);

            }
            synchronized (lock){
                System.out.println(Thread.currentThread()+" hold lock again:sleep @"+ DateFormatUtils.format(new Date(),DateFormatUtils.ISO_DATETIME_FORMAT.getPattern()));
                SleepUtils.second(5);
            }
        }
    }
}

输出如下：

Thread[WaitThread,5,main] flag is true,wait @2016-06-28T22:03:52
Thread[NotifyThread,5,main] hold lock:notify @2016-06-28T22:03:53
Thread[WaitThread,5,main] flag is false,running @2016-06-28T22:03:58
Thread[NotifyThread,5,main] hold lock again:sleep @2016-06-28T22:03:58

根据上述代码示例主要说明了调用wait、notify、notifyAll时需要注意的细节

1、使用wait、notify、notifyAll时需要先对调用对象加锁

2、调用wait方法后，现在状态有RUNNING变为WAITING，并将当前线程放置到对象的等待队列

3、notify或者notifyAll方法调用后，等待线程依旧不会从wait方法返回，需要调用notify或notifyAll的线程释放锁之后，等待线程才有机会从wait方法返回

4、notify方法将等待队列中的一个等待线程从等待队列中移动到同步队列中，而notifyAll方法则是将等待队列中的所有线程全部移动到同步队列，被移动的线程状态由WAITING变为BLOCKED。

5、从wait方法返回的前提是获得了调用对象的锁。

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

如上述示例代码所示

WaitThread首先获取了对象的锁，然后调用对象的wait方法，从而放弃了锁并进入了对象的等待队列WaitQueue中，进入等待状态。由于WaitThread释放了对象的锁，NotifyThread随后获取了对象的锁，并调用对象的notifyAll方法，将WaitQueue中的所有等待线程包括WaitThread线程移到SynchronizedQueqe中，此时WaitThread的状态变为阻塞状态。NotifyThread释放了锁之后，WaitThread再次获取到锁并从wait方法返回继续执行。