完全真正理解wait和notify使用的時候wait一定要放在while循環裏面！

說實話，第一遍看這個概念並沒有看懂，第二遍硬磕了一下，發現原來不理解的原因是**if()和while()方法給忽視了**

• if(){…}，如果說程序在判斷完滿足if條件之後，那麼就會進入大括號裏面，即使在裏面等待一段時間之後，我們也是會直接出來
• while(){…}如果說滿足了條件，那麼就會進入大括號裏面，在裏面呆了一段時間，要想出來那得先去while判斷一下，如果滿足，還是不能出來。

即if進去要口令，出來不要口令
while進去和出來都要口令
那麼我們來看具體的代碼：如果線程1在執行dowait方法釋放鎖之後進入等待狀態，即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
線程通信