等待/通知机制

2019独角兽企业重金招聘Python工程师标准>>>

        等待/通知机制，是指一个线程A调用了对象O的wait()方法进入等待状态，而另一线程B调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而执行后续操作。

        notify()：通知一个在对象上等待的线程，使其从wait()方法返回，而返回的前提是该线程取到了对象的锁。

        wait()：调用该方法的线程进入waiting状态，只有等待另一个线程的通知或者被中断才会返回，需要注意，调用wait（）方法后，会释放对象的锁。

        

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) {
                // 当条件不满足时，继续wait，同时释放了lock的锁
                while (flag) {
                    try {
                        System.out.println(Thread.currentThread() + " flag is true. wait @ "
                                           + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                        lock.wait();
                    } 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);
            }
            // 再次加锁
            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 @ 21:21:51
Thread[NotifyThread,5,main] hold lock. notify @ 21:21:52
Thread[NotifyThread,5,main] hold lock again. sleep @ 21:21:57
Thread[WaitThread,5,main] flag is false. running @ 21:22:02

上面第3/4行的顺序可能会互换。

注意：

1. 使用wait(),notify(),notifyAll()时需要先给调用对象加锁，是和synchronized关键字合作使用的。

2. 调用wait()方法后，线程状态有running变成waiting，并将当前线程放置到对象的等待队列。

3. notify()或notifyAll()方法调用后，等待线程依旧不会从wait()返回，需要调用notify()后notifyAll()的线程释放锁之后，等待线程才有机会从wait（）返回。（如上例）

4. notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()方法则将等待队列中的所有线程全部移到同步队列，被移动的线程状态由waiting变成blocked。

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

转载于:https://my.oschina.net/dylan2hdf/blog/836871