• 新闻资讯
  • 面試官提問：線程中的wait和notify方法有啥作用？

面試官提問：線程中的wait和notify方法有啥作用？

2023.10.12

面試官提問：線程中的wait和notify方法有啥作用？


本文主要圍繞線程之間的協調和通信相關技術進行一些知識總結，使用Object類別中的wait()、notify()、notifyAll()方法，可以實現線程之間的協調和通信，但是它們只有在synchronized修飾的同步方法/同步程式碼區塊才會生效。

一、簡介

在先前的線程系列文章中，我們介紹了synchronized和volatile關鍵字，使用它能解決線程同步的問題，但是它們無法解決線程之間協調和通信的問題。

舉個簡單的例子，例如線程A 負責將int 型變數i 值累積操作到10000，然後通知線程B 負責把結果列印出來。

這個怎麼實現呢？其中一個最簡單的辦法就是，線程B 不斷的透過輪詢方式while(i == 10000)檢查是否滿足條件，這樣就可以實現了。

雖然這種方式可以實現需求，但也帶來了另一個問題：執行緒B 中的while()操作不會釋放CPU 資源，會導致CPU 一直在這個方法上做判斷操作，極大的浪費CPU 資源。

我们知道 CPU 资源是非常非常昂贵的，因为使用 CPU 资源不只是当前一个应用程序，还有其它许许多多的应用程序。如果把这些轮询的时间释放出来，给别的线程使用，更能显著提升应用程序的运行效率。比如，线程 A 操作完成之后，通知线程 B 进行后续的操作，线程 B 无需通过轮询检查的方式来完成线程之间的协调，这样是不是更好。

在Java 的父類別中，也就是Object類別中，就有三個方法：wait()、notify()、notifyAll()，它們可以實作執行緒之間的通訊。

如果沒有接觸多線程，這些方法可能基本上使用不到。下面我們就一起來看看它們的使用方式！

二、方法介紹

  • 等待（）

wait()方法，顧名思義，表示等待的意思，它的作用是：使執行當前程式碼的執行緒進入阻塞狀態，將目前執行緒置入"預執行佇列"中，並且wait()所在的程式碼處停止執行，直到接到通知或中斷。

不過有個前提，在呼叫wait()方法之前，執行緒必須取得該物件的鎖，因此只能在synchronized修飾的同步方法/同步程式碼區塊中呼叫wait()方法；同時，wait()方法執行後，會立即釋放所獲得的物件鎖以便其它執行緒使用，當前執行緒被阻塞，進入等待狀態。

至於wait()為什麼有阻塞的效果，其內部機制非常複雜，主要由JVM 的C 程式碼實現，大家了解就行。

  • 通知（）

notify()方法，顧名思義，表示通知的意思，它的作用是：讓處於同一監視器下的等待線程被重新喚醒，如果有多個線程等待，那麼隨機挑選出一個等待的線程，對其發出通知notify()，並使它等待取得該物件的物件鎖。

注意“等待獲取該物件的物件鎖”，這意味著即使收到了通知，等待的執行緒也不會馬上取得物件鎖，必須等待notify()方法的執行緒釋放鎖才可以。

呼叫環境和wait()一樣，notify()也要在synchronized修飾的同步方法/同步程式碼區塊中呼叫。

  • 通知全部()

notifyAll()方法，顧名思義，也是表示通知的意思，它的作用是：讓所有處於同一監視器下的等待線程被重新喚醒，notify()方法只會隨機的喚醒一個線程，而使用notifyAll()方法將一次性全部喚醒。

通常來說，notifyAll()方法更安全，因為當我們的程式碼邏輯考慮不周的時候，使用notify()會導致只喚醒了一個線程，而其他線程可能永遠等待下去醒不過來了。

呼叫環境和notify()一樣，notifyAll()也要在synchronized修飾的同步方法/同步程式碼區塊中呼叫。

三個方法總結下來就是：

  • 1.wait()方法，使執行緒阻塞，進入等待狀態
  • 2.notify()方法，喚醒處於等待的線程，如果有多個線程就隨機從中取一個
  • 3.notifyAll()方法，喚醒所有處於等待的執行緒

2.1、wait/notify/notifyAll 使用介紹

通常wait()方法，一般與notify()或notifyAll()搭配使用比較多。

下面我們來看一個簡單的範例。

public class MyThreadA extends Thread{

    private Object lock;

    public MyThreadA(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock){
            System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " wait begin");
            try {
                // 进入阻塞等待
                lock.wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " wait end");
        }
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
public class MyThreadB extends Thread{

    private Object lock;

    public MyThreadB(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock){
            System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " notify begin");
            // 唤醒其它等待线程
            lock.notify();
            System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " notify end");
        }
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
public class MyThreadTest {

    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        MyThreadA threadA = new MyThreadA(lock);
        threadA.start();

        //过3秒再启动下一个线程
        Thread.sleep(3000);

        MyThreadB threadB = new MyThreadB(lock);
        threadB.start();
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.

運行服務，輸出結果如下：

2023-09-28 16:42:19 当前线程：Thread-0 wait begin
2023-09-28 16:42:22 当前线程：Thread-1 notify begin
2023-09-28 16:42:22 当前线程：Thread-1 notify end
2023-09-28 16:42:22 当前线程：Thread-0 wait end
  • 1.
  • 2.
  • 3.
  • 4.

從日誌可以得出，threadA線程先啟動，然後進入阻塞狀態，過了3 秒之後，再啟動threadB線程，運行結束之後，通知threadA線程可以取得物件鎖，最後執行完畢。

整個線程之間的協調和通信，大體就是這樣的。

假如我們把threadA線程數量增加到5 個，再來看看運行效果。

public class MyThreadTest {

    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        // 创建5个wait线程
        for (int i = 0; i < 5; i++) {
            MyThreadA threadA = new MyThreadA(lock);
            threadA.start();
        }

        //过3秒再启动下一个线程
        Thread.sleep(3000);

        MyThreadB threadB = new MyThreadB(lock);
        threadB.start();
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.

運行服務，輸出結果如下：

2023-09-28 17:02:05 当前线程：Thread-0 wait begin
2023-09-28 17:02:05 当前线程：Thread-4 wait begin
2023-09-28 17:02:05 当前线程：Thread-3 wait begin
2023-09-28 17:02:05 当前线程：Thread-2 wait begin
2023-09-28 17:02:05 当前线程：Thread-1 wait begin
2023-09-28 17:02:08 当前线程：Thread-5 notify begin
2023-09-28 17:02:08 当前线程：Thread-5 notify end
2023-09-28 17:02:08 当前线程：Thread-0 wait end
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.

從日誌中，可以很清楚的看到，當多個執行緒處於等待狀態時，呼叫notify()方法，只會喚醒其中一個等待的執行緒；同時服務無法關閉，因為剩下的4 個執行緒一直處於阻塞狀態。

假如我們把MyThreadB類別中的lock.notify()方法改成lock.notifyAll()方法，再看看效果如何。

public class MyThreadB extends Thread{

    private Object lock;

    public MyThreadB(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock){
            System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " notify begin");
            // 唤醒所有等待的线程
            lock.notifyAll();
            System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " notify end");
        }
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.

運行服務，輸出結果如下：

2023-09-28 17:18:13 当前线程：Thread-0 wait begin
2023-09-28 17:18:13 当前线程：Thread-4 wait begin
2023-09-28 17:18:13 当前线程：Thread-3 wait begin
2023-09-28 17:18:13 当前线程：Thread-2 wait begin
2023-09-28 17:18:13 当前线程：Thread-1 wait begin
2023-09-28 17:18:16 当前线程：Thread-5 notify begin
2023-09-28 17:18:16 当前线程：Thread-5 notify end
2023-09-28 17:18:16 当前线程：Thread-1 wait end
2023-09-28 17:18:16 当前线程：Thread-2 wait end
2023-09-28 17:18:16 当前线程：Thread-3 wait end
2023-09-28 17:18:16 当前线程：Thread-4 wait end
2023-09-28 17:18:16 当前线程：Thread-0 wait end
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.

從日誌上可以很清楚的看到，3 秒後所有處於等待的執行緒都被喚醒，並且服務運行結束。

2.2、wait 釋放鎖介紹

在多執行緒的程式設計中，任何時候都要注意鎖，因為它對目前程式碼執行是否安全，發揮了重要的作用。

在上面我們提到，呼叫wait()方法，除了讓執行緒進入阻塞，進入等待狀態以外，還會釋放鎖。

我們可以看一個簡單的範例就知道了。

public class MyThreadA1 extends Thread{

    private Object lock;

    public MyThreadA1(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock){
            System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " wait begin");
            try {
                // 进入阻塞等待
                lock.wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " wait end");
        }
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
public class MyThreadTest1 {

    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();

        // 创建两个调用wait的线程
        MyThreadA1 threadA1 = new MyThreadA1(lock);
        threadA1.start();

        MyThreadA1 threadA2 = new MyThreadA1(lock);
        threadA2.start();
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.

運行服務，輸出結果如下：

2023-09-28 17:31:56 当前线程：Thread-0 wait begin
2023-09-28 17:31:56 当前线程：Thread-1 wait begin
  • 1.
  • 2.

從日誌結果可以清楚的看出，兩個執行緒中其中一個呼叫lock.wait()之後，進入了阻塞狀態，同時把物件鎖也釋放掉了，另一個執行緒拿到鎖並進入同步程式碼區塊內，所以看到兩個線程都印了wait begin。

在Thread類別中也有一個sleep()方法可以讓目前執行緒阻塞，但是它們之間是有區別的，sleep()方法不會讓目前執行緒釋放鎖定。

我們可以看一個簡單的例子。

public class MyThreadA1 extends Thread{

    private Object lock;

    public MyThreadA1(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock){
            System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " sleep begin");
            try {
                // 进入阻塞等待
                Thread.sleep(100);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " sleep end");
        }
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
public class MyThreadTest1 {

    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();

        // 创建两个调用sleep的线程
        MyThreadA1 threadA1 = new MyThreadA1(lock);
        threadA1.start();

        MyThreadA1 threadA2 = new MyThreadA1(lock);
        threadA2.start();
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.

運行服務，輸出結果如下：

2023-09-28 17:55:20 当前线程：Thread-0 sleep begin
2023-09-28 17:55:21 当前线程：Thread-0 sleep end
2023-09-28 17:55:21 当前线程：Thread-1 sleep begin
2023-09-28 17:55:21 当前线程：Thread-1 sleep end
  • 1.
  • 2.
  • 3.
  • 4.

從日誌上看，執行緒沒有交替執行，而是串連執行。

2.3、notify/notifyAll 不釋放鎖介紹

於此對應的還有notify()和notifyAll()， 呼叫notify()或notifyAll()方法當前執行緒是不會釋放鎖定的，只有當同步方法/同步程式碼區塊執行完畢，才會釋放鎖定。

同樣的，我們可以看一個簡單的範例。

public class MyThreadA2 extends Thread{

    private Object lock;

    public MyThreadA2(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock){
            System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " notify begin");
            // 唤醒其它等待线程
            lock.notify();
            System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " notify end");
        }
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
public class MyThreadTest2 {

    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();

        // 创建两个调用notify()的线程
        MyThreadA2 threadA1 = new MyThreadA2(lock);
        threadA1.start();

        MyThreadA2 threadA2 = new MyThreadA2(lock);
        threadA2.start();
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.

運行服務，輸出結果如下：

2023-09-28 18:11:36 当前线程：Thread-0 notify begin
2023-09-28 18:11:36 当前线程：Thread-0 notify end
2023-09-28 18:11:36 当前线程：Thread-1 notify begin
2023-09-28 18:11:36 当前线程：Thread-1 notify end
  • 1.
  • 2.
  • 3.
  • 4.

從日誌結果可以清楚的看出，兩個執行緒沒有交替執行，而是串列執行。

2.4、IllegalMonitorStateException 異常介紹

雖然wait()、notify()、notifyAll()方法是在Object 類別中，理論上每個類別都可以直接調用，但不是每個地方都可以隨便調用，如果調用這三個方法，不在同步方法/在同步程式碼區塊中，程式運行時會直接拋一次拋異常java.lang.IllegalMonitorStateException。

下面我們看一個簡單的範例就知道了。

public class MyThreadTest3 {

    public static void main(String[] args) throws Exception {
        Object lock = new Object();
        lock.wait();
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.

運行程序，直接拋異常。

Exception in thread "main" java.lang.IllegalMonitorStateException
 at java.lang.Object.wait(Native Method)
 at java.lang.Object.wait(Object.java:502)
 at com.example.thread.e3.MyThreadTest3.main(MyThreadTest3.java:19)
  • 1.
  • 2.
  • 3.
  • 4.

換成notify()、notifyAll()，運行結果也是一樣。

三、小結

本文主要圍繞線程之間的協調和通信相關技術進行一些知識總結，使用Object類別中的wait()、notify()、notifyAll()方法，可以實現線程之間的協調和通信，但是它們只有在synchronized修飾的同步方法/同步程式碼區塊才會生效。如果不在同步方法/同步程式碼區塊調用，會拋java.lang.IllegalMonitorStateException異常。

文章內容難免有所遺漏，歡迎網友留言指出！

四、參考

1、廖雪峰- wait和notify介紹

2、五月的倉頡- wait()和notify()/notifyAll()介紹