Java并发编程 - 生产者和消费者

用心去追梦

于 2024-08-17 10:00:06 发布

阅读量208

点赞数 2

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_33240556/article/details/141276220

版权

生产者-消费者模型是解决多线程并发问题的一种经典模式。这种模式描述了一种多线程之间的协作形式，其中一个或多个线程负责生产数据（生产者），而另一个或多个线程负责消费这些数据（消费者）。生产者和消费者通过一个共享的数据结构（如队列）进行通信，从而实现解耦合。

基本原理

生产者-消费者模型的核心思想在于将生产和消费的过程分离，这样可以实现更好的解耦和资源利用。通常情况下，生产者和消费者之间通过一个缓冲区（如队列）进行交互。当生产者产生数据时，会将数据放入缓冲区；而消费者则从缓冲区取出数据进行处理。为了确保数据的一致性和线程安全，通常需要使用同步机制来控制对缓冲区的访问。

实现方式

在Java中，实现生产者-消费者模型有多种方式，下面是一些常见的实现方法：

使用synchronized关键字
- 使用synchronized关键字来同步对共享数据结构的访问。
- 使用wait()和notify()或notifyAll()来实现线程间的同步。
使用java.util.concurrent包中的工具
- 使用BlockingQueue作为共享队列。
- 使用ExecutorService和Callable来管理生产者和消费者的线程。
使用ReentrantLock和Condition
- 使用ReentrantLock来替代synchronized关键字。
- 使用Condition来替代wait()和notify()方法。

示例代码

下面是一个简单的生产者-消费者模型实现示例，使用BlockingQueue和ExecutorService来管理生产者和消费者线程。

使用`BlockingQueue`

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ProducerConsumerExample {

    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10); // 创建一个容量为10的队列
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 创建生产者
        executor.submit(() -> {
            for (int i = 0; i < 100; i++) {
                try {
                    queue.put(i); // 生产数据
                    System.out.println("Produced: " + i);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        // 创建消费者
        executor.submit(() -> {
            for (int i = 0; i < 100; i++) {
                try {
                    Integer value = queue.take(); // 消费数据
                    System.out.println("Consumed: " + value);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        // 关闭线程池
        executor.shutdown();
    }
}

在这个例子中，我们创建了一个LinkedBlockingQueue作为生产者和消费者之间的缓冲区。put()方法用于生产数据，而take()方法用于消费数据。这两个方法都是阻塞的，即如果队列满了，put()会阻塞，直到有空间可用；同样，如果队列为空，take()也会阻塞，直到有数据可用。

使用`synchronized`和`wait/notify`

另一种实现方式是使用synchronized关键字和wait()/notify()方法。这种方式需要手动管理同步和唤醒机制，如下所示：

import java.util.LinkedList;
import java.util.Queue;

public class ProducerConsumerExample {

    private Queue<Integer> queue = new LinkedList<>();
    private final int capacity = 10;

    public synchronized void produce(int value) throws InterruptedException {
        while (queue.size() == capacity) {
            wait(); // 队列已满，等待
        }
        queue.add(value);
        System.out.println("Produced: " + value);
        notifyAll(); // 通知消费者队列中有新元素
    }

    public synchronized Integer consume() throws InterruptedException {
        while (queue.isEmpty()) {
            wait(); // 队列为空，等待
        }
        Integer value = queue.remove();
        System.out.println("Consumed: " + value);
        notifyAll(); // 通知生产者队列中有空位
        return value;
    }

    public static void main(String[] args) throws InterruptedException {
        ProducerConsumerExample example = new ProducerConsumerExample();

        // 创建生产者线程
        Thread producer = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                try {
                    example.produce(i);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        // 创建消费者线程
        Thread consumer = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                try {
                    example.consume();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        producer.start();
        consumer.start();

        producer.join();
        consumer.join();
    }
}