文章目录
1、条件变量std::condition_variable、wait()、notify_one()
1.1 前提
- 线程A:等待一个条件满足
- 线程B:专门往消息队列中扔消息(数据)
1.2 std::condition_variable
std::condition_variable my_cond;
- 实际上是一个类,是一个和条件相关的一个类,说白了就是等待一个条件达成。
- 这个类是需要和互斥量来配合工作,用的时候我们要生成这个类的对象。
1.3 wait()
- 如果第二个参数
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
返回,流程走下来。
- 如果
1.4 notify_one()
- 唤醒处于堵塞的
wait()
的线程继续执行。
1.5 示例代码(不完美):
#include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息(玩家命令)入到一个队列的线程
void inMsgRecvQueue()
{
for (int i = 0; i < 10000; i++)
{
cout << "inMsgRecvQueue()执行,插入一个元素 " << i << endl;
std::unique_lock<std::mutex> 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<std::mutex> 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<int> 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;
}
2、notify_all()
- 唤醒所有等待的
wait()
,但因为锁只有一把的话,还是只有一个线程会执行下去。
示例代码:
#include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息(玩家命令)入到一个队列的线程
void inMsgRecvQueue()
{
for (int i = 0; i < 10000; i++)
{
std::unique_lock<std::mutex> 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<std::mutex> 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<int> 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++多线程学习地址