wait()方法为什么要放在while循环里面(虚假唤醒过早唤醒)

本文主要是介绍wait()方法为什么要放在while循环里面(虚假唤醒过早唤醒)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

java在使用内置锁实现消费者-生产者模式的时候,可以使用wait,notify,notifyAll三个方法,而且这三个方法都是基类Object的方法,要调用某一个对象的同步方法时,必须将其放在sycronized修饰的方法、对象、代码块里面,你必须先持有对象上的锁,才能在某个条件下,修改其等待状态,下面给出了使用同步方法的标准代码模式:

synchronized (obj) {while (&lt;condition does not hold&gt;竞态条件)obj.wait();... // Perform action appropriate to condition}

其中,Object.wait会自动释放锁,并请求操作系统挂起当前线程,从而使得其他线程能够获取这个锁并修改对象的状态.当被挂起的线程醒来时,它将在醒来之前重新获取锁.从直观上来理解,调用wait意味着"我要去休息了,但当发生特定的事情时唤醒我",而调用通知方法就意味着"特定的事情发生了".

如果不将代码放在同步方法里面的话,会抛出IllegalMonitorStateException异常:

package com.springcloud.server.springserver.thread;public class Demo {public static void main(String[] args) {Demo demo =  new Demo();try {demo.wait();} catch (InterruptedException e) {e.printStackTrace();}}
}

执行代码:

lost wake up问题

假如有两个线程，一个消费者线程，一个生产者线程。生产者线程的任务可以简化成将count加一，而后唤醒消费者；消费者则是将count减一，而后在减到0的时候陷入睡眠：

生产者伪代码：

count+1;

notify();

消费者伪代码：

while(count<=0)

//线程在此发生上下文切换

wait()

count--

这两个线程会交替执行,如果不加同步的话会出现什么问题呢?

假如消费者在判断count<=0之后,发生了上下文切换,生产者代码进行执行,数量加一,并且通知消费者,但是此时消费者还没有进入wait()方法,当消费者进入wait()之后,就会出现丢失通知的问题,明明我可以消费,且要阻塞在这里的问题.

正确的解决方法是,让生产者和消费者竞争同一把锁,让线程在同一时间节点,只有一个线程在运行,那么即使线程发生上下文切换,由于锁的原因,同一时间只有生产者或者消费者在执行,就可以解决这个丢失通知信息的问题了.

虚假(过早)唤醒

另外的一个疑问是为什么wait的竞态条件要使用死循环进行判断,普通的if判断难道不行么?观察下面代码:

package com.springcloud.server.springserver.thread;import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;/*** Created by rhwayfun on 16-4-14.*/
public class EarlySignalDemo {//元素列表private List<String> list;//日期格式器private static final DateFormat format = new SimpleDateFormat("HH:mm:ss");//计数器private AtomicLong number = new AtomicLong();public EarlySignalDemo() {list = new ArrayList<>();}//对list执行删除的元素public void remove() throws InterruptedException {synchronized (list){if (list.isEmpty()){//只要list为空，那么调用此方法的线程必须等待list.wait();}//如果执行到这里，说明list已经不为空了//这样执行元素的删除操作才不会出错String item = list.remove(0);System.out.println(Thread.currentThread().getName() + ": remove element " + item + "! "+ format.format(new Date()));}}//对list执行添加操作public void add(){synchronized (list){long currentTime = System.currentTimeMillis();//添加元素不要进行判断list.add(""+ number.incrementAndGet());System.out.println(Thread.currentThread().getName() + ": add item " + number.get()+ " " +format.format(new Date()));list.notifyAll();while (System.currentTimeMillis() - currentTime <= 1000){//assume do something}}}static class AddThread implements Runnable{private EarlySignalDemo es;public AddThread(EarlySignalDemo es) {this.es = es;}@Overridepublic void run() {try {TimeUnit.MILLISECONDS.sleep(600);es.add();} catch (InterruptedException e) {e.printStackTrace();}}}static class RemoveThread implements Runnable{private EarlySignalDemo es;public RemoveThread(EarlySignalDemo es) {this.es = es;}@Overridepublic void run() {try {TimeUnit.MILLISECONDS.sleep(100);es.remove();} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args){EarlySignalDemo es = new EarlySignalDemo();for (int i = 0; i < 3; i++){new Thread(new RemoveThread(es),"RemoveThread" + i).start();}new Thread(new AddThread(es),"AddThread").start();}
}

执行结果:

这个代码启动了四个线程,三个RemoveThread,一个AddThread,并且使用休眠的方式,让添加线程休眠600毫秒,删除线程休眠100毫秒,三个删除线程调用的remove方法,由于使用了synchronized修饰,所有每一次只有一个线程进行if判断,第一个线程肯定判断为true,走到wait方法,此时wait方法会释放锁,并且在此阻塞,那么第二个和第三个线程也会相继执行到同一程度.

600毫秒后,添加线程添加一个记录到list集合,并且通知所有的使用list锁住的线程,加入第一个线程先恢复,抢到了锁,它会正确删除集合,之后释放锁,第二个线程抢到之后由于直接remove集合元素,此时集合为空,必定报错.这就出现了过早唤醒的问题了.

解决办法就是讲竞态条件放在while循环里面,唤醒之后继续判断,此时便不会出现异常了.

总结:

wait,notify,notifyAll方法需要放在同步块里面使用,并且判断的竞态需要使用while循环进行判断,不能使用if.