【846、手写生产者消费者模型 写完之后并进行讲解 】

当创建多线程应用程序时，生产者-消费者模型是一个常见的并发模式，用于协调一个或多个生产者线程和一个或多个消费者线程，以便安全地共享有限的资源，如缓冲区。下面是一个用Java编写的简单生产者-消费者模型的示例：

import java.util.LinkedList;

class SharedBuffer {
    private LinkedList<Integer> buffer = new LinkedList<>();
    private int capacity;

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

    public void produce(int value) throws InterruptedException {
        synchronized (this) {
            while (buffer.size() == capacity) {
                wait();
            }

            buffer.add(value);
            System.out.println("Produced: " + value);
            notifyAll();
        }
    }

    public int consume() throws InterruptedException {
        synchronized (this) {
            while (buffer.isEmpty()) {
                wait();
            }

            int value = buffer.removeFirst();
            System.out.println("Consumed: " + value);
            notifyAll();
            return value;
        }
    }
}

class Producer implements Runnable {
    private SharedBuffer buffer;

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

    @Override
    public void run() {
        try {
            for (int i = 1; i <= 10; i++) {
                buffer.produce(i);
                Thread.sleep(1000); // Simulate production time
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

class Consumer implements Runnable {
    private SharedBuffer buffer;

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

    @Override
    public void run() {
        try {
            for (int i = 1; i <= 10; i++) {
                int value = buffer.consume();
                Thread.sleep(1500); // Simulate consumption time
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

public class ProducerConsumerExample {
    public static void main(String[] args) {
        SharedBuffer buffer = new SharedBuffer(5);

        Thread producerThread = new Thread(new Producer(buffer));
        Thread consumerThread = new Thread(new Consumer(buffer));

        producerThread.start();
        consumerThread.start();

        try {
            producerThread.join();
            consumerThread.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

这个示例中包含以下几个关键部分：

1. SharedBuffer 类表示共享的缓冲区，内部使用 LinkedList 实现。它有两个方法 produce 和 consume，分别用于生产和消费数据。
2. Producer 类实现了生产者线程，调用 buffer.produce 来将数据添加到缓冲区。
3. Consumer 类实现了消费者线程，调用 buffer.consume 来从缓冲区中取出数据。
4. 在 main 方法中，创建了一个 SharedBuffer 实例，然后创建了一个生产者线程和一个消费者线程，并启动它们。

在生产者和消费者之间，通过synchronized关键字来保证对共享资源的安全访问。wait 和 notifyAll 方法用于在缓冲区满或空时进行线程的等待和唤醒。