C++多线程之生产者-消费者模型

/**
 * 生产者-消费者模型
 * 定义一个产品类型，和产品仓库，定义生产者和消费者
 * 生产者生产产品并存入仓库，消费者从仓库取出产品并消耗
 * 仓库满时，生产者停止生产，仓库空时，消费者停止消费
 * 存入产品时计数加一，取出产品时计数减一
 * 生产和消费需要时间
 */
#include <iostream>
#include <condition_variable>
#include <mutex>
#include <thread>
#include <chrono>
#include <queue>
#include <atomic>

using namespace std;

//定义任意一个产品类型
struct Product {
	int prod_value;
};

const int MAX_SIZE = 10; //仓库最大容量
queue<Product> ware_house; 

std::atomic<int> prod_index = 0; //产品编号
std::atomic<int> prod_count = 0; //仓库产品数量

mutex condition_mutex; //仓库互斥量
condition_variable produce_buffer; //条件变量

bool is_producing{ true };
bool is_consuming{ true };

void Producer(const int producer_time) {
	while (is_producing) {

		prod_index++;
		Product prod{ prod_index }; //准备产品

		//创建信号量，对资源加锁
		unique_lock<mutex> lk(condition_mutex);
		produce_buffer.wait(lk, [] {                   //条件变量等待信号，阻塞线程
			return prod_count < MAX_SIZE;              //满足期望时返回
		});
		
		//获得仓库所有权，产品放入仓库
		ware_house.push(prod);
		prod_count++;
		cout << "Producer --> product " << prod_index  
			 << " inventory " << prod_count << endl;

		produce_buffer.notify_all(); //通知所有等待的条件变量
		lk.unlock(); //解除对资源的锁定

		//生产技能冷却
		std::this_thread::sleep_for(std::chrono::seconds(producer_time));
	}
}

void Consumer(const int consumer_time) {
	while (is_consuming) {
		
		//创建信号量，对资源加锁
		unique_lock<mutex> lk(condition_mutex);
		produce_buffer.wait(lk, [] {              //等待信号，阻塞线程
			return !ware_house.empty();           //仓库不为空时返回 
		});

		//获得仓库所有权，取出产品
		Product prod = ware_house.front();
		ware_house.pop();
		prod_count--;
		cout << "Consumer --> product " << prod.prod_value 
			 << " inventory " << prod_count << endl;

		produce_buffer.notify_all(); //通知所有等待的条件变量
		lk.unlock(); //解除对资源的锁定

		//消费技能冷却
		std::this_thread::sleep_for(std::chrono::seconds(consumer_time));
	}
}

int main() {
	thread producer(Producer, 1);  //创建生产者线程，设置生产时间
	thread consumer(Consumer, 2);  //创建消费者线程，设置消费时间

	producer.join();
	consumer.join();
	return 0;
}