扩展模式之生产者&消费者模式_生产者消费者设计模式-CSDN博客

Producer（生产者）：负责产生任务或数据并将其放入缓冲区（队列）中。在多线程环境中，生产者可能会因为队列已满而被阻塞，直到队列有足够空间可容纳新的数据。
Consumer（消费者）：负责从缓冲区（队列）中取出任务或数据并进行处理。在多线程环境中，消费者可能会因队列为空而被阻塞，直到队列中有数据可以消费。
Buffer（缓冲区）：缓冲区是生产者和消费者之间共享的数据结构，通常是一个队列。生产者将数据放入队列中，消费者从队列中取出数据进行处理。缓冲区的大小和同步机制是设计生产者/消费者模式时需要特别关注的问题。

通常可以考虑使用阻塞队列
Synchronizer（同步机制）：为了避免多个线程之间的资源争用，生产者和消费者必须通过同步机制来协调它们的操作。常见的同步机制包括使用锁（如 ReentrantLock）、信号量（如 Semaphore）或条件变量（如 Condition）来保证线程安全。

三、Demo示例

下面是一个基于 Java 的简单示例，演示生产者/消费者模式的实现。

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

// 缓冲区类
class Buffer<T> {
    private Queue<T> queue = new LinkedList<>();
    private int capacity;

    public Buffer(int capacity) {
        this.capacity = capacity;
    }

    public synchronized void add(T item) throws InterruptedException {
        while (queue.size() == capacity) {
            wait();  // 队列满，生产者等待
        }
        queue.add(item);
        notifyAll();  // 唤醒消费者
    }

    public synchronized T remove() throws InterruptedException {
        while (queue.isEmpty()) {
            wait();  // 队列空，消费者等待
        }
        T item = queue.poll();
        notifyAll();  // 唤醒生产者
        return item;
    }
}

// 生产者类
class Producer extends Thread {
    private Buffer<Integer> buffer;

    public Producer(Buffer<Integer> buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                buffer.add(i);
                System.out.println("Produced: " + i);
                Thread.sleep(100);  // 模拟生产过程
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

// 消费者类
class Consumer extends Thread {
    private Buffer<Integer> buffer;

    public Consumer(Buffer<Integer> buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                Integer item = buffer.remove();
                System.out.println("Consumed: " + item);
                Thread.sleep(150);  // 模拟消费过程
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

// 主类
public class ProducerConsumerDemo {
    public static void main(String[] args) {
        Buffer<Integer> buffer = new Buffer<>(5);  // 缓冲区大小为5
        Producer producer = new Producer(buffer);
        Consumer consumer = new Consumer(buffer);

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

3.1 代码解析

Buffer 类：该类实现了一个简单的缓冲区，使用 LinkedList 作为队列来存储数据。add 和 remove 方法分别负责向队列中添加和移除数据，并在操作时使用 synchronized 进行同步，确保线程安全。
Producer 类：该类模拟生产者的行为，通过 add 方法将数据加入到缓冲区。生产者每次生产一个数据后会暂停 100 毫秒，模拟生产的时间。
Consumer 类：该类模拟消费者的行为，通过 remove 方法从缓冲区取出数据进行消费。消费者每次消费一个数据后会暂停 150 毫秒，模拟消费的时间。
ProducerConsumerDemo 类：这是主类，创建一个缓冲区实例，并启动生产者和消费者线程。