生产者消费者模型

最新推荐文章于 2022-10-23 08:45:00 发布
最新推荐文章于 2022-10-23 08:45:00 发布
阅读量517 收藏
点赞数
分类专栏： 手撕题 文章标签： java rabbitmq 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46153765/article/details/122015537
版权

生产者和消费者问题是线程模型中老生常谈的问题，也是面试中经常遇到的问题。今天我们就盘它！！！

一、生产者消费者模型

何为生产者消费者模型呢？

生产者消费者模型是由两类线程构成：

  • 生产者线程：“生产”产品，并把产品放到一个缓冲区里；
  • 消费者线程：“消费”产品。

如图所示：

小贴士：

  • 生产者持续生产，直到缓冲区满，满时阻塞；缓冲区不满后，继续生产；
  • 如果缓冲区里的产品从无到有，生产者就得通知一下消费者，告诉它可以来消费了；
  • 消费者持续消费，直到缓冲区空，空时阻塞；缓冲区不空后，继续消费；
  • 如果缓冲区里的产品从满到不满，消费者也得去通知下生产者，说你可以来生产了。

那我们自己如何实现这个生产者消费者模型呢？

方式一：使用 wait() / notify() 方式

方式二：使用 BlockingQueue 阻塞队列方式

二、wait()/notify() 方式

wait() 和 notify() 都是 Java 中的 Object 类自带的方法，可以用来实现线程间的通信

wait() 方法是用来让当前线程等待，直到有别的线程调用 notify() 将它唤醒，或者我们可以设定一个时间让它自动苏醒。

notify() 方法只能通知一个线程，如果多个线程在等待，那就唤醒任意一个。

notifyAll() 方法是可以唤醒所有等待线程，然后加入同步队列。

具体代码如下：

// 生产者
public class Producer implements Runnable {
	private volatile boolean isRunning = true;
	private final Vector sharedQueue;                            // 内存缓冲区
	private final int SIZE;                                      // 缓冲区大小
	private static AtomicInteger count = new AtomicInteger();    // 总数，原子操作
	private static final int SLEEPTIME = 1000;

	public Producer(Vector sharedQueue, int SIZE) {
		this.sharedQueue = sharedQueue;
		this.SIZE = SIZE;
	}

	@Override
	public void run() {
		int data;
		Random r = new Random();

		System.out.println("start producer id = " + Thread.currentThread().getId());
		try {
			while (isRunning) {
				// 模拟延迟
				Thread.sleep(r.nextInt(SLEEPTIME));

				// 当队列满时阻塞等待
				while (sharedQueue.size() == SIZE) {
					synchronized (sharedQueue) {
						System.out.println("Queue is full, producer " + Thread.currentThread().getId()
								+ " is waiting, size：" + sharedQueue.size());
						sharedQueue.wait();
					}
				}

				// 队列不满时持续创造新元素
				synchronized (sharedQueue) {
					data = count.incrementAndGet();					// 构造任务数据
					sharedQueue.add(data);
					System.out.println("producer create data:" + data + ", size：" + sharedQueue.size());
					sharedQueue.notifyAll();
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
			Thread.currentThread().interrupted();
		}
	}

	public void stop() {
		isRunning = false;
	}
}

// 消费者
public class Consumer implements Runnable {

	private final Vector sharedQueue;                            // 内存缓冲区
	private final int SIZE;                                      // 缓冲区大小
	private static final int SLEEPTIME = 1000;

	public Consumer(Vector sharedQueue, int SIZE) {
		this.sharedQueue = sharedQueue;
		this.SIZE = SIZE;
	}

	@Override
	public void run() {

		Random r = new Random();

		System.out.println("start consumer id = " + Thread.currentThread().getId());
		try {
			while (true) {
				// 模拟延迟
				Thread.sleep(r.nextInt(SLEEPTIME));

				// 当队列空时阻塞等待
				while (sharedQueue.isEmpty()) {
					synchronized (sharedQueue) {
						System.out.println("Queue is empty, consumer " + Thread.currentThread().getId()
								+ " is waiting, size：" + sharedQueue.size());
						sharedQueue.wait();
					}
				}

				// 队列不空时持续消费元素
				synchronized (sharedQueue) {
					System.out.println("consumer consume data：" + sharedQueue.remove(0) + ", size：" + sharedQueue.size());
					sharedQueue.notifyAll();
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
			Thread.currentThread().interrupt();
		}
	}
}


// 主线程代码
public static void main(String args[]) throws InterruptedException {
	// 1.构建内存缓冲区
	Vector sharedQueue = new Vector();
	int size = 4;

	// 2.建立线程池和线程
	ExecutorService service = Executors.newCachedThreadPool();
	Producer prodThread1 = new Producer(sharedQueue, size);
	Producer prodThread2 = new Producer(sharedQueue, size);
	Producer prodThread3 = new Producer(sharedQueue, size);
	Consumer consThread1 = new Consumer(sharedQueue, size);
	Consumer consThread2 = new Consumer(sharedQueue, size);
	Consumer consThread3 = new Consumer(sharedQueue, size);
	service.execute(prodThread1);
	service.execute(prodThread2);
	service.execute(prodThread3);
	service.execute(consThread1);
	service.execute(consThread2);
	service.execute(consThread3);

	// 3.睡一会儿然后尝试停止生产者
	Thread.sleep(10 * 1000);
	prodThread1.stop();
	prodThread2.stop();
	prodThread3.stop();

	// 4.再睡一会儿关闭线程池
	Thread.sleep(3000);
	service.shutdown();
}

// 执行结果
start producer id = 13
start consumer id = 16
start consumer id = 17
start producer id = 12
start consumer id = 15
start producer id = 14
producer create data:1, size：1
producer create data:2, size：2
consumer consume data：1, size：1

我们解释一下上面的代码吧

  • 创造数据：生产者-消费者解决的问题就是数据在多线程间的共享，所以我们首要关心的问题就应该是数据，我们这里采用的是使用一个AtomicInteger类来为我们创造数据，使用它的好处是该类是一个保证原子操作的类，我们使用其中的incrementAndGet()方法不仅能够保证线程安全，还可以达到一个计数的效果，所以是一个既简单又实用的选择，当然也可以使用其他的数据来代替，这里注意的是要保证该类在内存中只存在一份，使用static修饰；
  • 内存缓冲区：要保证在多线程环境下内存缓冲区的安全，所以我们考虑使用简单的Vector类来作为我们的内存缓冲区，并且使用final修饰保证内存缓冲区的唯一，然后的话我们需要判断队列是否满，需要手动添加一个标识缓冲区大小的变量SIZE，注意也是final修饰；
  • 模拟延迟：这里主要模拟的是一个网络延迟，我们首先定义了一个SLEEPTIME的延迟范围，注意使用的是static final修饰，然后使用Random()类的nextInt()方法来随机选取一个该范围内的值来模拟网络环境中的延迟；
  • 停止方法：首先需要知道在Thread类中有一个弃用的stop()方法，我们自己增加一个标志位isRunning来完成我们自己的stop()功能，需要注意的是使用volatile来修饰，保证该标志位的可见性；
  • 错误处理：当捕获到错误时，我们应该使用Thread类中的interrupted()方法来终止当前的进程；
  • 消息提示：我们主要是要在控制台输出该生产者的信息，包括当前队列的状态，大小，当前线程的生产者信息等，注意的是信息格式的统一；

三、 BlockingQueue 阻塞队列方式

大家还是直接看代码吧：

public class Producer implements Runnable {
	private volatile boolean isRunning = true;
	private BlockingQueue<Integer> queue;                        // 内存缓冲区
	private static AtomicInteger count = new AtomicInteger();    // 总数，原子操作
	private static final int SLEEPTIME = 1000;

	public Producer(BlockingQueue<Integer> queue) {
		this.queue = queue;
	}

	@Override
	public void run() {
		int data;
		Random r = new Random();

		System.out.println("start producer id = " + Thread.currentThread().getId());
		try {
			while (isRunning) {
				// 模拟延迟
				Thread.sleep(r.nextInt(SLEEPTIME));

				// 往阻塞队列中添加数据
				data = count.incrementAndGet();               	// 构造任务数据
				System.out.println("producer " + Thread.currentThread().getId() + " create data：" + data
						+ ", size：" + queue.size());
				if (!queue.offer(data, 2, TimeUnit.SECONDS)) {
					System.err.println("failed to put data：" + data);
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
			Thread.currentThread().interrupted();
		}
	}

	public void stop() {
		isRunning = false;
	}
}


public class Consumer implements Runnable {

	private BlockingQueue<Integer> queue;                            // 内存缓冲区
	private static final int SLEEPTIME = 1000;

	public Consumer(BlockingQueue<Integer> queue) {
		this.queue = queue;
	}

	@Override
	public void run() {

		int data;
		Random r = new Random();

		System.out.println("start consumer id = " + Thread.currentThread().getId());
		try {
			while (true) {
				// 模拟延迟
				Thread.sleep(r.nextInt(SLEEPTIME));

				// 从阻塞队列中获取数据
				if (!queue.isEmpty()) {
					data = queue.take();
					System.out.println("consumer " + Thread.currentThread().getId() + " consume data：" + data
							+ ", size：" + queue.size());
				} else {
					System.out.println("Queue is empty, consumer " + Thread.currentThread().getId()
							+ " is waiting, size：" + queue.size());
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
			Thread.currentThread().interrupt();
		}
	}
}


public static void main(String args[]) throws InterruptedException {
	// 1.构建内存缓冲区
	BlockingQueue<Integer> queue = new LinkedBlockingDeque<>();

	// 2.建立线程池和线程
	ExecutorService service = Executors.newCachedThreadPool();
	Producer prodThread1 = new Producer(queue);
	Producer prodThread2 = new Producer(queue);
	Producer prodThread3 = new Producer(queue);
	Consumer consThread1 = new Consumer(queue);
	Consumer consThread2 = new Consumer(queue);
	Consumer consThread3 = new Consumer(queue);
	service.execute(prodThread1);
	service.execute(prodThread2);
	service.execute(prodThread3);
	service.execute(consThread1);
	service.execute(consThread2);
	service.execute(consThread3);

	// 3.睡一会儿然后尝试停止生产者
	Thread.sleep(10 * 1000);
	prodThread1.stop();
	prodThread2.stop();
	prodThread3.stop();

	// 4.再睡一会儿关闭线程池
	Thread.sleep(3000);
	service.shutdown();
}

// 运行结果
start producer id = 13
start consumer id = 15
start consumer id = 16
start producer id = 14
start producer id = 12
start consumer id = 17
Queue is empty, consumer 16 is waiting, size：0
Queue is empty, consumer 16 is waiting, size：0
Queue is empty, consumer 16 is waiting, size：0
Queue is empty, consumer 16 is waiting, size：0
producer 13 create data：1, size：0
consumer 15 consume data：1, size：0
producer 12 create data：2, size：0

好了，手撕阻塞队列就讲到这里了！！！我们下期见

引用：

https://www.cnblogs.com/wmyskxz/p/9538177.html#_label0

https://segmentfault.com/a/1190000024444906

https://segmentfault.com/a/1190000018169793?utm_source=sf-similar-article

skier~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java基于Lock的生产者消费者模型示例
08-27
主要介绍了Java基于Lock的生产者消费者模型,结合实例形式分析了java基于锁机制的生产者消费者模型相关实现与使用技巧,需要的朋友可以参考下
Java实现简易生产者消费者模型过程解析
08-19
主要介绍了Java实现简易生产者消费者模型过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Qt入门练习项目——生产者消费者模型.zip
08-01
Qt入门练习项目——生产者消费者模型 Qt入门练习项目源码，通过本项目从而了解Qt，进行一个简单的入门。 本文件是对应项目源码，希望多多交流。
python之生产者消费者模型实现详解
09-18
主要介绍了python之生产者消费者模型实现详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
共享队列ShareQueue
renyisheng的专栏
08-14 1161
public class SharedQueue { class Node { Object task; Node next; Node(Object task) { this.task = task; next = null; } } private Node head = new Node(null); private Node last = he
生产者-消费者模型
一江溪水
11-20 6770
什么是生产者消费者模型 生产者 - 消费者模型（ Producer-consumer problem） 是一个非常经典的多线程并发协作的模型，在分布式系统里非常常见。 这个模型由两类线程和一个缓冲区组成来组成 生产者线程：生产数据，并把数据放在这个队列里面 缓冲区：存放生产者的数据的地方 消费者线程：从队列里面取数据，消费数据 运行流程 生产者和消费者在同一时间段内共用同一个存储空间 生产者往存储空间中添加产品 消费者从存储空间中取走产品 当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。
生产者消费者模型详解
小赵小赵福星高照的博客
04-06 8872
生产者消费者模型 文章目录生产者消费者模型什么是生产者消费者模型基于BlockingQueue的生产者消费者模型单生产者单消费者模型多生产者多消费者模型 什么是生产者消费者模型 生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者
生产者与消费者模型
m0_63020222的博客
10-23 432
基于阻塞队列、互斥锁，条件变量和基于环形队列、信号量，两种方式实现生产者与消费者模型
操作系统 —— 生产者消费者模型
lyzzs222的博客
10-09 2901
生产者消费者模型，生产者消费者无非是几个线程，关键是支持它们之间的场所如何实现？我给出三种实现方式：阻塞队列，环形队列，线程池。
理解生产者消费者模型及在Python编程中的运用实例
12-25
什么是生产者消费者模型 在 工作中，大家可能会碰到这样一种情况：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产 生数据的模块，就形象地称为...
queue线程安全
zidian666的博客
02-08 1576
queue非线程安全 大佬封装成线程安全的，接口与原<queue>一致，但无法拷贝（锁） #pragma once #include <queue> #include <mutex> #include <condition_variable> template <typename T> class SharedQueue { public: SharedQueue(); ~SharedQueue(); T &am
java生产者消费者模型
有个疙叫瘩儿的博客
12-14 4836
前言 生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。 基于synchronized配合wait()和notify()方法的实现 这也是最简单最基础的实现，缓冲区满和为空时都调用wait()方法等待，当生产者生产了一个产品或者消费者消费了一个产品之后会唤醒所有线程。 public class Test...
【C++】【设计模式之】生产者-消费者模型(理论讲解及实现)
格物致知
07-12 8322
一、什么是生产者-消费者模型 1、简单理解生产者-消费者模型 假设有两个进程（或线程）A、B和一个固定大小的缓冲区，A进程生产数据放入缓冲区，B进程从缓冲区中取出数据进行计算，这就是一个简单的生产者-消费者模型。这里的A进程相当于生产者，B进程相当于消费者。 2、为什么要使用生产者-消费者模型 在多线程开发中，如果生产者生产数据的速度很快，而消费者消费数据的速度很慢，那么生产者就必须等待消费者消费完数据才能够继续生产数据，因为生产过多的数据可能会导致存储不足；同理如果消费者的速度大于生产者那么消费者就会经常
多线程设计模式:生产者-消费者
念念不忘，必有回响
09-03 2830
生产者，消费者：就好比厨师和食客，我们来看代码理解一下 https://www.cnblogs.com/xiaoxi/p/7910868.html https://www.jianshu.com/p/71a5089afe13
生产者消费者模型的实现(线程通信)
m0_60264772的博客
01-13 2556
目录 实现一： 实现二： 实现一： package com.atguigu.juc; import java.util.LinkedList; public class ProductConsumerTest2 { public static void main(String[] args) { MessageQueue messageQueue = new MessageQueue(3); for (int i = 0; i <= 3......
介绍生产者消费者模型
最新发布
02-24
生产者消费者模型是一种常见的并发编程模型，用于解决多线程环境下的生产者和消费者之间的协作问题。在该模型中，生产者负责生成数据并将其放入共享的缓冲区，而消费者则负责从缓冲区中取出数据进行处理。 以下是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值