等待/通知机制

场景

吃饭 :

一家人要吃午饭，妈妈做饭，我和爸爸吃饭。让我和爸爸的坐在桌子旁准备吃饭。但是我和爸爸又想多看一会电视，这个时候我们该怎么办呢？我们只能不断的跑到厨房看妈妈是不是做好饭了。

化简为代码

while(food != done){
    Thread.sleep(1000);
}
haveFood();

通过以上的方式我们可以多看一会电视，并且避免了无效的等待，但是还是有点问题：

• 难以确保实时性。可能在我们看电视的间隔时间，妈妈就已经做好饭了。看的时间过长可能妈妈还会生气
• 难以降级开销。如果我们看电视的间隔时间变短，但是我就会忙碌在往返电视和厨房的路上有点得不偿失。

以上两个问题，看似矛盾，但是却能通过另外一种方式(等待/通知)机制很好的解决。

解决的方式是

让妈妈叫我们吃饭！

转换为Java

而转换为到Java上面要怎么去实现呢？

java.lang.Object 为我们提供了以下的几个方法来实现

image.png

方法简介

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

一个简单的例子

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

/**
 * 有两个线程，一个等待线程，一个通知线程
 *
 * @author gongyan
 * @date 2018/4/9
 */
public class WaitNotifyDemo {

    /**
     * 状态标识
     */
    private static boolean flag = true;

    /**
     * 锁
     */
    private static Object lock = new Object();

    /**
     * 等待的线程
     */
    static class WaitRunnable implements Runnable {

        @Override
        public void run() {
            synchronized (lock) {
                while (flag) {
                    try {
                        System.out.println(Thread.currentThread() + " flag is true.@ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread() + " flag is false.@ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            }

        }
    }

    /**
     * 通知的线程
     */
    static class NotifyRunnable implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                System.out.println(Thread.currentThread() + " hold lock. notify @ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                lock.notifyAll();
                flag = false;
                SleepUtils.sleep(1);
            }
            synchronized (lock) {
                System.out.println(Thread.currentThread() + " hold lock again. notify @ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                SleepUtils.sleep(1);
            }
        }
    }


    /**
     * 线程睡眠工具类
     */
    static class SleepUtils {

        public static void sleep(int seconds) {
            try {
                TimeUnit.SECONDS.sleep(seconds);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public static void main(String[] args) {
        /** 开启一个线程执行的等待操作 */
        Thread waitThread = new Thread(new WaitRunnable(), "waitThread");
        waitThread.start();

        /** 主线程睡眠，保证等待线程获取到锁 */
        SleepUtils.sleep(1);

        /** 开启通知线程，通知等待线程恢复 */
        Thread notifyThread = new Thread(new NotifyRunnable(), "notifyThread");
        notifyThread.start();
    }

}

运行结果

Thread[waitThread,5,main] flag is true.@ 14:13:55
Thread[notifyThread,5,main] hold lock. notify @ 14:13:56
Thread[notifyThread,5,main] hold lock again. notify @ 14:13:57
Thread[waitThread,5,main] flag is false.@ 14:13:58

通过以上的代码可以完成通知的操作，这样就不需要一直for循环的等待了。

一点小解释

为什么调用wait的操作要在同步代码块中执行呢？

wait的api中写到：

使当前线程等待另一个线程调用此对象的方法或notify() notifyall()方法。换句话说，这个方法的行为就好像它仅执行呼叫等待（0）。

当前线程必须拥有此对象监视器。的线程释放该监视器的所有权并等待，直到另一个线程通知等待此对象监视器醒来通过调用notify方法或notifyAll方法的线程。然后这个线程等待直到它可以重新获得所有权的监测和恢复执行。

需要注意的几个关键点

• 使用wait(),notify(),notifyAll()的时候需要先对调用的对象加锁。
• 调用wait()方法后，线程的状态由Running变成waiting，并且会将当前线程放置到对象的等待队列中。
• notify() 或 notifyAll()方法调用后，等待线程不会直接从wait中返回，而是需要调用notify()或notifyAll()的线程释放锁后，等待线程才有机会从wait返回
• notify()方法将等待队列的一个等待线程从等待队列中移动到同步队列中，而notifyAll()方法则是将等待队列中所有的线程全部移动到同步队列，被移动的线程状态由waitting状态编程blocked状态。
• 从wait()方法返回的前提是获得了调用对象的锁。

等待/通知的经典范式

经典范式分为两部分，分为等待方（消费者）和通知方（生产者）
等待方遵循以下原则：

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

伪代码：

    synchronized(object){
        while(条件不满足){
            object.wait();
        }
        dosomething;
    }

通知方遵循如下原则：

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

伪代码：

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