Java多线程生产者消费者实现详解

编程并不是一个机械性的工作，而是需要有思考，有创新的工作，语法是固定的，但解决问题的思路则是依靠人的思维，这就需要我们坚持学习和更新自己的知识。今天golang学习网就整理分享《Java多线程生产者消费者实现方法》，文章讲解的知识点主要包括，如果你对文章方面的知识点感兴趣，就不要错过golang学习网，在这可以对大家的知识积累有所帮助，助力开发能力的提升。

使用synchronized和wait/notify实现生产者消费者模式，通过共享缓冲区协调线程：当缓冲区满时生产者等待，空时消费者等待，调用notifyAll唤醒对应线程。

在Java中实现多线程生产者消费者模式，核心是让生产者线程向共享缓冲区添加数据，消费者线程从缓冲区取出数据，同时保证线程安全和避免资源浪费。可以通过wait()、notify()或使用BlockingQueue来高效实现。

使用synchronized + wait/notify

这是基础实现方式，通过同步方法控制对共享资源的访问。

关键点：当缓冲区满时，生产者等待；当缓冲区空时，消费者等待。

定义一个共享缓冲区：

class SharedBuffer {
    private final int[] buffer;
    private int index = 0;

    public SharedBuffer(int size) {
        this.buffer = new int[size];
    }

    public synchronized void produce(int value) throws InterruptedException {
        while (index == buffer.length) {
            wait(); // 缓冲区满，生产者等待
        }
        buffer[index++] = value;
        System.out.println("生产: " + value);
        notifyAll(); // 唤醒所有等待线程（包括消费者）
    }

    public synchronized int consume() throws InterruptedException {
        while (index == 0) {
            wait(); // 缓冲区空，消费者等待
        }
        int value = buffer[--index];
        System.out.println("消费: " + value);
        notifyAll(); // 唤醒生产者
        return value;
    }
}

生产者线程：

class Producer implements Runnable {
    private final SharedBuffer buffer;

    public Producer(SharedBuffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        for (int i = 1; i 

<p>消费者线程：</p>
<pre class="brush:java;toolbar:false;">class Consumer implements Runnable {
    private final SharedBuffer buffer;

    public Consumer(SharedBuffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        for (int i = 0; i 

<p>测试运行：</p>
<pre class="brush:java;toolbar:false;">public class ProducerConsumerDemo {
    public static void main(String[] args) {
        SharedBuffer buffer = new SharedBuffer(3);
        Thread p = new Thread(new Producer(buffer));
        Thread c = new Thread(new Consumer(buffer));

        p.start();
        c.start();
    }
}

使用BlockingQueue简化实现

更推荐的方式是使用java.util.concurrent.BlockingQueue，它内部已处理了线程等待与唤醒逻辑。

优势：无需手动管理wait/notify，代码简洁且不易出错。

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

class PCUsingQueue {
    private final BlockingQueue<integer> queue = new ArrayBlockingQueue(3);

    class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 1; i 

<h3>注意事项</h3>
<p>使用<code>wait()</code>时必须配合<code>synchronized</code>，否则会抛出异常。</p>
<p>循环判断条件应使用<code>while</code>而不是<code>if</code>，防止虚假唤醒导致问题。</p>
<p><code>notifyAll()</code>比<code>notify()</code>更安全，能唤醒所有等待线程，避免死锁。</p>
<p>实际开发中优先选择<code>BlockingQueue</code>实现，如<code>ArrayBlockingQueue</code>、<code>LinkedBlockingQueue</code>等，它们是线程安全的，性能更好。</p>

基本上就这些。<p>理论要掌握，实操不能落！以上关于《Java多线程生产者消费者实现详解》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！</p></integer>