关键字wait、notify、notifyAll
大家都知道wait、notify、notifyAll这三个是Object提供的线程间协作的方法，常用在生产消费者模式，那么wait跟sleep有什么区别呢？wait、notify、notifyAll又该如何使用呢。
wait跟sleep区别
（1）共同点，wait、sleep都会让当前线程进入阻塞等待状态，并释放CPU时间片，在满足某个条件后被唤醒，例如timeout、中的；
（2）不同点，wait是Objec的方法，sleep是Thread的方法；
（3）异同点，wait会释放锁，而sleep不会释放；
wait、notify、notifyAll使用
场景：生产消费者模式
mProducerThread是生产者线程，负责生产商品，如果不能继续生产则wait；mConsumerThread是消费者线程，负责消费商品，如果不能继续消费则wait。
使用规则：
（1）wait、notify、notifyAll必须在同步代码中执行；
（2）wait必须在while循环内执行。
public class Goods {
//生产者线程
private Thread mProducerThread = new Thread() {
@Override
public void run() {
produce();
}
};
//消费者线程
private Thread mConsumerThread = new Thread() {
@Override
public void run() {
consume();
}
};
public void produce() {
while (true) {
synchronized (Goods.this) {
while (是否不能生产) {//不满足生产条件
try {
Goods.this.wait();//释放锁，让出CPU
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//生产商品
Goods.this.notifyAll();
}
}
}
public void consume() {
while (true) {
synchronized (Goods.this) {
while (是否不能消费) {//不满足消费条件
try {
Goods.this.wait();//释放锁，让出CPU
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//消费商品
Goods.this.notifyAll();
}
}
}
//开启任务
public void start() {
mProducerThread.start();
mConsumerThread.start();
}
}
以下是消费者的流程图，生产者也类似，
消费者.png
使用规则思考
wait、notify、notifyAll，为什么必须在同步代码中执行
（1）以上述代码为例，当不能继续生产或不能继续消费时，需要其他线程消费或者生成商品，则调用wait释放锁让出CPU，wait是释放锁，只有获得锁才能释放锁，没有获得锁哪来释放锁呢，另外，线程间协作通常会共享变量，对共享变量的操作放在同步代码块中，可以解决线程安全问题，所以wait必须在同步代码执行，否则会抛出java.lang.IllegalMonitorStateException: object not locked by thread before wait()异常；
（2）notify、notifyAll同理，生产完商品或消费完商品，需要唤醒其他线程并且释放锁，那么其他线程才有机会获得锁，所以在退出同步代码时调用notify、notifyAll，如果不在同步代码中执行，则抛出java.lang.IllegalMonitorStateException: object not locked by thread before notify()；
（3）总结一点，没有获取锁，那就谈不上wait、notify、notifyAll；
notify和notifyAll区别
（1）notify，唤醒等待同一个对象的某个线程去竞争锁，至于是哪个线程获取锁，由CPU调度；
（2）notifyAll，唤醒等待同一个对象的所有线程去竞争锁，至于是哪个线程获取锁，由CPU调度，听起来跟notify一样；
（3）上述代码，将Goods.this.notifyAll()换成Goods.this.notify效果一样。假如，mConsumerThread消费者先获得锁进入同步代码，但是发现不能继续消费商品，则wait释放锁让出CPU处于等待状态，那么mProducerThread生产者线程竞争获得锁进入同步代码而且可以继续生产商品，则开始生产商品，生产完以后在退出同步代码之前调用notifyAll，那么mConsumerThread 就会被唤醒去竞争锁。试想着，在等待的只有mConsumerThread，所以无论是用notifyAll唤醒多个，还是notify唤醒某一个，效果都一样。如果是只有一个mConsumerThread和一个mProducerThread的情况，用notifyAll或notify都一样，因为在等待的只有一个。
如果是多个ConsumerThread或者多个
ProducerThread的情况，用notifyAll显然更适合。假如，mProducerThread生产完商品，希望唤醒消费者来消费，那么所有消费者都应该得到唤醒，如果使用notify，极端情况，只有其中某个消费者一直被唤醒消费，属于过得饱和，而其他消费者 过度饥饿，显示不是使用多线程的初衷；还有一种极端情况，还是只有其中某个消费者一直被唤醒，但是因为某个条件不满足，无法消费商品，而生产的商品已经满了，一直处于wait，而消费者一直不消费商品，任务无法继续执行下去，假死现象。
（4）永远是单个线程处于等待，用notify或notifyAll效果都一样，如果是多线程处于等待，显然用notifyAll更合适。
wait为什么必须在while循环内执行
上述代码的consume方法，将while改成if，当mProducerThread生产者生产完商品唤醒消费者，mConsumerThread获得锁不再判断消费条件是否成立，直接去消费商品，这样没有如何问题，因为很明确知道mConsumerThread被唤醒且获得锁，肯定是有商品可以消费，所以无需再判断条件是否成立。
但如果是以下场景则不同，
mConsumerThread1 与mProducerThread1，以及mConsumerThread2 与mProducerThread2是成对关系。
mConsumerThread1 只能消费mProducerThread1生产的商品，mConsumerThread2 只能消费mProducerThread2生产的商品。
当mConsumerThread1 、mConsumerThread2都不满足消费条件处于等待状态，这时mProducerThread1 生产了商品，调用notifyAll唤醒线程来消费，因为调用的是 notifyAll，所以mConsumerThread1、mConsumerThread2都会被唤醒，如果正好是mConsumerThread2获得了锁，需要重新判断条件是否满足，因为mConsumerThread2是跟mProducerThread2对应的，这时候while循环就起用了。
如果是有多组执行条件，唤醒存在假唤醒的情况（中断唤醒），那么用while循环显然更合适，这也是Java推荐的。
public class Goods {
//生成者线程1
private Thread mProducerThread1 = new Thread() {
@Override
public void run() {
produce1();
}
};
//消费者线程2
private Thread mConsumerThread1 = new Thread() {
@Override
public void run() {
consume1();
}
};
//生成者线程2
private Thread mProducerThread2 = new Thread() {
@Override
public void run() {
produce2();
}
};
//消费者线程2
private Thread mConsumerThread2 = new Thread() {
@Override
public void run() {
consume2();
}
};
public void produce1() {
while (true) {
synchronized (Goods.this) {
while (是否不能生产) {//不满足生成条件1
try {
Goods.this.wait();//释放锁，让出CPU
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//生成商品
Goods.this.notifyAll();
}
}
}
public void consume1() {
while (true) {
synchronized (Goods.this) {
while (是否不能消费) {//不满足消费条件1
try {
Goods.this.wait();//释放锁，让出CPU
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//消费商品
Goods.this.notifyAll();
}
}
}
public void produce2() {
while (true) {
synchronized (Goods.this) {
while (是否不能生产) {//不满足生产条件2
try {
Goods.this.wait();//释放锁，让出CPU
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//生成商品
Goods.this.notifyAll();
}
}
}
public void consume2() {
while (true) {
synchronized (Goods.this) {
while (是否不能消费商品) {//不满足消费条件2
try {
Goods.this.wait();//释放锁，让出CPU
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//消费商品
Goods.this.notifyAll();
}
}
}
//开启任务
public void start() {
mProducerThread1.start();
mConsumerThread1.start();
mProducerThread2.start();
mConsumerThread2.start();
}
}
总结：
（1）wait、notify、notifyAll必须在同步代码中执行；
（2）wait必须在while循环内执行；
（3）notify比notifyAll更容易出现死锁。
以上分析有不对的地方，请指出，互相学习，谢谢哦！
网友评论