一：条件变量std::condition_variable，wait()，notify_one()
【c++学习|17.8 condition_variable、wait、notify_one与notify_all】只能通知一个outMsgRecvQueue线程
线程A：等待一个条件满足
线程B：专门往消息队列中扔数据
std::condition_varibale实际上是一个类，是一个和条件相关的一个类，说白了就是等待一个条件达成。
这个类是需要和互斥量来配合工作，用的时候我们要生成这个类的对象。
class MA
{
public:
int i = 0;
std::unique_lock rtn_unique_gurad()
{
std::unique_locktmpgurad(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 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 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 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 rtn_unique_gurad()
{
std::unique_locktmpgurad(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 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 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 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;
}
推荐阅读
- c++学习|17.7 单例设计模式共享数据分析、解决与call_once
- c++学习|17.6 unique_lock详解
- c++学习|14.4 类内初始化、默认构造函数、“=default”和“=delete”
- C++|C++ - 智能指针
- C++|C++ - Lambda表达式
- C++ - 子类与父类的同名成员变量
- C++|【C++】多态
- QT|QT---创建对话框3（形状可变对话框的实现）
- QT|Qt状态机的使用