爲什麼wait()方法要放在同步塊以及wait和notify的用法

原文鏈接：https://www.cnblogs.com/Joy-Hu/p/10693969.html

一、爲什麼wait()方法要放在同步塊

回顧一下，如果wait()方法不在同步塊中，代碼的確會拋出異常:

public class WaitInSyncBlockTest {

    @Test
    public void test() {
        try {
            new Object().wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

結果是：

Exception in thread "main" java.lang.IllegalMonitorStateException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:503)
    at com.kzx.test.juc.WaitInSyncBlockTest.main(WaitInSyncBlockTest.java:7)

1.Lost Wake-Up Problem：多線程編程裏面臭名昭著的問題
這個問題並不是說只在Java語言中會出現，而是會在所有的多線程環境下出現。

假如有兩個線程，一個消費者線程，一個生產者線程。生產者線程的任務可以簡化成將count加一，而後喚醒消費者；消費者則是將count減一，而後在減到0的時候陷入睡眠：
生產者僞代碼：

count+1;
notify();

消費者僞代碼：

while(count<=0){
　　wait();
}
count--;

熟悉多線程的朋友一眼就能夠看出來，這裏面有問題。什麼問題呢？

生產者是兩個步驟：

1、count+1;

2、notify();

消費者也是兩個步驟：

1、檢查count值；

2、睡眠或者減一；

萬一這些步驟混雜在一起呢？比如說，初始的時候count等於0，這個時候消費者檢查count的值，發現count小於等於0的條件成立；就在這個時候，發生了上下文切換，生產者進來了，噼噼啪啪一頓操作，把兩個步驟都執行完了，也就是發出了通知，準備喚醒一個線程。這個時候消費者剛決定睡覺，還沒睡呢，所以這個通知就會被丟掉。緊接着，消費者就睡過去了……

這就是所謂的lost wake up問題。

那麼怎麼解決這個問題呢？
現在我們應該就能夠看到，問題的根源在於，消費者在檢查count到調用wait()之間，count就可能被改掉了。

這就是一種很常見的競態條件。

很自然的想法是，讓消費者和生產者競爭一把鎖，競爭到了的，才能夠修改count的值。

於是生產者的代碼是:

tryLock();

count+1;

notify();

releaseLock();

消費者的代碼是:

tryLock();

while(count<=0){
    wait();
}

count--;

releaseLock();

注意的是，我這裏將兩者的兩個操作都放進去了同步塊中。

終極答案
所以，我們可以總結到，爲了避免出現這種lost wake up問題，在這種模型之下，總應該將我們的代碼放進去的同步塊中。

Java強制我們的wait()/notify()調用必須要在一個同步塊中，就是不想讓我們在不經意間出現這種lost wake up問題。

不僅僅是這兩個方法，包括java.util.concurrent.locks.Condition的await()/signal()也必須要在同步塊中。

準確的來說，即便是我們自己在實現自己的鎖機制的時候，也應該要確保類似於wait()和notify()這種調用，要在同步塊內，防止使用者出現lost wake up問題

Java的這種檢測是很嚴格的。它要求的是，一定要處於鎖對象的同步塊中。舉例來說：

private Object obj = new Object();
private Object anotherObj  = new Object();

@Test
public void produce(){
　　synchronized(obj){
　　　　try{
　　　　　　anotherObj.notify();;
　　　　}catch(Exception e){
　　　　　　e.printStackTrace();
　　　　}
　　}
}

這樣是沒有什麼卵用的。一樣出現IllegalMonitorStateException。

二、wait和notify的用法
1.wait()、notify()和notifyAll()

1）wait()、notify()和notifyAll()方法是本地方法，並且爲final方法，無法被重寫。

2）調用某個對象的wait()方法能讓當前線程阻塞，並且當前線程必須擁有此對象的monitor（即鎖，或者叫管程）

3）調用某個對象的notify()方法能夠喚醒一個正在等待這個對象的monitor的線程，如果有多個線程都在等待這個對象的monitor，則只能喚醒其中一個線程；

4）調用notifyAll()方法能夠喚醒所有正在等待這個對象的monitor的線程；
2.用法

/**
 * wait()&&notify()方法
 * 這兩個方法是在Object中定義的，用於協調線程同步，比join更加靈活
 */
public class NotifyDemo {
    public static void main(String[] args) {
        //寫兩個線程 1.圖片下載
        Object obj=new Object();
        Thread download=new Thread(){
            public void run() {
                System.out.println("開始下載圖片");
                for (int i = 0; i < 101; i+=10) {
                    System.out.println("down"+i+"%");
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("圖片下載成功");
                synchronized (obj) {
                    obj.notify();//喚起
                }
                System.out.println("開始下載附件");
                for (int i = 0; i < 101; i+=10) {
                    System.out.println("附件下載"+i+"%");

                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
                System.out.println("附件下載成功");
            }
        };
        //2.圖片展示
        Thread show=new Thread(){
            public void run(){
                synchronized (obj) {
                    try {
                        obj.wait();//阻塞當前
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("show:開始展示圖片");
                    System.out.println("圖片展示完畢");
                }

            }
        };
        download.start();
        show.start();
    }
}

運行結果截圖：

如果不使用wait()和notify(),運行結果將是這樣，圖片還未下載完就已經開始展示，不符合正常邏輯：

3.執行過程

wait和notify方法均可釋放對象的鎖，但wait同時釋放CPU控制權，即它後面的代碼停止執行，線程進入阻塞狀態，而notify方法不立刻釋放CPU控制權，而是在相應的synchronized(){}語句塊執行結束，再自動釋放鎖。
釋放鎖後，JVM會在等待resoure的線程中選取一線程，賦予其對象鎖，喚醒線程，繼續執行。這樣就提供了在線程間同步、喚醒的操作

4.sleep區別

1》前三個方法是Object的本地final方法，sleep方法是Thead類的靜態方法。
2》wait使當前線程阻塞，前提是必須先獲得鎖，所以只能在synchronized鎖範圍內裏使用wait、notify/notifyAll方法，而sleep可以在任何地方使用。
3》Thread.sleep()與Object.wait()二者都可以暫停當前線程，釋放CPU控制權，主要的區別在於Object.wait()在釋放CPU同時，釋放了對象鎖的控制，而在同步塊中的Thread.sleep()方法並不釋放鎖，僅釋放CPU控制權。

原文鏈接：https://blog.csdn.net/qq_41140741/article/details/81488663