完全真正理解wait和notify使用的时候wait一定要放在while循环里面！

说实话，第一遍看这个概念并没有看懂，第二遍硬磕了一下，发现原来不理解的原因是**if()和while()方法给忽视了**

• if(){…}，如果说程序在判断完满足if条件之后，那么就会进入大括号里面，即使在里面等待一段时间之后，我们也是会直接出来
• while(){…}如果说满足了条件，那么就会进入大括号里面，在里面呆了一段时间，要想出来那得先去while判断一下，如果满足，还是不能出来。

即if进去要口令，出来不要口令
while进去和出来都要口令
那么我们来看具体的代码：如果线程1在执行do wait方法获得锁之后进入等待状态，即myMonitorObject.wait();那么如果另一个线程2执行donotify方法去唤醒线程1被线程3截胡了，那么等线程2去获得锁-》执行操作，使得wasSignalled为false之后，最后如果释放锁被线程1获得到了，如果是if，那么就直接向下执行，这就是假唤醒，有可能使我们程序出现问题，但是如果是while的话，因为它唤醒还要再看一下wasSignalled是否为true，因为是false，所以不会被唤醒。

public class MyWaitNotify3{

  MonitorObject myMonitorObject = new MonitorObject();
  boolean wasSignalled = false;

  public void doWait(){
    synchronized(myMonitorObject){
      if(!wasSignalled){
        try{
          myMonitorObject.wait();
         } catch(InterruptedException e){...}
      }
      //clear signal and continue running.
      wasSignalled = false;
    }
  }

  public void doNotify(){
    synchronized(myMonitorObject){
      wasSignalled = true;
      myMonitorObject.notify();
    }
  }
}

来看一则具体的例子，在生产者和消费者模型中

public class Test {
    private final Object lock = new Object();
    private int product = 0;
    //如果没有产品,在lock对象上等待唤醒,如果有产品,消费.
    private Runnable consumer = () -> {
        System.out.println(Thread.currentThread().getName() + " prepare consume");
        synchronized (lock) {
            if (product <= 0) {//替换为while解决线程虚假唤醒问题
                try {
                    System.out.println(Thread.currentThread().getName() + " wait");
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " wakeup");
            }
            product--;
            System.out.println(Thread.currentThread().getName() + " consumed product:" + product);
            if (product < 0) {
                System.err.println(Thread.currentThread().getName() + " spurious lock happend, product: " + product);
            }
        }
    };
    //生产一个产品然后唤醒一个在lock对象上等待的consumer
    private Runnable producer = () -> {
        System.out.println(Thread.currentThread().getName() + " prepare produce");
        synchronized (lock) {
            product += 1;
            System.out.println(Thread.currentThread().getName() + "produced product: " + product);
            lock.notify();
        }
    };

    public void producerAndConsumer() {
        // 启动2个consumer,1个producer
        Thread c1 = new Thread(consumer);
        Thread c2 = new Thread(consumer);
        Thread p = new Thread(producer);
        c1.start();
        c2.start();
        p.start();

    }

    public static void main(String[] args) {
        //运行100次,以便触发异常现象
        for (int i = 0; i < 100; i++) {
            new Test().producerAndConsumer();
        }

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.exit(0);
    }
}

参考多线程之while和wait
线程通信