当前位置：首页 > 文章列表 > 文章 > java教程 > Java多线程通信与生产者消费者模型解析

Java多线程通信与生产者消费者模型解析

2026-01-28 18:18:34 0浏览收藏

哈喽！今天心血来潮给大家带来了《Java多线程通信与生产者消费者模型详解》，想必大家应该对文章都不陌生吧，那么阅读本文就都不会很困难，以下内容主要涉及到，若是你正在学习文章，千万别错过这篇文章~希望能帮助到你！

Java多线程通信应使用wait()/notify()或Lock+Condition配合共享状态，而非while(true)+sleep；因后者浪费CPU、响应延迟高、易错过唤醒，且无法精准定向通知。

Java多线程中如何实现线程通信_生产者消费者模型讲解

Java 多线程中实现线程通信，核心不是靠“手动轮询”或“sleep 等待”，而是用 wait() / notify() 或更可靠的 Lock + Condition，配合共享状态（如队列）来协调生产与消费节奏。

为什么不能直接用 while(true) + sleep 模拟等待？

这种做法浪费 CPU、响应延迟高、无法精准唤醒——比如消费者刚睡着，生产者就塞进新数据，只能等下一轮醒来才发现，还可能错过唤醒信号。

真正有效的通信必须满足：等待时释放锁、被唤醒时重新竞争锁、唤醒动作能定向通知（而非广播惊群）。

wait() 必须在 synchronized 块内调用，且会释放当前对象锁
notify() 只唤醒一个等待线程，但不保证是消费者；notifyAll() 更稳妥（尤其多个生产/消费者时）
每次 wait() 返回后，必须重新检查条件（用 while 而非 if），防止虚假唤醒

用 synchronized + wait/notify 实现基础版

适用于简单场景，共享一个 ArrayList 或计数器，通过同一把锁（如 this 或队列对象）协调。

public class SimplePC {
    private final List<String> buffer = new ArrayList<>();
    private final int capacity = 5;

    public void produce(String item) throws InterruptedException {
        synchronized (this) {
            while (buffer.size() == capacity) {
                this.wait(); // 满了就等
            }
            buffer.add(item);
            System.out.println("Produced: " + item);
            this.notifyAll(); // 通知所有等待者（包括可能的消费者）
        }
    }

    public String consume() throws InterruptedException {
        synchronized (this) {
            while (buffer.isEmpty()) {
                this.wait(); // 空了就等
            }
            String item = buffer.remove(0);
            System.out.println("Consumed: " + item);
            this.notifyAll(); // 通知生产者可以继续
            return item;
        }
    }
}

⚠️ 注意：notifyAll() 是必须的；如果只用 notify()，在多消费者场景下可能唤醒另一个消费者，导致生产者永远没人通知。

用 ReentrantLock + Condition 实现更灵活控制

当需要区分“生产等待队列”和“消费等待队列”时（比如避免 notifyAll 唤醒错角色），Condition 是唯一选择。

一个 Lock 可绑定多个 Condition，例如 notFull 和 notEmpty
await() 对应 wait()，signal() 对应 notify()，signalAll() 对应 notifyAll()
必须显式 lock().unlock()，推荐用 try-finally 保证释放

public class LockBasedPC {
    private final Lock lock = new ReentrantLock();
    private final Condition notEmpty = lock.newCondition();
    private final Condition notFull = lock.newCondition();
    private final List<String> buffer = new ArrayList<>();
    private final int capacity = 5;

    public void produce(String item) throws InterruptedException {
        lock.lock();
        try {
            while (buffer.size() == capacity) {
                notFull.await(); // 等待“不满”条件
            }
            buffer.add(item);
            notEmpty.signal(); // 唤醒一个消费者
        } finally {
            lock.unlock();
        }
    }

    public String consume() throws InterruptedException {
        lock.lock();
        try {
            while (buffer.isEmpty()) {
                notEmpty.await(); // 等待“非空”条件
            }
            String item = buffer.remove(0);
            notFull.signal(); // 唤醒一个生产者
            return item;
        } finally {
            lock.unlock();
        }
    }
}