C++11实现生产者消费者问题

#include <windows.h>
#include <iostream>
#include <cstdlib>
#include <mutex>
#include <thread>
#include <condition_variable>
const int bufferSize=10;
struct ItemRepository
{
	int item_buffer[bufferSize];
	int write_pos;  //current position of producer
	int read_pos;   //current position of consumer
	std::condition_variable not_empty_con;
	std::condition_variable not_full_con;
	std::mutex mtx;
}itemRepository;

void produce_one_item(ItemRepository*ir)
{
	if (!ir)
		return;
	int* item_buffer = ir->item_buffer;
	std::unique_lock<std::mutex> lock(ir->mtx);
	if (ir->write_pos == ir->read_pos&&
		item_buffer[ir->write_pos] == 1)//the repository is full
	{
		std::cout << "The producer is waiting for an empty." << std::endl;
		ir->not_full_con.wait(lock);
	}

	item_buffer[ir->write_pos] = 1;//now the buffer in this position is full
	std::cout << "The producer produces a new item on " << ir->write_pos << std::endl;
	ir->write_pos++;
	ir->not_empty_con.notify_all();//notify the consumer to consume items

	if (ir->write_pos == bufferSize)
		ir->write_pos = 0;
}

void consume_one_item(ItemRepository*ir)
{
	if (!ir)
		return;
	int* item_buffer = ir->item_buffer;
	std::unique_lock<std::mutex> lock(ir->mtx);

	if (ir->read_pos == ir->write_pos&&
		item_buffer[ir->write_pos] == 0)//the repository is empty
	{
		std::cout << "The consumer is waiting for items." << std::endl;
		ir->not_empty_con.wait(lock);
	}

	item_buffer[ir->read_pos] = 0;//now the buffer in this position is empty
	std::cout << "The consumer consumes an item on " << ir->read_pos << std::endl;
	ir->read_pos++;
	ir->not_full_con.notify_all();//notify the producer to produce new items
	
	if (ir->read_pos == bufferSize)
		ir->read_pos = 0;
}

void produceTask()
{
	for (int i = 0; i < 50; i++)
		produce_one_item(&itemRepository);
}

void consumeTask()
{
	for (int i = 0; i < 50; i++)
	{
		Sleep(1);
		consume_one_item(&itemRepository);
	}
}

void initializeRepository(ItemRepository*ir)
{
	if (!ir)
		return;
	ir->read_pos = 0;
	ir->write_pos = 0;
}

int main()
{
	initializeRepository(&itemRepository);
	std::thread producer(produceTask);
	std::thread consumer(consumeTask);
	producer.join();
	consumer.join();
	system("pause");
	return 0;
}