生产者和消费者模型是一种常用于描述多线程操作中生产者和消费者之间关系的模型。
在该模型中，生产者负责生成数据，消费者则负责处理数据。
生产者和消费者之间通过一个缓冲区进行交互，也就是生产者将生产的数据放入缓冲区，而消费者则从缓冲区中取出数据进行处理。
这种模型的使用场景非常广泛，例如：多线程编程、异步编程、消息队列等。生产者和消费者模型可以有效地控制数据流量，避免了生产者和消费者之间的资源竞争，提高了程序的效率和稳定性。
以下是一个使用Java实现生产者和消费者模型的示例代码：
import java.util.LinkedList;
import java.util.Queue;
public class ProducerConsumerDemo {
// 队列容量
private static final int CAPACITY = 5;
// 使用 LinkedList 作为队列
private static Queue<Integer> queue = new LinkedList<>();
public static void main(String[] args) {
// 创建生产者线程和消费者线程
Thread producerThread = new Thread(new Producer());
Thread consumerThread = new Thread(new Consumer());
// 启动线程
producerThread.start();
consumerThread.start();
}
// 生产者线程
static class Producer implements Runnable {
@Override
public void run() {
int i = 0;
while (true) {
synchronized (queue) {
// 如果队列已满，则等待
while (queue.size() == CAPACITY) {
try {
System.out.println("队列已满，生产者线程等待...");
queue.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 队列未满，可以生产数据
queue.offer(i);
System.out.println("生产者生产数据：" + i);
i++;
// 通知其他线程
queue.notifyAll();
}
}
}
}
// 消费者线程
static class Consumer implements Runnable {
@Override
public void run() {
while (true) {
synchronized (queue) {
// 如果队列为空，则等待
while (queue.isEmpty()) {
try {
System.out.println("队列为空，消费者线程等待...");
queue.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 队列不为空，可以消费数据
int data = queue.poll();
System.out.println("消费者消费数据：" + data);
// 通知其他线程
queue.notifyAll();
}
}
}
}
}
在上面的示例中，定义了一个长度为5的队列作为缓冲区。生产者线程不断生产数据并将其加入队列中，如果队列已满，则等待消费者线程消费数据。消费者线程不断从队列中取出数据进行消费，如果队列为空，则等待生产者线程生产数据。通过synchronized关键字和wait/notifyAll方法来实现线程间的同步和通信，从而实现了生产者和消费者模型。
除了使用synchronized关键字和wait/notifyAll方法来实现线程同步和通信，还可以使用Java中提供的线程安全的队列类来实现生产者和消费者模型。
常用的线程安全队列类有ConcurrentLinkedQueue、ArrayBlockingQueue、LinkedBlockingQueue等。
以下是使用LinkedBlockingQueue实现生产者和消费者模型的示例代码：
package com.example.demo.produce;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class ProducerConsumerDemo2 {
private static final int CAPACITY = 5; // 队列容量
private static BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(CAPACITY); // 使用阻塞队列作为生产者和消费者之间的缓冲区
public static void main(String[] args) {
Thread producerThread = new Thread(new Producer()); // 创建生产者线程
Thread consumerThread = new Thread(new Consumer()); // 创建消费者线程
producerThread.start(); // 启动生产者线程
consumerThread.start(); // 启动消费者线程
}
static class Producer implements Runnable {
@Override
public void run() {
int i = 0;
while (true) {
try {
queue.put(i); // 将数据放入队列中，如果队列已满则阻塞
System.out.println("生产者生产数据：" + i);
i++;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
static class Consumer implements Runnable {
@Override
public void run() {
while (true) {
try {
int data = queue.take(); // 从队列中获取数据，如果队列为空则阻塞
System.out.println("消费者消费数据：" + data);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
该代码演示了一个简单的生产者-消费者模型，并使用了Java中的阻塞队列作为生产者和消费者之间的缓冲区。生产者线程不断向队列中放入数据，如果队列已满则阻塞；消费者线程不断从队列中取出数据，如果队列为空则阻塞。由于使用了阻塞队列，生产者和消费者线程不需要手动进行同步，从而简化了代码实现。
以上代码可正常运行，有疑问可以交流～～
欢迎关注公众号：程序员的思考与落地
公众号提供大量实践案例，Java入门者不容错过哦，可以交流！！
