Java多執行緒8：wait()和notify()/notifyAll()

五月的倉頡發表於2015-10-04
Java執行緒AI

輪詢

執行緒本身是作業系統中獨立的個體，但是執行緒與執行緒之間不是獨立的個體，因為它們彼此之間要相互通訊和協作。

想像一個場景，A執行緒做int型變數i的累加操作，B執行緒等待i到了10000就列印出i，怎麼處理？一個辦法就是，B執行緒while(i == 10000)，這樣兩個執行緒之間就有了通訊，B執行緒不斷通過輪訓來檢測i == 10000這個條件。

這樣可以實現我們的需求，但是也帶來了問題：CPU把資源浪費了B執行緒的輪詢操作上，因為while操作並不釋放CPU資源，導致了CPU會一直在這個執行緒中做判斷操作。如果可以把這些輪詢的時間釋放出來，給別的執行緒用，就好了。

 

wait/notify

在Object物件中有三個方法wait()、notify()、notifyAll()，既然是Object中的方法，那每個物件自然都是有的。如果不接觸多執行緒的話，這兩個方法是不太常見的。下面看一下前兩個方法：

1、wait()

wait()的作用是使當前執行程式碼的執行緒進行等待，將當前執行緒置入"預執行佇列"中，並且wait()所在的程式碼處停止執行，直到接到通知或被中斷。在呼叫wait()之前，執行緒必須獲得該物件的鎖，因此只能在同步方法/同步程式碼塊中呼叫wait()方法。

2、notify()

notify()的作用是，如果有多個執行緒等待，那麼執行緒規劃器隨機挑選出一個wait的執行緒，對其發出通知notify()，並使它等待獲取該物件的物件鎖。注意"等待獲取該物件的物件鎖"，這意味著，即使收到了通知，wait的執行緒也不會馬上獲取物件鎖，必須等待notify()方法的執行緒釋放鎖才可以。和wait()一樣，notify()也要在同步方法/同步程式碼塊中呼叫。

總結起來就是，wait()使執行緒停止執行，notify()使停止執行的執行緒繼續執行。

 

wait()/notify()使用示例

看一段程式碼：

public class MyThread30_0 extends Thread
{
    private Object lock;
    
    public MyThread30_0(Object lock)
    {
        this.lock = lock;
    }
    
    public void run()
    {
        try
        {
            synchronized (lock)
            {
                System.out.println("開始------wait time = " + System.currentTimeMillis());
                lock.wait();
                System.out.println("結束------wait time = " + System.currentTimeMillis());
            }
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}
public class MyThread30_1 extends Thread
{
    private Object lock;
    
    public MyThread30_1(Object lock)
    {
        this.lock = lock;
    }
    
    public void run()
    {
        synchronized (lock)
        {
            System.out.println("開始------notify time = " + System.currentTimeMillis());
            lock.notify();
            System.out.println("結束------notify time = " + System.currentTimeMillis());
        }
    }
}

寫個main函式，同樣的Thread.sleep(3000)也是為了保證mt0先執行，這樣才能看到wait()和notify()的效果：

public static void main(String[] args) throws Exception
{
    Object lock = new Object();
    MyThread30_0 mt0 = new MyThread30_0(lock);
    mt0.start();
    Thread.sleep(3000);
    MyThread30_1 mt1 = new MyThread30_1(lock);
    mt1.start();
}

看一下執行結果：

開始------wait time = 1443931599021
開始------notify time = 1443931602024
結束------notify time = 1443931602024
結束------wait time = 1443931602024

第一行和第二行之間的time減一下很明顯就是3s，說明wait()之後程式碼一直暫停，notify()之後程式碼才開始執行。

wait()方法可以使呼叫該執行緒的方法釋放共享資源的鎖，然後從執行狀態退出，進入等待佇列，直到再次被喚醒。

notify()方法可以隨機喚醒等待佇列中等待同一共享資源的一個執行緒，並使得該執行緒退出等待狀態，進入可執行狀態

notifyAll()方法可以使所有正在等待佇列中等待同一共享資源的全部執行緒從等待狀態退出，進入可執行狀態 

最後，如果wait()方法和notify()/notifyAll()方法不在同步方法/同步程式碼塊中被呼叫，那麼虛擬機器會丟擲java.lang.IllegalMonitorStateException，注意一下。

 

wait()釋放鎖以及notify()不釋放鎖

多執行緒的學習中，任何地方都要關注"鎖"，wait()和notify()也是這樣。wait()方法是釋放鎖的，寫一個例子來證明一下：

public class ThreadDomain31
{
    public void testMethod(Object lock)
    {
        try
        {
            synchronized (lock)
            {
                System.out.println(Thread.currentThread().getName() + " Begin wait()");
                lock.wait();
                System.out.println(Thread.currentThread().getName() + " End wait");
            }
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}
public class MyThread31 extends Thread
{
    private Object lock;
    
    public MyThread31(Object lock)
    {
        this.lock = lock;
    }
    
    public void run()
    {
        ThreadDomain31 td = new ThreadDomain31();
        td.testMethod(lock);
    }
}

main函式呼叫一下：

public static void main(String[] args)
{
    Object lock = new Object();
    MyThread31 mt0 = new MyThread31(lock);
    MyThread31 mt1 = new MyThread31(lock);
    mt0.start();
    mt1.start();
}

看一下執行結果：

Thread-0 Begin wait()
Thread-1 Begin wait()

如果wait()方法不釋放鎖，那麼Thread-1根本不會進入同步程式碼塊列印的，所以，證明完畢。

接下來證明一下notify()方法不釋放鎖的結論：

public class ThreadDomain32
{
    public void testMethod(Object lock)
    {
        try
        {
            synchronized (lock)
            {
                System.out.println("Begin wait(), ThreadName = " + Thread.currentThread().getName());
                lock.wait();
                System.out.println("End wait(), ThreadName = " + Thread.currentThread().getName());
            }
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
    
    public void synNotifyMethod(Object lock)
    {
        try
        {
            synchronized (lock)
            {
                System.out.println("Begin notify(), ThreadName = " + Thread.currentThread().getName());
                lock.notify();
                Thread.sleep(5000);
                System.out.println("End notify(), ThreadName = " + Thread.currentThread().getName());
            }
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

寫兩個執行緒分別呼叫2個方法：

public class MyThread32_0 extends Thread
{
    private Object lock;
    
    public MyThread32_0(Object lock)
    {
        this.lock = lock;
    }
    
    public void run()
    {
        ThreadDomain32 td = new ThreadDomain32();
        td.testMethod(lock);
    }
}
public class MyThread32_1 extends Thread
{
    private Object lock;
    
    public MyThread32_1(Object lock)
    {
        this.lock = lock;
    }
    
    public void run()
    {
        ThreadDomain32 td = new ThreadDomain32();
        td.synNotifyMethod(lock);
    }
}

寫個main函式呼叫一下：

public static void main(String[] args) throws Exception
{
    Object lock = new Object();
    MyThread32_0 mt0 = new MyThread32_0(lock);
    mt0.start();
    MyThread32_1 mt1 = new MyThread32_1(lock);
    mt1.start();
    MyThread32_1 mt2 = new MyThread32_1(lock);
    mt2.start();
}

看一下執行結果：

Begin wait(), ThreadName = Thread-0
Begin notify(), ThreadName = Thread-1
End notify(), ThreadName = Thread-1
Begin notify(), ThreadName = Thread-2
End notify(), ThreadName = Thread-2
End wait(), ThreadName = Thread-0

如果notify()方法釋放鎖，那麼在Thread-1呼叫notify()方法後Thread.sleep(5000)必定應該有其他執行緒可以進入同步程式碼塊了，但是實際上沒有，必須等到Thread-1把程式碼執行完。所以，證明完畢。

 

interrupt()打斷wait()

之前有說過，interrupt()方法的作用不是中斷執行緒，而是線上程阻塞的時候給執行緒一箇中斷標識，表示該執行緒中斷。wait()就是"阻塞的一種場景"，看一下用interrupt()打斷wait()的例子：

public class ThreadDomain33
{
    public void testMethod(Object lock)
    {
        try
        {
            synchronized (lock)
            {
                System.out.println("Begin wait()");
                lock.wait();
                System.out.println("End wait()");
            }
        }
        catch (InterruptedException e)
        {
            System.out.println("wait()被interrupt()打斷了！");
            e.printStackTrace();
        }
    }
}
public class MyThread33 extends Thread
{
    private Object lock;
    
    public MyThread33(Object lock)
    {
        this.lock = lock;
    }
    
    public void run()
    {
        ThreadDomain33 td = new ThreadDomain33();
        td.testMethod(lock);
    }
}
public static void main(String[] args) throws Exception
{
    Object lock = new Object();
    MyThread33 mt = new MyThread33(lock);
    mt.start();
    Thread.sleep(5000);
    mt.interrupt();
}

看一下執行結果：

Begin wait()
wait()被interrupt()打斷了！
java.lang.InterruptedException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:485)
    at com.xrq.example.e33.ThreadDomain33.testMethod(ThreadDomain33.java:12)
    at com.xrq.example.e33.MyThread33.run(MyThread33.java:15)

 

notifyAll()喚醒所有執行緒

利用Object物件的notifyAll()方法可以喚醒處於同一監視器下的所有處於wait的執行緒，舉個例子證明一下：

public class ThreadDomain34
{
    public void testMethod(Object lock)
    {
        try
        {
            synchronized (lock)
            {
                System.out.println("Begin wait(), ThreadName = " + Thread.currentThread().getName());
                lock.wait();
                System.out.println("End wait(), ThreadName = " + Thread.currentThread().getName());
            }
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

寫兩個執行緒，一個呼叫testMethod(Object lock)的執行緒，一個notifyAll()執行緒：

public class MyThread34_0 extends Thread
{
    private Object lock;
    
    public MyThread34_0(Object lock)
    {
        this.lock = lock;
    }
    
    public void run()
    {
        ThreadDomain34 td = new ThreadDomain34();
        td.testMethod(lock);
    }
}
public class MyThread34_1 extends Thread
{
    private Object lock;
    
    public MyThread34_1(Object lock)
    {
        this.lock = lock;
    }
    
    public void run()
    {
        synchronized (lock)
        {
            lock.notifyAll();
        }
    }
}

main函式開三個wait執行緒，用一個notifyAll的執行緒去喚醒：

public static void main(String[] args) throws Exception
{
    Object lock = new Object();
    MyThread34_0 mt0 = new MyThread34_0(lock);
    MyThread34_0 mt1 = new MyThread34_0(lock);
    MyThread34_0 mt2 = new MyThread34_0(lock);
    mt0.start();
    mt1.start();
    mt2.start();
    Thread.sleep(1000);
    MyThread34_1 mt3 = new MyThread34_1(lock);
    mt3.start();
}

看一下執行結果：

Begin wait(), ThreadName = Thread-0
Begin wait(), ThreadName = Thread-2
Begin wait(), ThreadName = Thread-1
End wait(), ThreadName = Thread-1
End wait(), ThreadName = Thread-2
End wait(), ThreadName = Thread-0

當然，喚醒的順序不重要，因為notifyAll()把處於同一資源下wait的執行緒全部喚醒，至於喚醒的順序，就和執行緒啟動的順序一樣，是虛擬機器隨機的。

 

相關文章