为什么要引入,condition_variable、wait()、notify_one(),这一些列函数。原因就是为了高效。举例:下面这段代码 单纯的通过加锁的方式 效率其实不太高。
// test.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
#include <iostream>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <list>
#include <thread>
#include <chrono>
#include <mutex>
using namespace std;
class A
{
public:
void inMsgRecvQueue()
{
for (int i = 0; i < 100000; i++)
{
cout << "inMsgRecvQueue 线程执行,插入一个元素:" << i << endl;
unique_lock<mutex> lockGuard(my_mutex);
msgRecvQueue.push_back(i);
}
}
bool outMsgLULProc(int& command)
{
unique_lock<mutex> lockGuard(my_mutex);
if (!msgRecvQueue.empty())
{
int command = msgRecvQueue.front();
msgRecvQueue.pop_front();
return true;
}
return false;
}
void outMsgRecvQueue()
{
int command = 0;
for (int i = 0; i < 100000; i++)
{
bool result = outMsgLULProc(command);
if (result == true)
{
cout << "outMsgRecvQueue(),执行了,从容器中取出一个元素:" << command << endl;
}
else
{
cout << "outMsgRecvQueue 线程执行了,但是目前消息队列中的元素是为空:" << i << endl;
}
}
}
private:
list<int> msgRecvQueue;
mutex my_mutex;
};
int main()
{
A myobja;
thread myInMsgObj(&A::inMsgRecvQueue,&myobja);
thread myOutMsgObj(&A::outMsgRecvQueue,&myobja);
myInMsgObj.join();
myOutMsgObj.join();
cout << "main 主线程执行结束" << endl;
return 0;
}
1.condition_variable 是一个类,是一个和条件相关的类,说白了就是等待一个条件达成。
2.condition_variable 这个类需要和互斥量配合工作,用的时候我们要生成这个类的对象。
// test.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
#include <iostream>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <list>
#include <thread>
#include <chrono>
#include <mutex>
#include <string>
using namespace std;
class A
{
private:
list<int> msgRecvQueue;
mutex m_mutex;
condition_variable m_cond;
public:
void inMsgQueue()
{
for (int i = 0; i < 100000; i++)
{
cout << "inMsgQueue() 执行了,插入了一个元素:" << i << endl;
unique_lock<mutex> mymutex(m_mutex);
msgRecvQueue.push_back(i);
m_cond.notify_one();//我们尝试把wait()线程唤醒,那么outMsgQueue()中的wait()就被唤醒了。notify_one() 不能百分之百保证能够把线程唤醒
}
}
void outMsgQueue()
{
int command = 0;
while (true)
{
//1.wait()用来等一个东西。
//2.如果第二个参数lambda表达式为false,那么wait()将解锁互斥量(也就是释放互斥量,那么其他线程的锁就能够拿到互斥量,进而也就有机会调用notify_one()),并堵塞到本行,那么堵塞到什么时候为止呢?
//堵塞到其他线程调用notify_one()成员函数为止;
//3.如果wait()没有第二个参数:m_cond.wait(mymutex);那么就跟第二个参数lambda表达式返回false效果一样,也就是
//那么wait()将解锁互斥量,并堵塞到本行,堵塞到其他线程调用notify_one()成员函数为止;
//4.如果第二个参数lambda表达式为true,那么wait()直接返回。
//当其他线程调用notify_one()将本wait(原来是睡着/堵塞)的状态唤醒后,wait()就开始恢复干活了,恢复后wait()干什么呢?
//a.wait()不断的尝试重新获取互斥量,如果获取不到,那么流程就卡在wait()这里等着获取,如果获取到了锁(等于加了锁)。
//b.
//b.1 如果wait()有第二个参数(lambda),就判断这个lambda表达式,如果lambda表达式为false,那么wait又对这个互斥量解锁,并堵塞到本行,
// 然后又在这里休眠,等待再次被notify_one()唤醒。
//b.2 如果lambda 表达式为true,则wait()返回,流程走下来(此时互斥量被锁住)。
//b.3 wait没有第二个参数,则wait返回,流程走下来
unique_lock<mutex> mymutex(m_mutex);
m_cond.wait(mymutex, [this] {
if (!msgRecvQueue.empty())
return true;
return false;
});
//流程只要能够走到这里来,这个互斥锁一定是锁住的,同时msgRecvQueue至少是有一条数据的。
command = msgRecvQueue.front();
msgRecvQueue.pop_front();
mymutex.unlock(); // 提前解锁,以便影响其他线程得到锁,以免锁住太长时间,体现了unique_lock 的方便性。
cout << "outMsgQueue()执行,取出一个元素:" << command << endl;
}
}
};
int main()
{
A obj;
thread outThread(&A::outMsgQueue, &obj);
thread inThread(&A::inMsgQueue,&obj);
outThread.join();
inThread.join();
return 0;
}
notify_all() 通知所有线程,notify_one() 只能通知一个线程。
// test.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
#include <iostream>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <list>
#include <thread>
#include <chrono>
#include <mutex>
#include <string>
#include <condition_variable>
using namespace std;
class A
{
private:
list<int> msgRecvQueue;
mutex m_mutex;
condition_variable m_cond;
public:
void inMsgQueue()
{
for (int i = 0; i < 100000; i++)
{
cout << "inMsgQueue() 执行了,插入了一个元素:" << i << endl;
unique_lock<mutex> mymutex(m_mutex);
msgRecvQueue.push_back(i);
//m_cond.notify_one();//我们尝试把wait()线程唤醒,那么outMsgQueue()中的wait()就被唤醒了。notify_one() 不能百分之百保证能够把线程唤醒
m_cond.notify_all();
}
}
void outMsgQueue()
{
int command = 0;
while (true)
{
//1.wait()用来等一个东西。
//2.如果第二个参数lambda表达式为false,那么wait()将解锁互斥量(也就是释放互斥量,那么其他线程的锁就能够拿到互斥量,进而也就有机会调用notify_one()),并堵塞到本行,那么堵塞到什么时候为止呢?
//堵塞到其他线程调用notify_one()成员函数为止;
//3.如果wait()没有第二个参数:m_cond.wait(mymutex);那么就跟第二个参数lambda表达式返回false效果一样,也就是
//那么wait()将解锁互斥量,并堵塞到本行,堵塞到其他线程调用notify_one()成员函数为止;
//4.如果第二个参数lambda表达式为true,那么wait()直接返回。
//当其他线程调用notify_one()将本wait(原来是睡着/堵塞)的状态唤醒后,wait()就开始恢复干活了,恢复后wait()干什么呢?
//a.wait()不断的尝试重新获取互斥量,如果获取不到,那么流程就卡在wait()这里等着获取,如果获取到了锁(等于加了锁)。
//b.
//b.1 如果wait()有第二个参数(lambda),就判断这个lambda表达式,如果lambda表达式为false,那么wait又对这个互斥量解锁,并堵塞到本行,
// 然后又在这里休眠,等待再次被notify_one()唤醒。
//b.2 如果lambda 表达式为true,则wait()返回,流程走下来(此时互斥量被锁住)。
//b.3 wait没有第二个参数,则wait返回,流程走下来
unique_lock<mutex> mymutex(m_mutex);
m_cond.wait(mymutex, [this] {
if (!msgRecvQueue.empty())
return true;
return false;
});
//流程只要能够走到这里来,这个互斥锁一定是锁住的,同时msgRecvQueue至少是有一条数据的。
command = msgRecvQueue.front();
msgRecvQueue.pop_front();
mymutex.unlock(); // 提前解锁,以便影响其他线程得到锁,以免锁住太长时间,体现了unique_lock 的方便性。
cout << "outMsgQueue()执行,取出一个元素:" << command << ","<<"thread id:"<<std::this_thread::get_id()<<endl;
}
}
};
int main()
{
A obj;
thread outThread(&A::outMsgQueue, &obj);
thread outThread2(&A::outMsgQueue, &obj);
thread inThread(&A::inMsgQueue,&obj);
outThread.join();
inThread.join();
return 0;
}