等待/通知机制
场景
吃饭 :
一家人要吃午饭，妈妈做饭，我和爸爸吃饭。让我和爸爸的坐在桌子旁准备吃饭。但是我和爸爸又想多看一会电视，这个时候我们该怎么办呢？我们只能不断的跑到厨房看妈妈是不是做好饭了。
化简为代码
while(food != done){
Thread.sleep(1000);
}
haveFood();
通过以上的方式我们可以多看一会电视，并且避免了无效的等待，但是还是有点问题：
- 难以确保实时性。可能在我们看电视的间隔时间，妈妈就已经做好饭了。看的时间过长可能妈妈还会生气
- 难以降级开销。如果我们看电视的间隔时间变短，但是我就会忙碌在往返电视和厨房的路上有点得不偿失。
以上两个问题，看似矛盾，但是却能通过另外一种方式(等待/通知)机制很好的解决。
解决的方式是
让妈妈叫我们吃饭！
转换为Java
而转换为到Java上面要怎么去实现呢？
java.lang.Object 为我们提供了以下的几个方法来实现
方法简介
| 方法 | 解释 |
|---|---|
| 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();
}
