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字，可根据需要调整具体实现细节或扩展案例部分）