序言
Object是超类，是所有类的父类，默认继承了Oject类（如果没有显式的继承Object,jdk6之前是编译器处理，jdk7之后是虚拟机处理默认继承）。Object类中有notify、wait等基本方法，所以继承了Object的类也拥有了Object的所有方法。
在多线程编程中，wait 方法是让当前线程进入休眠状态，直到另一个线程调用了 notify(notifyAll) 方法之后，才能继续恢复执行。而在 Java 中，wait 和 notify(notifyAll) 有着一套自己的使用格式要求，也就是在使用 wait 和 notify（notifyAll 的使用和 notify 类似，所以下文就只用 notify 用来指代二者）必须配合 synchronized 一起使用才行。
wait/notify基础使用
public static void main(String[] args) {
Object lock = new Object();
new Thread(()->{
synchronized (lock){
try {
System.out.println("wait 之前");
lock.wait();
System.out.println("wait 之后");
}catch (Exception ex){
ex.printStackTrace();
}
}
}).start();
try {
Thread.sleep(1000);
}catch (Exception ex){
ex.printStackTrace();
}
synchronized (lock){
System.out.println("执行 notify");
lock.notify();
}
}以上代码的执行结果
wait 之前
执行 notify
wait 之后wait/notify和synchronized一起用？
那问题来了，是不是 wait 和 notify 一定要配合 synchronized 一起使用呢？wait 和 notify 单独使用行不行呢？ 我们尝试将以上代码中的 synchronized 代码行删除，实现代码如下：
public static void main(String[] args) {
Object lock = new Object();
new Thread(()->{
try {
System.out.println("wait 之前");
lock.wait();
System.out.println("wait 之后");
}catch (Exception ex){
ex.printStackTrace();
}
}).start();
try {
Thread.sleep(1000);
}catch (Exception ex){
ex.printStackTrace();
}
System.out.println("执行 notify");
lock.notify();
}初看代码好像没啥问题，编译器也没报错，好像能“正常使用”，然而当我们运行以上程序时就会发生如下错误：
从上述结果可以看出：无论是 wait 还是 notify，如果不配合 synchronized 一起使用，在程序运行时就会报 IllegalMonitorStateException 非法的监视器状态异常，而且 notify 也不能实现程序的唤醒功能了。
原因分析
从上述的报错信息我们可以看出，JVM 在运行时会强制检查 wait 和 notify 有没有在 synchronized 代码中，如果没有的话就会报非法监视器状态异常（IllegalMonitorStateException），但这也仅仅是运行时的程序表象，那为什么 Java 要这样设计呢？
其实这样设计的原因就是为了防止多线程并发运行时，程序的执行混乱问题。初看这句话，好像是用来描述“锁”的。然而实际情况也是如此，wait 和 notify 引入锁就是来规避并发执行时程序的执行混乱问题的。那这个“执行混乱问题”到底是啥呢？接下来我们继续往下看。
wait和notify问题复现
我们假设 wait 和 notify 可以不加锁，我们用它们来实现一个自定义阻塞队列。 这里的阻塞队列是指读操作阻塞，也就是当读取数据时，如果有数据就返回数据，如果没有数据则阻塞等待数据，实现代码如下：
public class TestBlockQueque {
Queue<String> queue = new LinkedList();
public void add(String data){
queue.add(data);
notify();//步骤3
}
public String take() throws Exception{
while (queue.isEmpty()){//步骤1
wait();//步骤2
}
return queue.remove();
}
}注意上述代码，我们在代码中标识了三个关键执行步骤：①：判断队列中是否有数据；②：执行 wait 休眠操作；③：给队列中添加数据并唤醒阻塞线程。 如果不强制要求添加 synchronized，那么就会出现如下问题：
步骤 | 线程1 | 线程2 |
1 | 执行步骤1 判断当前队列中没有数据 | |
2 | 执行步骤3 将数据添加到队列，并唤醒线程1继续执行 | |
3 | 执行步骤2 线程1进去休眠状态 |
从上述执行流程看出问题了吗？
如果 wait 和 notify 不强制要求加锁，那么在线程 1 执行完判断之后，尚未执行休眠之前，此时另一个线程添加数据到队列中。然而这时线程 1 已经执行过判断了，所以就会直接进入休眠状态，从而导致队列中的那条数据永久性不能被读取，这就是程序并发运行时“执行结果混乱”的问题。
然而如果配合 synchronized 一起使用的话，代码就会变成以下这样：
public class TestBlockQueque {
Queue<String> queue = new LinkedList();
public void add(String data){
synchronized (TestBlockQueque .class){
queue.add(data);
notify();//步骤3
}
}
public String take() throws Exception{
synchronized (TestBlockQueque .class){
while (queue.isEmpty()){//步骤1
wait();//步骤2
}
}
return queue.remove();
}
}步骤 | 线程1 | 线程2 |
1 | 执行步骤1 判断当前队列中没有数据 | |
2 | 执行步骤2线程进入休眠状态 | |
3 | 执行步骤3 将数据添加到队列，并执行唤醒操作 | |
4 | 线程被唤醒，继续执行 | |
5 | 判断队列中有数据，返回数据 | |
这样咱们的程序就可以正常执行了，这就是为什么 Java 设计一定要让 wait 和 notify 配合上 synchronized 一起使用的原因了。 |
wait与notify经典用法
线程间通信基本的三个方法
- wait():一旦执行该方法，当前线程就会堵塞状态，并释放同步监视器（锁）
- notify():一旦执行该方法，就会唤醒被wait的一个线程，如果是多个，则唤醒优先级高的线程
- notifyAll():一旦执行该方法，就会唤醒所有被wait的线程
public class NumberRunnable implements Runnable{
private int i = 0;
@Override
public void run() {
while (true){
synchronized (this){
notify();
if(i<100){
i++;
System.out.println(Thread.currentThread().getName()+"----"+i);
}else {
break;
}
try {
wait();
}catch (InterruptedException ex){
ex.printStackTrace();
}
}
}
}
}测试main函数
NumberRunnable numberRunnable = new NumberRunnable();
Thread t1 = new Thread(numberRunnable,"线程一");
Thread t2 = new Thread(numberRunnable,"线程二");
t1.start();
t2.start();输出结果：
线程一----1
线程二----2
线程一----3
线程二----4
线程一----5
线程二----6
·····
线程一----99
线程二----100总结
本文介绍了 wait 和 notify 的基础使用，以及为什么 wait 和 notify/notifyAll 一定要配合 synchronized 使用的原因。如果 wait 和 notify/notifyAll 不强制和 synchronized 一起使用，那么在多线程执行时，就会出现 wait 执行了一半，然后又执行了添加数据和 notify 的操作，从而导致线程一直休眠的缺陷。
