生产者与消费者模式

生产者与消费者模式

  作用及特点：生产者-消费者问题，实际上主要是包含了两类线程，一种是生产者线程用于生产数据，另一种是消费者线程用于消费数据， 一般来说将主线程作为生产者线程，子线程作为消费者线程。
  书接前文，我们依然要假设一个马戏团表演场景，现在马戏团管理员依次叫动物们上场，但是要它们延迟一段时间上场，并开始表演，延迟一段时间退场。

马戏团管理员类

增加两个私有变量队列，方便子线程在里面拿东西，进行创建或者销毁操作
增加一个公共静态锁，在操作队列的时候上锁
增加一个线程函数和线程指针

struct DeleyInfo //类外声明
{
	std::string AnimalName; //动物名称,例如老虎，老鹰
	uint32_t DeleyTime;// 延迟时间
};

private:
	std::multimap<std::string, DeleyInfo> m_queueDelayShowAnimal;//需要延时上场的动物队列
	std::multimap<std::string, DeleyInfo> m_queueDelayExitAnimal;//需要退场的动物队列
	
	HANDLE m_hThread;

	static DWORD WINAPI monitorWThread(LPVOID WorkContext); //思考为什么是静态的
	void startThread();//线程在构造管理类的时候开启
	
public:
	static std::mutex m_mutex; //静态变量，不仅要声明，用之前需定义

	std::multimap<std::string, DeleyInfo>& getDelayShowMap();//获取等待上场的动物列表
	std::multimap<std::string, DeleyInfo>& getDelayExitMap();//获取等待退场的动物列表

	bool insertShowList(std::string name, DeleyInfo deleyInfo);
	bool insertExitList(std::string name, DeleyInfo deleyInfo);

线程函数

std::mutex AnimalManager::m_mutex;//定义公共静态锁

void AnimalManager::startThread()
{
	DWORD thread_id = 0;
	m_hThread = ::CreateThread(NULL, 0, monitorWThread, (LPVOID)this, 0, &thread_id);
	if (NULL == m_hThread)
	{
		DWORD dwErrorCode = GetLastError();
	}
}

DWORD WINAPI AnimalManager::monitorWThread(LPVOID WorkContext)
{
	AnimalManager* animalManager = reinterpret_cast<AnimalManager*>(WorkContext);
	if (!animalManager) return 0;
	while (true)
	{
		uint32_t tTime = GetTickCount(); //std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
		m_mutex.lock();
		auto iterShow = animalManager->getDelayShowMap().begin();
		if (iterShow != animalManager->getDelayShowMap().end())
		{
			if (tTime >= iterShow->second.DeleyTime)
			{

				animalManager->callAnimal(iterShow->first,iterShow->second.AnimalName);
				//Tiger* tiger = (Tiger*)GetAnimalManager()->findAnimal("小脑斧");
				iterShow = animalManager->getDelayShowMap().erase(iterShow);
			}
		}

		auto iterExit = animalManager->getDelayExitMap().begin();
		if (iterExit != animalManager->getDelayExitMap().end())
		{
			if (tTime >= iterExit->second.DeleyTime)
			{

				GetAnimalManager()->exit(iterExit->first);

				iterExit = animalManager->getDelayExitMap().erase(iterExit);
			}
		}
		m_mutex.unlock();
		//std::this_thread::sleep_for(std::chrono::milliseconds(10));
	}
	return 0;
}

马戏团开始表演

假设应用场景：
  马戏团管理员，先登记所有马戏团动物，然后依次叫它们上场表演，并将它们的名称记录在本子上，它们得到消息后 小脑斧延迟1秒上场，大佬凝延迟2秒上场，表演时间为5秒，之后它们退场，并删除记录

#include "Animal.h"
#include "AnimalManager.h"

int main()
{
	uint32_t currentTime = GetTickCount();
	DeleyInfo eagleDeleyInfo{ "Eagle",currentTime+1000 };
	DeleyInfo tigerDeleyInfo{ "Tiger",currentTime+2000 };
	AnimalManager::m_mutex.lock();
	GetAnimalManager()->insertShowList("小脑斧", tigerDeleyInfo);
	GetAnimalManager()->insertShowList("大佬凝", eagleDeleyInfo);
	AnimalManager::m_mutex.unlock();

	tigerDeleyInfo.DeleyTime += 5000;
	eagleDeleyInfo.DeleyTime += 5000;
	AnimalManager::m_mutex.lock();
	GetAnimalManager()->insertExitList("小脑斧", tigerDeleyInfo);
	GetAnimalManager()->insertExitList("大佬凝", eagleDeleyInfo);
	AnimalManager::m_mutex.unlock();

	while (true)//保持主线程不退出，大家肯定比我聪明，有更好的办法
	{

	}
}

输出结果和总结

• 本小节涉及多线程和互斥锁，互斥锁的实现方式有好多,例如  std::unique_lock<std::mutex> lock(m_mutex);  lock_guard<mutex> guard(m_mutex)