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

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

synchronized (obj) {
   while (<condition does not hold>竞态条件)
          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;
        }

        @Override
        public 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;
        }

        @Override
        public 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.