下面是一个使用Java实现生产者和消费者模式的简单示例：
import java.util.LinkedList;
public class ProducerConsumerExample {
public static void main(String[] args) {
Buffer buffer = new Buffer(5); // 缓冲区大小为5
Producer producer = new Producer(buffer);
Consumer consumer = new Consumer(buffer);
Thread producerThread = new Thread(producer);
Thread consumerThread = new Thread(consumer);
producerThread.start();
consumerThread.start();
}
}
class Buffer {
private LinkedList<Integer> queue;
private int capacity;
public Buffer(int capacity) {
this.capacity = capacity;
this.queue = new LinkedList<>();
}
public void produce(int item) throws InterruptedException {
synchronized (this) {
while (queue.size() == capacity) {
wait();
}
queue.add(item);
System.out.println("生产者生产了：" + item);
notify();
}
}
public void consume() throws InterruptedException {
synchronized (this) {
while (queue.isEmpty()) {
wait();
}
int item = queue.remove();
System.out.println("消费者消费了：" + item);
notify();
}
}
}
class Producer implements Runnable {
private Buffer buffer;
public Producer(Buffer buffer) {
this.buffer = buffer;
}
@Override
public void run() {
try {
for (int i = 1; i <= 10; i++) {
buffer.produce(i);
Thread.sleep(1000); // 模拟生产者生产的时间
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class Consumer implements Runnable {
private Buffer buffer;
public Consumer(Buffer buffer) {
this.buffer = buffer;
}
@Override
public void run() {
try {
for (int i = 1; i <= 10; i++) {
buffer.consume();
Thread.sleep(2000); // 模拟消费者消费的时间
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
上面的代码中，我们定义了一个Buffer类作为缓冲区，它维护一个LinkedList作为队列来存放生产者生产的数据。
生产者线程通过调用produce方法向缓冲区中添加数据，如果缓冲区已满，则生产者线程会等待，直到有空间可用并通知消费者线程。
消费者线程通过调用consume方法从缓冲区中消费数据，如果缓冲区为空，则消费者线程会等待，直到有数据可消费并通知生产者线程。
在main方法中，我们创建了一个Buffer实例，并创建生产者和消费者线程并启动它们。
运行代码后，你将会看到生产者不断地生产数据，而消费者不断地消费数据，它们之间通过缓冲区实现了同步和通信。
