等待/通知机制

前言

一个线程如果修改了一个对象的值，而另一个线程感知到了变化的话，就会进行相应的操作，整个过程开始于一个线程，而最终执行又是另外一个线程，前者是生产者，后者则是消费者，这种模式隔离了"做什么"vs"怎么做"，在功能层面上实现了解耦，体系结构上具备了良好的伸缩性，但是在java中如何实现类似的功能？
例一
简单的办法就是让消费者线程不断的去循环检查变量是否符合预期，如下面伪代码所示，在while循环中设置不满足的条件，如果条件满足则退出while循环，从而完成消费者的工作

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

上述这段伪代码在条件不满足时就会执行睡眠1秒，这样做的目的是防止过快的"无效"尝试，这种方式看似能够解决实现所需的功能，但是却存在一下问题
问题1
难以保证及时性，在睡眠时，基本不消耗处理器资源，但是如果睡的过久，就不能及时发现条件已经变化，也就是及时性难以保证。
问题2
难以降低开销，如果降低睡眠的时间，比如休眠1毫秒，这样消费者能更加迅速的发现条件变化，但是却可能消耗更多的处理器资源，造成了无端的浪费。

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

等待/通知的相关方法是任意java对象都具备的，因为这些方法被定义在所有的对象的超类java.lang.Object上，方法如下所示

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

等待/通知机制，是指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而执行后续操作，上述两个线程通过对象O来完成交互，而对象上的wait()和notify/notifyAll()的关系就如同开关信号一样，用来等待方和通知方之间的交互工作。
例二
1.创建两个线程–WaitThread和NotifyThread，前者检查flag值是否为false，如果符合要求，进行后续操作，否则在lock上等待后者在睡眠了一段时间后对lock进行通知

package com.lsp.lock.two;

import com.lsp.lock.one.SleepUtils;

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

/**
 * @Author: liusupeng
 * @Date: 2021/6/20 11:36
 */
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 {

        @Override
        public void run() {
            //加锁，拥有lock的Monitor
            synchronized (lock) {
                System.out.println(Thread.currentThread() + "flag is true . wait @  " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                try {
                    System.out.println("我进来了，线程开始等待------");
                    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
            //直到当前线程释放了lock，WwaitThread才能从wait方法中返回
            synchronized (lock) {
                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);
            }

        }
    }


}

执行效果如下：

以上代码中，我们需要注意的细节如下

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

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

方法名称	描述
NEW（初始）	新创建了一个线程对象，但还没有调用start()方法。
RUNNABLE（运行）	Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。
BLOCKED（阻塞）	表示线程阻塞于锁。
WAITING（等待）	进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）
TIMED_WAITING（超时等待）	该状态不同于WAITING，它可以在指定的时间后自行返回。
TERMINATED(终止)	表示该线程已经执行完毕。