Java如何在兩個線程間進行通訊

# Java如何在兩個線程間進行通訊

## 引言

在多線程編程中，線程間的通信（Inter-Thread Communication）是核心問題之一。Java提供了多種機制實現線程間數據傳遞和協調，包括共享內存、等待/通知機制、阻塞隊列等。本文將深入探討這些方法及其適用場景。

---

## 一、共享內存（Shared Memory）

### 1.1 基本原理
通過共享對象或變量實現數據交換，需配合`synchronized`保證線程安全。

```java
class SharedObject {
    private String message;
    
    public synchronized void setMessage(String msg) {
        this.message = msg;
    }
    
    public synchronized String getMessage() {
        return message;
    }
}

1.2 優缺點

• ? 實現簡單直接
  
• ? 需要手動處理同步，易引發死鎖或競態條件

二、等待/通知機制（Wait/Notify）

2.1 核心方法

• wait(): 釋放鎖并進入等待狀態
• notify()/notifyAll(): 喚醒等待線程

class MessageQueue {
    private String message;
    private boolean empty = true;

    public synchronized void put(String msg) {
        while (!empty) wait();
        message = msg;
        empty = false;
        notifyAll();
    }

    public synchronized String take() {
        while (empty) wait();
        empty = true;
        notifyAll();
        return message;
    }
}

2.2 注意事項

• 必須在同步塊內調用
• 推薦使用notifyAll()避免信號丟失

三、BlockingQueue實現

3.1 JDK提供的線程安全隊列

BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);

// 生產者線程
queue.put("Data");

// 消費者線程
String data = queue.take();

3.2 優勢

• 內置線程安全
• 支持容量限制和超時操作

四、管道通信（PipedStream）

4.1 適用場景

面向字節流/字符流的單向通信：

PipedInputStream pis = new PipedInputStream();
PipedOutputStream pos = new PipedOutputStream(pis);

// 線程1寫入
pos.write("Hello".getBytes());

// 線程2讀取
pis.read();

五、高級通信工具

5.1 CountDownLatch

CountDownLatch latch = new CountDownLatch(2);

// 線程A/B
latch.countDown();

// 主線程
latch.await();

5.2 CyclicBarrier

CyclicBarrier barrier = new CyclicBarrier(3);

// 所有線程到達屏障后繼續執行
barrier.await();

5.3 Exchanger

Exchanger<String> exchanger = new Exchanger<>();

// 線程A
String dataA = exchanger.exchange("DataA");

// 線程B
String dataB = exchanger.exchange("DataB");

六、實戰案例：生產者-消費者模型

class ProducerConsumer {
    private final BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5);

    class Producer implements Runnable {
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    class Consumer implements Runnable {
        public void run() {
            try {
                while (true) {
                    Integer value = queue.take();
                    System.out.println("Consumed: " + value);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

七、通信方式對比

八、最佳實踐建議

1. 優先使用java.util.concurrent包中的工具類
2. 避免使用Thread.stop()等廢棄方法
3. 注意處理InterruptedException
4. 考慮使用volatile保證可見性
5. 復雜場景可使用Lock和Condition替代synchronized

結語

Java線程通信的選擇取決于具體場景需求。對于簡單交互，共享變量或BlockingQueue可能足夠；復雜協調則需要Wait/Notify或并發工具類。理解每種機制的底層原理是寫出健壯多線程程序的關鍵。

提示：Java 21引入的虛擬線程（Virtual Threads）進一步簡化了并發編程模型，值得關注。 “`

（全文約1350字，可根據需要調整具體實現細節或擴展案例部分）