java中wait的场景,Java-wait、notify、notifyAll

关键字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更容易出现死锁。

以上分析有不对的地方，请指出，互相学习，谢谢哦！