17.8 condition_variable、wait、notify_one与notify_all

一：条件变量std::condition_variable，wait()，notify_one()

只能通知一个outMsgRecvQueue线程
线程A：等待一个条件满足
线程B：专门往消息队列中扔数据
std::condition_varibale实际上是一个类，是一个和条件相关的一个类，说白了就是等待一个条件达成。
这个类是需要和互斥量来配合工作，用的时候我们要生成这个类的对象。

class MA
{
public:
	int i = 0;
	std::unique_lock<std::mutex> rtn_unique_gurad()
	{
		std::unique_lock <std::mutex> tmpgurad(my_mutex_1);
		return tmpgurad;  //从函数返回一个局部的unique_lock对象是可以的，三章十四届讲过移动构造函数
		//返回这种局部对象会导致系统生成临时unique_lock对象，并调用unique_lock的移动构造函数
	}

	//把收到的消息(玩家命令)放入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素：  " << i << endl;
			std::unique_lock<std::mutex> sbguard_1 = rtn_unique_gurad();
			msgRecvQueue.push_back(i);  //假设这个数字i就是我们收到的命令，直接弄到消息队列中

			std::chrono::milliseconds dura(500);
			std::this_thread::sleep_for(dura);

			//假如outMsgRecvQueue()正在处理一个事务，需要一段时间，而不是正卡在wait()那里等待唤醒；
			//那么此时这个notify_one()这个调用也许就没效果。
			my_cond.notify_one();  //我们尝试把wait()线程唤醒，执行完这行，那么outMsgRecvQueue()里边的wait()就会被唤醒
			//my_cond.notify_all();
		}
		cout << "i = " << i << endl;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		while (true)
		{
			//wait()用来等待一个东西
			//如果第二个参数lambda表达式返回值是true，那wait()直接返回；
			//如果第二个参数lambda表达式返回值是false，那么wait()将解锁互斥量，并堵塞到本行
			//那堵塞到什么时候为止呢？堵塞到其他某个线程调用notify_one()成员函数为止；
			//如果wait()没有第二个参数：my_cond.wait(sbguard1); 那么就跟第二个参数lambda表达式返回false效果一样，堵塞本行
			//wait()将解锁互斥量，并阻塞到本行，阻塞到其他某个线程调用欧冠notify_one()成员函数为止；

			//当其他线程用notify_one()将本wait()(原来是睡着/阻塞)的状态唤醒后，wait就开始恢复干活了，恢复后wait干什么活？
			//a> wait()不断的尝试重新获取互斥量锁，如果获取不到，那么流程就卡在wait()这这里等着获取，如果获取到了锁(等于加了锁)，那么wait()就继续执行b；
			//b> 
			//b.1> 如果wait()有第二个参数(lambda)，就判断这个lambda表达式，如果lambda表达式为false，那wait()又对互斥量解锁，然后又休眠这里等待再次被notify_one唤醒；
			//b.2> 如果lambda表达式为true， 则wait返回，流程走下来(此时互斥锁被锁着)；
			//b.3> 如果wait()没有第二个参数，则wait()返回，流程走下来。
			std::unique_lock<std::mutex> sbguard_1(my_mutex_1);
			my_cond.wait(sbguard_1, [this] {  //一个lambda就是一个可调用对象(函数)
				if (!msgRecvQueue.empty())
					return true;
				return false;
				});

			//流程只要能走到这里来，这个互斥锁一定是锁着的,同时msgRecvQueue至少是有一条数据的
			command = msgRecvQueue.front();
			msgRecvQueue.pop_front();
			sbguard_1.unlock();  //因为unique_lock的灵活性，所以我们可以随时的unlock解锁，以免锁住太长时间。
			cout << "outMsgRecvQueue()执行，取出一个元素 " << command << " " << std::this_thread::get_id() << endl;
		}  //end while
		cout << "end" << endl;
	}
private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	mutex my_mutex_1;  //创建了一个互斥量  (一把锁头)
	std::condition_variable my_cond;  //生成一个条件变量对象
};

int main()
{
	MA myobj;
	std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj);  //第二个参数是引用,才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj);
	myOutMsgObj.join();
	myInMsgObj.join();
	cout << "main主函数执行结束" << endl;  //最后执行这句，整个进程退出
	return 0;
}

二：上述代码深入思考

三：notify_all()

class MA
{
public:
	int i = 0;
	std::unique_lock<std::mutex> rtn_unique_gurad()
	{
		std::unique_lock <std::mutex> tmpgurad(my_mutex_1);
		return tmpgurad;  //从函数返回一个局部的unique_lock对象是可以的，三章十四届讲过移动构造函数
		//返回这种局部对象会导致系统生成临时unique_lock对象，并调用unique_lock的移动构造函数
	}

	//把收到的消息(玩家命令)放入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素：  " << i << endl;
			std::unique_lock<std::mutex> sbguard_1 = rtn_unique_gurad();
			msgRecvQueue.push_back(i);  //假设这个数字i就是我们收到的命令，直接弄到消息队列中

			//std::chrono::milliseconds dura(500);
			//std::this_thread::sleep_for(dura);

			//假如outMsgRecvQueue()正在处理一个事务，需要一段时间，而不是正卡在wait()那里等待唤醒；
			//那么此时这个notify_one()这个调用也许就没效果。
			my_cond.notify_all();  //我们尝试把wait()线程唤醒，执行完这行，那么outMsgRecvQueue()里边的wait()就会被唤醒
		}
		cout << "i = " << i << endl;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		while (true)
		{
			//wait()用来等待一个东西
			//如果第二个参数lambda表达式返回值是true，那wait()直接返回；
			//如果第二个参数lambda表达式返回值是false，那么wait()将解锁互斥量，并堵塞到本行
			//那堵塞到什么时候为止呢？堵塞到其他某个线程调用notify_one()成员函数为止；
			//如果wait()没有第二个参数：my_cond.wait(sbguard1); 那么就跟第二个参数lambda表达式返回false效果一样，堵塞本行
			//wait()将解锁互斥量，并阻塞到本行，阻塞到其他某个线程调用欧冠notify_one()成员函数为止；

			//当其他线程用notify_one()将本wait()(原来是睡着/阻塞)的状态唤醒后，wait就开始恢复干活了，恢复后wait干什么活？
			//a> wait()不断的尝试重新获取互斥量锁，如果获取不到，那么流程就卡在wait()这这里等着获取，如果获取到了锁(等于加了锁)，那么wait()就继续执行b；
			//b> 
			//b.1> 如果wait()有第二个参数(lambda)，就判断这个lambda表达式，如果lambda表达式为false，那wait()又对互斥量解锁，然后又休眠这里等待再次被notify_one唤醒；
			//b.2> 如果lambda表达式为true， 则wait返回，流程走下来(此时互斥锁被锁着)；
			//b.3> 如果wait()没有第二个参数，则wait()返回，流程走下来。
			std::unique_lock<std::mutex> sbguard_1(my_mutex_1);
			my_cond.wait(sbguard_1, [this] {  //一个lambda就是一个可调用对象(函数)
				if (!msgRecvQueue.empty())
					return true;
				return false;
				});

			//流程只要能走到这里来，这个互斥锁一定是锁着的,同时msgRecvQueue至少是有一条数据的
			command = msgRecvQueue.front();
			msgRecvQueue.pop_front();
			cout << "outMsgRecvQueue()执行，取出一个元素 " << command << " threadID： " << std::this_thread::get_id() << endl;
			sbguard_1.unlock();  //因为unique_lock的灵活性，所以我们可以随时的unlock解锁，以免锁住太长时间。
		}  //end while
		cout << "end" << endl;
	}
private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	mutex my_mutex_1;  //创建了一个互斥量  (一把锁头)
	std::condition_variable my_cond;  //生成一个条件变量对象
};

int main()
{
	MA myobj;
	std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj);
	std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj);  //第二个参数是引用,才能保证线程里用的是同一个对象
	std::thread myOutMsgObj2(&MA::outMsgRecvQueue, &myobj);

	myInMsgObj.join();
	myOutMsgObj.join();
	myOutMsgObj2.join();
	cout << "main主函数执行结束" << endl;  //最后执行这句，整个进程退出
	return 0;
}