C++11并发与多线程笔记（8）condition

• 1、条件变量std::condition_variable、wait()、notify_one()
• • 1.1 前提
  • 1.2 std::condition_variable
  • 1.3 wait()
  • 1.4 notify_one()
  • 1.5 示例代码（不完美）：
• 2、notify_all()

• 线程A：等待一个条件满足
• 线程B：专门往消息队列中扔消息（数据）

• std::condition_variable my_cond;
• 实际上是一个类，是一个和条件相关的一个类，说白了就是等待一个条件达成。
• 这个类是需要和互斥量来配合工作，用的时候我们要生成这个类的对象。

• 如果第二个参数lambda表达式返回是true，那wait()直接返回。
• 如果第二个参数lambda表达式返回值是false，那么wait()将解锁互斥量，并堵塞到本行，堵塞到其他某个线程调用notify_one()成员函数为止。
• 如果wait()没有第二个参数：my_cond.wait(sbguard1)，那么就跟第二个参数lambda表达式返回false效果一样，wait()将解锁互斥量，并堵塞到本行，堵塞到其他某个线程调用notify_one()成员函数为止。
• 当其他线程用notify_one()将本wait(原来是睡眠/堵塞)的状态唤醒后，wait()就会不断地尝试重新获取互斥量锁，如果获取不到，那么流程就卡在wait这里等着获取，如果获取到了锁（等同于上锁）,那么wait就继续执行。
  • 如果wait有第二个参数(lambda)，就判断这个lambda表达式，如果为false，那wait又对互斥量解锁，然后又休眠到这里，在这里等待被notify_one唤醒。如果lambda表达式为true，则wait返回，流程走下来（此时互斥锁被锁着）。
  • 如果wait没有第二个参数，则wait返回，流程走下来。

• 唤醒处于堵塞的wait()的线程继续执行。

#include 
#include 
#include 
#include 
#include 
using namespace std;

class A
{
public:

	//把收到的消息（玩家命令）入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 10000; i++)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素 " << i << endl;

			std::unique_lock sbguard1(my_mutex);
			msgRecvQueue.push_back(i);

			//假如outMsgRecvQueue()正在处理一个事物，需要一段时间，而不是正卡在wait()那里等待唤醒，那么此时这个notify_one()就失效了
			my_cond.notify_one();		//我们尝试把wait()的线程唤醒，执行完这行outMsgRecvQueue()里面的wait就会被唤醒

			//......其他处理代码
		}
		return;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;

		while (true)
		{
			std::unique_lock sbguard1(my_mutex);

			my_cond.wait(sbguard1, [this]		//一个lambda表达式就是一个可调用对象（函数）
				{
					if (!msgRecvQueue.empty())
					{
						return true;
					}
					return false;
				});

			//流程只要能走到这里来，这个互斥锁一定是锁着的，同时MsgRecvQueue至少是有一条数据的
			//其他执行代码
			command = msgRecvQueue.front();
			msgRecvQueue.pop_front();
			sbguard1.unlock();		//因为unique_lock的灵活性，所以我们可以随时的unlock解锁，以免锁住太长时间
			cout << "outMsgRecvQueue()执行，取出一个元素" << command << endl;
            
            //这里为其他一些事务


		}	//end while
	}

private:
	list msgRecvQueue;		//容器，专门用于代表玩家给咱们发送过来的命令
	mutex my_mutex;					//创建了一个互斥量
	std::condition_variable my_cond;		//生成一个条件变量对象

};

int main()
{
	A myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);

	myInMsgObj.join();
	myOutnMsgObj.join();


	cout << "I live China!" << endl;	//最后执行这句，整个进程退出

	system("pause");
	return 0;
}

• 唤醒所有等待的wait()，但因为锁只有一把的话，还是只有一个线程会执行下去。

示例代码：

#include 
#include 
#include 
#include 
#include 
using namespace std;

class A
{
public:

	//把收到的消息（玩家命令）入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 10000; i++)
		{

			std::unique_lock sbguard1(my_mutex);
			cout << "inMsgRecvQueue()执行，插入一个元素 " << i << endl;
			msgRecvQueue.push_back(i);

			my_cond.notify_all();		//我们尝试把wait()的线程唤醒，执行完这行outMsgRecvQueue()里面的wait就会被唤醒

			//......其他处理代码
		}
		return;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;

		while (true)
		{
			std::unique_lock sbguard1(my_mutex);

			my_cond.wait(sbguard1, [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;
			sbguard1.unlock();		//因为unique_lock的灵活性，所以我们可以随时的unlock解锁，以免锁住太长时间


		}	//end while
	}

private:
	list msgRecvQueue;		//容器，专门用于代表玩家给咱们发送过来的命令
	mutex my_mutex;					//创建了一个互斥量
	std::condition_variable my_cond;		//生成一个条件变量对象

};

int main()
{
	A myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
	thread myOutnMsgObj2(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);

	myInMsgObj.join();
	myOutnMsgObj2.join();
	myOutnMsgObj.join();


	cout << "I live China!" << endl;	//最后执行这句，整个进程退出

	system("pause");
	return 0;
}

注：本人学习c++多线程视频地址：C++多线程学习地址