Java生产者消费者模式实现解析

本文详解Java中实现生产者消费者模式的两种核心方法，解决多线程环境下生产与消费速度不匹配的问题。首先，深入讲解如何利用`wait()`和`notify()`方法，结合`synchronized`关键字实现线程间的协作与同步，手动控制缓冲区状态。其次，重点介绍更简洁高效的`BlockingQueue`接口，它由Java并发包提供，内置线程安全和阻塞机制，自动处理队列满/空的阻塞，避免手动管理锁，大幅简化代码。相比之下，`BlockingQueue`是开发中的首选方案，而`wait/notify`更适合学习底层原理或定制化需求。通过本文，开发者可以掌握生产者消费者模式的Java实现，提升并发编程能力。

生产者消费者模式通过共享缓冲区协调生产与消费速度，Java中可用wait/notify或BlockingQueue实现。前者需手动同步控制，后者由并发包自动处理阻塞与线程安全，更简洁高效。

生产者消费者模式是多线程编程中常见的设计模式，用于解决生产数据和消费数据速度不匹配的问题。在Java中，可以通过多种方式实现该模式，核心目标是保证线程安全、避免资源竞争，并实现线程间的有效通信。

使用 wait() 和 notify()

这是最基础的实现方式，依赖 synchronized 配合 wait() 和 notify() 方法进行线程协作。

定义一个共享缓冲区（例如队列），生产者线程向其中添加数据，消费者线程从中取出数据。当缓冲区满时，生产者等待；当缓冲区空时，消费者等待。

示例代码：

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

    public synchronized void put(int value) {
        while (available) {
            try {
                wait(); // 缓冲区已占用，生产者等待
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        data = value;
        available = true;
        notifyAll(); // 唤醒消费者
    }

    public synchronized int take() {
        while (!available) {
            try {
                wait(); // 缓冲区为空，消费者等待
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        available = false;
        notifyAll(); // 唤醒生产者
        return data;
    }
}

创建生产者和消费者线程分别调用 put() 和 take() 方法即可。

使用 BlockingQueue

Java 并发包提供了 BlockingQueue 接口及其实现类（如 ArrayBlockingQueue、LinkedBlockingQueue），它内部已封装了线程安全和阻塞逻辑，是最推荐的方式。

BlockingQueue 的 put() 方法在队列满时自动阻塞，take() 方法在队列空时自动阻塞，无需手动管理锁和等待通知。

示例代码：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;

class Producer implements Runnable {
    private final BlockingQueue<integer> queue;

    public Producer(BlockingQueue<integer> queue) {
        this.queue = queue;
    }

    public void run() {
        try {
            for (int i = 0; i  queue;

    public Consumer(BlockingQueue<integer> queue) {
        this.queue = queue;
    }

    public void run() {
        try {
            while (true) {
                Integer value = queue.take();
                System.out.println("消费者消费: " + value);
                Thread.sleep(200); // 模拟消费耗时
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}
</integer></integer></integer>

主程序中启动多个生产者和消费者线程即可：

public class ProducerConsumerDemo {
    public static void main(String[] args) {
        BlockingQueue<integer> queue = new ArrayBlockingQueue(5);
        Thread producer = new Thread(new Producer(queue));
        Thread consumer = new Thread(new Consumer(queue));

        producer.start();
        consumer.start();
    }
}
</integer>

使用 Lock 和 Condition

如果需要更细粒度的控制，可以使用 ReentrantLock 配合 Condition 实现 await() 和 signal()，效果类似于 wait()/notify()，但更灵活。

你可以为“非满”和“非空”分别创建不同的 Condition，从而只唤醒特定类型的线程，提升效率。

关键点：

• 使用 lock.lock() 和 lock.unlock() 控制临界区
• condition.await() 替代 wait()
• condition.signalAll() 替代 notifyAll()

这种方式适合复杂场景，但日常开发中推荐优先使用 BlockingQueue。

基本上就这些。BlockingQueue 是最简洁高效的实现方式，适合绝大多数情况。wait/notify 和 Lock/Condition 更适合学习原理或定制需求。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《Java生产者消费者模式实现解析》文章吧，也可关注golang学习网公众号了解相关技术文章。