本文讨论了在多线程编程中引入condition_variable、wait()和notify_one()函数的原因，它们能有效避免死锁，提高线程间的协作效率。通过实例分析，展示了如何使用这些函数优化一个消息队列处理场景。
为什么要引入，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;
}
2086
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
