学习笔记：生产者和消费者模型

睡不着的苏东坡

已于 2023-09-24 20:10:28 修改

阅读量68

点赞数

文章标签：学习笔记

于 2023-09-23 14:44:54 首次发布

本文链接：https://blog.csdn.net/qq_74861634/article/details/133204012

版权

引入：现在有A，B两家蛋糕店，A家店主就比较节省，他们家没有柜台，每次A店主做完蛋糕都手提着蛋糕站在门口等待顾客领取，顾客取走后，A店主才能接着做下一个蛋糕。而B店里面有一个柜台，每次B店主做完蛋糕就把它放在柜台上，顾客可以直接从柜台上取走，如果柜台上已经放满了蛋糕，B店主就开始休息了，等有顾客购买蛋糕之后，B店长就继续开始工作；当然，如果柜台上的蛋糕被买完了，前往B店的顾客就得等等咯

什么是生产者—消费者模型

现在有两个进程C和D，他们共享一个固定大小的缓冲区，C进程产生数据，并将数据存入缓冲区；D进程从缓冲区中取出数据进行计算，其中：C进程就是生产者，D进程就是消费者。

为什么要使用生产者—消费者模型

在多线程开发中，如果生产者的生产速度过快，而消费者的消费速度很慢，就会导致生产者必须等待消费者消费完数据之后才能继续生产；反之，如果消费者消费速度远大于生产者生产速度，消费者就必须等待生产者生产数据，就比如引言中所提到的A店主。为了实现生产和消费之间的平衡，所以引入了生产者—消费者模型

生产者—消费者模型的特点

1、以缓冲区作为媒介，使得生产者和消费者之间没有了直接的联系，生产者不会在缓冲区满的时候继续生产，消费者也不会在缓冲区空的时候消费；

2、当缓冲区满的时候，生产者会进入休眠模式，当下次消费者开始从缓冲区中消耗数据时，生产者被唤醒，继续生产；当缓冲区空的时候，消费者进入休眠模式，当下次生产者开始向缓冲区添加数据时，消费者被唤醒，开始消费。

生产者-消费者模式的优点

解耦：将生产者类和消费者类进行解耦，消除代码之间的依赖性，简化工作负载的管理
复用：通过将生产者类和消费者类独立开来，那么可以对生产者类和消费者类进行独立的复用与扩展
调整并发数：由于生产者和消费者的处理速度是不一样的，可以调整并发数，给予慢的一方多的并发数，来提高任务的处理速度
异步：对于生产者和消费者来说能够各司其职，生产者只需要关心缓冲区是否还有数据，不需要等待消费者处理完；同样的对于消费者来说，也只需要关注缓冲区的内容，不需要关注生产者，通过异步的方式支持高并发，将一个耗时的流程拆成生产和消费两个阶段，这样生产者因为执行put()的时间比较短，而支持高并发
支持分布式：生产者和消费者通过队列进行通讯，所以不需要运行在同一台机器上，在分布式环境中可以通过redis的list作为队列，而消费者只需要轮询队列中是否有数据。同时还能支持集群的伸缩性，当某台机器宕掉的时候，不会导致整个集群宕掉。

实现生产者—消费者模型

在实现生产者-消费者模式之前我们需要搞清两个问题：

如何保证容器中数据状态的一致性
如何保证消费者和生产者之间的同步和协作关系

（1）容器中数据状态的一致性：当一个consumer执行了take()方法之后，此时容器为空，但是还没来得及更新容器的size,那么另外一个consumer来了之后以为size不等于0，那么继续执行take(),从而造成了了状态的不一致性

（2）为了保证当容器里面没有数据的时候，消费者不会继续take，此时消费者释放锁，处于阻塞状态；并且一旦生产者添加了一条数据之后，此时重新唤醒消费者，消费者重新获取到容器的锁，继续执行take();

当容器里面满的时候，生产者也不会继续put, 此时生产者释放锁，处于阻塞状态；一旦消费者take了一条数据，此时应该唤醒生产者重新获取到容器的锁，继续put

所以对于该容器的任何访问都需要进行同步，也就是说在获取容器的数据之前，需要先获取到容器的锁。

c++代码实现生产者—消费者模型

#include<iostream>
#include<queue>
#include<mutex>
#include<thread>
#include<vector>
#include<atomic>
#include<condition_variable>

using namespace std;

//重新封装queue   使得每次操作时都进行上锁操作
template<typename T>
class Safe_Queue {
private:
	mutex m_mutex;
	queue<T> m_queue;

public:
	Safe_Queue() = default;

	~Safe_Queue() = default;

	Safe_Queue& operator=(const Safe_Queue& other) = delete;

	Safe_Queue(Safe_Queue&& other) = delete;

	Safe_Queue& operator=(const Safe_Queue&& other) = delete;

	Safe_Queue(const Safe_Queue&& other) = delete;

	bool empty() {
		unique_lock<mutex> locker(m_mutex);
		return m_queue.empty();
	}

	int size() {
		unique_lock<mutex> locker(m_mutex);
		return m_queue.size();
	}

	void push(T& value) {
		unique_lock<mutex> locker(m_mutex);
		m_queue.emplace(value);
	}

	void push(T&& value) {
		unique_lock<mutex> locker(m_mutex);
		m_queue.emplace(move(value));
	}

	bool pop(T& value) {
		unique_lock<mutex> locker(m_mutex);
		if (m_queue.empty()) {
			return false;
		}
		else {
			value = move(m_queue.front());
			m_queue.pop();
			return true;
		}
	}
};

template<typename T>
class ProducerConsumer {
public:
	ProducerConsumer() {
		m_QueueMaxSize = 10;         //队列的大小
		m_ProducerThreads = 2;       //生产者线程数
		m_ConsumerThreads = 2;       //消费者线程数

		m_RunningStatus = true;

		intialize();
	}

	ProducerConsumer(int m_QueueMaxSize, int Num_ProducerThreads, int Num_ConsumerThreads):
		m_QueueMaxSize(m_QueueMaxSize), m_ProducerThreads(Num_ProducerThreads), m_ConsumerThreads(Num_ConsumerThreads)
	{
		m_RunningStatus = true;

		intialize();
	}

	~ProducerConsumer() {
		m_RunningStatus = false;

		m_QueueNotFullCV.notify_all();
		m_QueueNotEmptyCV.notify_all();

	}

private:
	Safe_Queue<T> m_Queue;
	int m_QueueMaxSize;

	condition_variable m_QueueNotFullCV;      //非满条件变量
	condition_variable m_QueueNotEmptyCV;     //非空条件变量

	vector<thread> m_ProducerThreads;         //生产者线程容器
	vector<thread> m_ConsumerThreads;         //消费者线程容器

	mutex m_mutex;                            //互斥量

	atomic<bool> m_RunningStatus;             //原子变量
	
	//生成生产者和消费者线程
	void intialize() {
		for (size_t i = 0; i < m_ProducerThreads.size(); i++) {
			m_ProducerThreads[i] = thread(&ProducerConsumer::Producer, this);
		}

		for (size_t i = 0; i < m_ConsumerThreads.size(); i++) {
			m_ConsumerThreads[i] = thread(&ProducerConsumer::Consumer, this);
		}
	}

	//判断队列是否为满
	bool isFull() {
		if (m_Queue.size() >= m_QueueMaxSize) {
			return true;
		}
		return false;
	}

	//生产者
	void Producer() {
		while (m_RunningStatus) {
			unique_lock<mutex> locker(m_mutex);         //上锁保护该进程

			if (isFull()) {
				cout << "Queue is full:waiting for m_QueueNotFullCV " << endl;
				m_QueueNotFullCV.wait(locker);          //等待队列不满来唤醒生产者线程
			}
			if (!isFull()) {
				T value = 3;
				m_Queue.push(value);                    //存入数据
				m_QueueNotEmptyCV.notify_one();         //激活非空条件变量
			}
		}
	}

	void Consumer() {
		while (m_RunningStatus) {
			unique_lock<mutex> locker(m_mutex);         //上锁保护该进程

			if (m_Queue.empty()) {
				cout << "Queue is empty:waiting for m_QueueNotEmptyCV " << endl;
				m_QueueNotEmptyCV.wait(locker);         //等待队列不为空来唤醒消费者线程
			}
			if (!m_Queue.empty()) {
				T value;
				bool result = m_Queue.pop(value);       //从队列中取出元素
				value++;
				cout << value << endl; 

				m_QueueNotFullCV.notify_one();          //激活非满条件变量
			}
		}
	}
};

int main() {
	ProducerConsumer<int> a(100, 6, 6);

	while (true) {}
	return 0;
}

参考文章：

经典并发同步模式：生产者-消费者设计模式_消费端设计端生产端数据链_kingmax54212008的博客-CSDN博客