等待/通知机制wait(),notify()

《JAVA并发编程的艺术》

等待 /通知机制 ：

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

public class WaitNotify {
    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();
    }

    static class Wait implements Runnable {
        public void run() {
            // 加锁，拥有lock的Monitor
            synchronized (lock) {

                while (flag) {
                    try {
                        System.out.println(Thread.currentThread() + " flag is true. wait @ "
                                           + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                        lock.wait();//等待，释放lock锁
                    } catch (InterruptedException e) {
                    }
                }
                // 完成工作
                System.out.println(Thread.currentThread() + " flag is false. running @ "
                                   + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            }
        }
    }

    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 @ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                lock.notifyAll();
                flag = false;
                SleepUtils.second(5);
            }
            //以上lock解锁后，等待的线程就可以执行了

             SleepUtils.second(5);
            // 再次加锁
            synchronized (lock) {
                System.out.println(Thread.currentThread() + " hold lock again. sleep @ "
                                   + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                SleepUtils.second(5);
            }
        }
    }
}

运行：

Thread[WaitThread,5,main] flag is true. wait @ 22:40:33
Thread[NotifyThread,5,main] hold lock. notify @ 22:40:34
Thread[WaitThread,5,main] flag is false. running @ 22:40:39
Thread[NotifyThread,5,main] hold lock again. sleep @ 22:40:44

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