Java怎么使用wait或notify實現線程間通信

Java怎么使用wait或notify實現線程間通信

在Java中，線程間通信是多線程編程中的一個重要概念。為了實現線程間的協調與同步，Java提供了wait()和notify()方法。這兩個方法都是Object類的一部分，因此所有Java對象都可以使用它們。本文將詳細介紹如何使用wait()和notify()實現線程間通信，并通過示例代碼幫助讀者更好地理解這些概念。

1. 線程間通信的基本概念

在多線程環境中，線程之間可能需要共享數據或協調工作。為了實現這一點，線程之間需要進行通信。Java提供了多種機制來實現線程間通信，其中wait()和notify()是最常用的方法之一。

1.1 wait()方法

wait()方法使當前線程進入等待狀態，直到其他線程調用該對象的notify()或notifyAll()方法。調用wait()方法時，當前線程會釋放對象的鎖，并進入等待隊列。

1.2 notify()方法

notify()方法喚醒在該對象上等待的單個線程。如果有多個線程在等待，JVM會選擇一個線程喚醒。被喚醒的線程將重新嘗試獲取對象的鎖，并在獲取鎖后繼續執行。

1.3 notifyAll()方法

notifyAll()方法喚醒在該對象上等待的所有線程。所有被喚醒的線程將競爭對象的鎖，只有一個線程能夠成功獲取鎖并繼續執行。

2. wait()和notify()的使用場景

wait()和notify()通常用于生產者-消費者模式中。在這種模式下，生產者線程生成數據并將其放入共享緩沖區，而消費者線程從緩沖區中取出數據進行處理。當緩沖區為空時，消費者線程需要等待生產者線程生成數據；當緩沖區滿時，生產者線程需要等待消費者線程消費數據。

3. 使用wait()和notify()實現線程間通信

下面通過一個簡單的生產者-消費者示例來演示如何使用wait()和notify()實現線程間通信。

3.1 共享緩沖區

首先，我們定義一個共享緩沖區類SharedBuffer，它包含一個List來存儲數據，并提供了put()和take()方法來添加和取出數據。

import java.util.LinkedList;
import java.util.Queue;

public class SharedBuffer {
    private Queue<Integer> buffer = new LinkedList<>();
    private final int capacity;

    public SharedBuffer(int capacity) {
        this.capacity = capacity;
    }

    public synchronized void put(int value) throws InterruptedException {
        while (buffer.size() == capacity) {
            wait(); // 緩沖區已滿，等待消費者消費
        }
        buffer.add(value);
        System.out.println("Produced: " + value);
        notifyAll(); // 通知消費者可以消費了
    }

    public synchronized int take() throws InterruptedException {
        while (buffer.isEmpty()) {
            wait(); // 緩沖區為空，等待生產者生產
        }
        int value = buffer.poll();
        System.out.println("Consumed: " + value);
        notifyAll(); // 通知生產者可以生產了
        return value;
    }
}

3.2 生產者線程

接下來，我們定義一個生產者線程類Producer，它不斷地向共享緩沖區中添加數據。

public class Producer implements Runnable {
    private SharedBuffer buffer;

    public Producer(SharedBuffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                buffer.put(i);
                Thread.sleep(100); // 模擬生產時間
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

3.3 消費者線程

然后，我們定義一個消費者線程類Consumer，它不斷地從共享緩沖區中取出數據。

public class Consumer implements Runnable {
    private SharedBuffer buffer;

    public Consumer(SharedBuffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                buffer.take();
                Thread.sleep(150); // 模擬消費時間
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

3.4 測試代碼

最后，我們編寫一個測試類ProducerConsumerTest來啟動生產者和消費者線程。

public class ProducerConsumerTest {
    public static void main(String[] args) {
        SharedBuffer buffer = new SharedBuffer(5);

        Thread producerThread = new Thread(new Producer(buffer));
        Thread consumerThread = new Thread(new Consumer(buffer));

        producerThread.start();
        consumerThread.start();
    }
}

3.5 運行結果

運行上述代碼后，輸出結果如下：

Produced: 0
Consumed: 0
Produced: 1
Consumed: 1
Produced: 2
Consumed: 2
Produced: 3
Consumed: 3
Produced: 4
Consumed: 4
Produced: 5
Consumed: 5
Produced: 6
Consumed: 6
Produced: 7
Consumed: 7
Produced: 8
Consumed: 8
Produced: 9
Consumed: 9

從輸出結果可以看出，生產者和消費者線程通過wait()和notify()實現了線程間的協調與同步。

4. wait()和notify()的注意事項

在使用wait()和notify()時，需要注意以下幾點：

4.1 必須在同步塊中使用

wait()和notify()必須在同步塊或同步方法中使用，否則會拋出IllegalMonitorStateException異常。這是因為wait()和notify()依賴于對象的鎖機制。

4.2 使用while循環檢查條件

在調用wait()之前，通常需要使用while循環來檢查條件。這是因為線程被喚醒后，條件可能仍然不滿足（例如，多個線程在等待同一個條件），因此需要再次檢查條件。

4.3 避免死鎖

在使用wait()和notify()時，需要小心避免死鎖。死鎖通常發生在多個線程相互等待對方釋放鎖的情況下。為了避免死鎖，應確保線程以一致的順序獲取鎖。

5. 使用notifyAll()的替代方案

在某些情況下，使用notifyAll()可能會導致性能問題，因為它會喚醒所有等待的線程，而實際上只有一個線程能夠繼續執行。為了避免這種情況，可以使用Condition類來實現更細粒度的線程控制。

5.1 Condition類

Condition類是java.util.concurrent.locks包的一部分，它提供了類似于wait()和notify()的功能，但支持多個條件隊列。通過使用Condition，可以更精確地控制哪些線程被喚醒。

5.2 使用Condition實現生產者-消費者模式

下面是一個使用Condition實現的生產者-消費者示例。

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SharedBufferWithCondition {
    private Queue<Integer> buffer = new LinkedList<>();
    private final int capacity;
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();

    public SharedBufferWithCondition(int capacity) {
        this.capacity = capacity;
    }

    public void put(int value) throws InterruptedException {
        lock.lock();
        try {
            while (buffer.size() == capacity) {
                notFull.await(); // 緩沖區已滿，等待
            }
            buffer.add(value);
            System.out.println("Produced: " + value);
            notEmpty.signal(); // 通知消費者可以消費了
        } finally {
            lock.unlock();
        }
    }

    public int take() throws InterruptedException {
        lock.lock();
        try {
            while (buffer.isEmpty()) {
                notEmpty.await(); // 緩沖區為空，等待
            }
            int value = buffer.poll();
            System.out.println("Consumed: " + value);
            notFull.signal(); // 通知生產者可以生產了
            return value;
        } finally {
            lock.unlock();
        }
    }
}

5.3 測試代碼

public class ProducerConsumerWithConditionTest {
    public static void main(String[] args) {
        SharedBufferWithCondition buffer = new SharedBufferWithCondition(5);

        Thread producerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    buffer.put(i);
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    buffer.take();
                    Thread.sleep(150);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producerThread.start();
        consumerThread.start();
    }
}

5.4 運行結果

運行上述代碼后，輸出結果與之前的示例類似，但使用了Condition類來實現更細粒度的線程控制。

6. 總結

wait()和notify()是Java中實現線程間通信的重要工具。通過合理地使用這兩個方法，可以實現線程間的協調與同步，從而避免競態條件和死鎖等問題。在實際開發中，應根據具體需求選擇合適的線程通信機制，并注意避免常見的陷阱和錯誤。

通過本文的介紹和示例代碼，讀者應該能夠理解如何使用wait()和notify()實現線程間通信，并能夠在實際項目中應用這些知識。希望本文對您有所幫助！