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

各位小伙伴们，大家好呀！看看今天我又给各位带来了什么文章？本文标题是《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学习网公众号，带你了解更多关于的知识点！