生产者消费者模式（c++）

什么是生产者消费者模式？

想象一下，你早上起来肚子快饿扁了，去包子铺买包子，包子铺有三个人在做包子（也可以是一个），这些人就是生产者，你作为买包子的，你就是一个消费者，当然买包子的消费者不止你一个。这种模式就是生产者消费者模式。

在程序的世界里，经常用线程来模拟这种模式。

我们不妨将包子想象成计算机世界里面的数据，那么做包子的人就相当于生成数据的线程，买包子的人就相当消耗或者处理这些数据的线程。

模式规则及代码实现

你再想一下，如果做包子的人发现做的包子没有地方放了，他还会继续做吗？

买包子的人发现没有包子了，他还能买得着吗？

根据这两个条件，我们用队列来模拟数据存储得缓冲区（想象成装包子得容器），当队列为满得时候，生产数据的线程就不再生产数据。当队列为空得时候，消耗数据的线程就不再消耗数据。

根据上面的规则，我们要用到线程同步的一些结构：我们用代码来分析一下：

# include<iostream>
using namespace std;
# include<thread>
# include<vector>
# include<mutex>
# include<condition_variable>
# include<queue>
#include <windows.h>
//生产者数量
# define PRODUCT_SIZE 20
//消费者数量
# define CUSTOMER_SIZE 1
//最大产品数量
#define MAX_SIZE 10
//互斥锁
mutex mut;
//条件变量
condition_variable con;
//队列，模拟缓冲区
queue<int> que;
void Producter()
{
	
	while (true)
	{
		Sleep(10);
		std::unique_lock <std::mutex> lck(mut);
		while(que.size()> MAX_SIZE)
		{
			
			con.wait(lck);
		}
		int data = rand();
		 que.push(data);
		cout << this_thread::get_id() << "生产了产品：" << data<<endl;
		con.notify_all();
		
	}
}
void Customer()
{
	while (true)
	{
		std::unique_lock <std::mutex> lck(mut);
		while (que.empty())
		{
			con.wait(lck);
		}
		cout << this_thread::get_id() << "消费了产品：" << que.front() << endl;
		que.pop();
		con.notify_all();
	}
}
int main()
{
	vector<thread> threadPoll;
	//创建生产者和消费者
	for (int i = 0; i < PRODUCT_SIZE; ++i)
	{
		threadPoll.push_back(thread(Producter));
	}
	for (int i = 0; i < PRODUCT_SIZE+ CUSTOMER_SIZE; ++i)
	{
		threadPoll.push_back(thread(Customer));
	}
		

	for (int i = 0; i < PRODUCT_SIZE + CUSTOMER_SIZE; ++i)
	{
		threadPoll[i].join();
	}
	
	return 0;
}

上面是我自己实现的生产者消费者模式。

std::unique_lock <std::mutex> lck(mut);

这句代码会获取到全局的互斥锁mut，并且自动进行加锁操作。还有需要注意的是，lck作为局部变量，当一次循环介绍后，会自动调用自己的析构函数，来对锁进行解锁操作。

con.wait(lck);

这句代码，当条件成立的时候，条件变量的成员函数wait首先会对锁进行解锁操作，然后会将线程挂起（suppend），当条件变量被noty_*系列函数唤醒的时候，会将锁再次进行加锁。

还有需要注意一点：

while(que.size()> MAX_SIZE)
{
			
    con.wait(lck);
}

对于上面这个循环，有的人可能会问，能不能用if来进行条件判断，答案是不行的。这是因为:

wait操作是可以返回的，程序并不是一直运行在wait处，因此，如果将条件判断改为if，那么判断一次之后，程序会继续向下执行，会导致与预期目标不符的结果。