如何实现线程间通信

线程间通信（Inter-Thread Communication，ITC）指的是多个线程之间协调工作、交换数据或同步状态。实现方式取决于你使用的编程语言和运行环境。下面以通用原理 + Java 为主进行说明，并简要对比其他语言。

一、为什么需要线程间通信

• 多个线程共享资源，需要同步访问
• 一个线程需要等待另一个线程的结果
• 生产者 / 消费者模型
• 控制线程执行顺序

二、Java 中常见的线程通信方式

1️⃣ wait() / notify() / notifyAll()（最经典）

前提：必须在 synchronized 代码块或方法中

class Shared {
    private int data;
    private boolean available = false;

    public synchronized void produce(int value) throws InterruptedException {
        while (available) {
            wait(); // 等待消费者消费
        }
        data = value;
        available = true;
        notifyAll(); // 唤醒消费者
    }

    public synchronized int consume() throws InterruptedException {
        while (!available) {
            wait(); // 等待生产者生产
        }
        available = false;
        notifyAll(); // 唤醒生产者
        return data;
    }
}

✅ 特点：

• 底层、灵活
• 容易出错（必须配合 while + 条件判断）
• 属于 Object 的方法

2️⃣ volatile + 自旋（简单状态通信）

适合状态标志

class Task implements Runnable {
    private volatile boolean running = true;

    public void stop() {
        running = false;
    }

    public void run() {
        while (running) {
            // do work
        }
    }
}

✅ 适合：

• 简单开关
• 不依赖复杂同步

❌ 不适合：

• 复杂条件等待

3️⃣ Lock + Condition（比 wait/notify 更灵活）

java.util.concurrent.locks

Lock lock = new ReentrantLock();
Condition notEmpty = lock.newCondition();
Condition notFull = lock.newCondition();

lock.lock();
try {
    while (queue.isEmpty()) {
        notEmpty.await();
    }
    // 消费
    notFull.signal();
} finally {
    lock.unlock();
}

✅ 优点：

• 一个 Lock 可以有多个 Condition
• 更细粒度控制

4️⃣ 阻塞队列（生产者-消费者首选 ✅）

BlockingQueue

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

// 生产者
queue.put(1);

// 消费者
int value = queue.take();

✅ 优点：

• 线程安全
• 自动阻塞
• 代码简洁
• 最推荐

5️⃣ CountDownLatch（等待其他线程完成）

CountDownLatch latch = new CountDownLatch(3);

// 子线程
latch.countDown();

// 主线程
latch.await();

✅ 用于：

• 等待多个线程完成
• 一次性同步

6️⃣ CyclicBarrier（线程互相等待）

CyclicBarrier barrier = new CyclicBarrier(3);

barrier.await();

✅ 用于：

• 多线程阶段性任务

7️⃣ Future / Callable（线程返回结果）

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<Integer> future = executor.submit(() -> 1 + 1);
Integer result = future.get();

✅ 用于：

• 线程间传递计算结果

三、不同语言简要对比

四、如何选择？

✅ 推荐优先级

1. BlockingQueue（生产者-消费者）
2. Lock + Condition
3. CountDownLatch / CyclicBarrier
4. wait/notify（了解原理即可）
5. volatile（仅状态标志）

五、一句话总结

线程间通信 = 共享变量 + 协调机制
实战中：能用高级并发工具，就别手写 wait/notify

如果你有具体场景（如：生产者消费者、线程池、异步结果返回），我可以给你针对性示例。