java并发编程：等待/通知机制

对等待/通知机制做个总结：

一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行又是另一个线程。前者是生产者，后者就是消费者，这种模式隔离了“做什么（what）”和“怎么做（how）",在功能层面上实现了解耦，体系结构上具备了良好的伸缩性，但是在java语言中如何实现类似的功能那？

简单的方法是让消费者线程不断地循环检查变量是否符合预期，如下面代码所示，在while循环中设置不满足的条件，如果条件满足则退出while循环，从而完成消费者的工作。

while(value != desire){
   Thread.sleep(1000);
}
doSomething();

上面这段伪代码在条件不满足时就睡眠一段时间，这样做的目的是防止过快的“无效”尝试，这种方式看似能够实现所需功能，但是却存在如下问题。

难以确保及时性。在睡眠时，基本不消耗处理器资源，但是如果睡得过久，就不能及时发现条件已经变化，也就是及时性难以保证。
难以降低开销。如果降低睡眠的时间，比如休眠1毫秒，这样消费者能更加迅速地发现条件变化，但是却可能消耗更多的处理器资源，造成了无端的浪费。

上面这两个问题，看似矛盾难以调和，但是Java通过内置的等待/通知机制能够很好地解决这个矛盾并实现所需的功能。

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

示例如下：

public class WaitNotify {

    static boolean flag = true;
    static Object lock = new Object();

    static class Wait implements Runnable {

        @Override
        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();
                        System.out.println("哎呀我天，终于等到你。。。");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            //条件满足时，完成工作
            System.out.println(Thread.currentThread() + "flag is false. running @ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        }
    }

    static class Notify implements Runnable{

        @Override
        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();
                System.out.println("我真的不会释放锁，除非我结束了我的线程,haha");
                flag = false;
            }
            //再次加锁
            synchronized (lock){
                System.out.println(Thread.currentThread() + "hold lock agin , haha :" + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            }
        }
    }

    public static void main(String[] args) {
        Thread wait = new Thread(new Wait(), "WaitThread");
        Thread notify = new Thread(new Notify() , "NotifyThread");
        wait.start();
        notify.start();
    }

}

Thread[WaitThread,5,main]flag is true. wait @ 16:21:40
Thread[NotifyThread,5,main]hold lock. notify @ 16:21:40
我真的不会释放锁，除非我结束了我的线程,haha
Thread[NotifyThread,5,main]hold lock agin , haha :16:21:40
哎呀我天，终于等到你。。。
Thread[WaitThread,5,main]flag is false. running @ 16:21:40

需要注意的细节：

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

由以上示例，我们可以提炼出等待/通知的经典范式，该范式分为两部分，分别针对等待方（消费者）和通知方（生产者）。

等待方遵循如下的原则：

获取对象的锁
如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件
条件满足则执行对应的逻辑

对应的伪代码如下：

synchronized (对象){
            while(条件不满足){
                对象.wait();
            }
            对象的处理逻辑；
        }

通知方遵循如下的原则：

获得对象的锁
改变条件
通知所有等待在对象上的线程

对应的伪代码如下：

synchronized (对象){
      改变条件 
      对象.notifyAll();
 }

java并发编程：等待/通知机制

猜你喜欢