- condition_variable
- wait()
- notify_one
- notify_all
condition_variable
条件变量的实际用途：
比如有两个线程A和B，在线程A中等待一个条件满足，(消息队列中有要处理的消息)，线程B专门往队列中丢数据。当B往线程中放入数据，同时B通知线程A，开始往下执行。在服务器的后台设计中，有一个线程，阻塞式地读取消息，并且将其解析，放入队列中，此时线程B还通知A，要从队列中去拿请求，并进行处理。
a) socket技术使得服务器中的程序能够像打开文件一样来读取数据。
b) 线程B读取数据，并将其放入到消息队列中。
c) 线程B唤醒线程A，让线程A从队列中拿数据。
d) 服务器处理请求完成并返回结果。
通过条件变量类可以使得A等待B:
复习原先的代码：(通过双重锁定，使得每次都判断是否为空，如果为空那么就取得锁)
class ProcessRequest {
public:
//把命令加入到一个队列
void inMsgRecvQueue() {
for (int i = 0; i < 100000; ++i) {
//std::lock_guard<std::mutex> sbguard(my_mutex);
cout << "插入一个元素" << endl;
m_msgRecvQueue.push_back(i); //假设这个队列表示玩家的命令
} //占用时间片
}
bool outMsgLULProc(int &command) {
//通过双重锁定，避免每次进来程序都锁定。
if (!m_msgRecvQueue.empty())
{
std::lock_guard<std::mutex> sbguard(my_mutex);
if (!m_msgRecvQueue.empty()) {
int command = m_msgRecvQueue.front();
m_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() 执行，取出一个元素" << endl;
}
else
{
cout << "outMsgRecvQueue() 还执行，但是消息队列为空" << endl;
//消息队列为空
}
//占用时间片
}
}
private:
std::list<int> m_msgRecvQueue; //容器，用于表示玩家的发送过来命令
std::mutex my_mutex;
};
使用类std::condition_variable来替代双重锁定，用来等待一个条件达成，这个类需要和互斥量配合工作，用的时候需要生成类的对象。
pirvate:
std::condition_variable my_condition;
wait()
出队列修改： wait是卡在这里的，需要修改入队列的线程。
void outMsgRecvQueue() {
int command = 0;
while (true) {
std::unique_lock<std::mutex> sbguard1(my_mutex);
my_condition.wait(sbguard1, [this] {
if (!m_msgRecvQueue.empty())//lambda表达式就是一个可调用对象(函数)
return true;
else
return false;
}); //wait用来等待一个东西
//Wait(para1, para2)
//para1: 互斥量
//para2:第二个参数Lambda表达式的返回值是False
// 那么将解锁互斥量,并阻塞本行，直到其他线程调用 notify_one()
//如果没有第二个参数,那么就跟第二个参数返回False效果一样
}
}
当然wait()之后可以提早解开 unique_lock()，然后执行逻辑。
notify_one
将原来阻塞的进程唤醒了。wait就开始恢复干活了，恢复之后
a) wait() 不断尝试获取互斥量锁，尝试拿这个锁。如果获取不到锁，流程就卡在wait这里,如果获取到，wait就走下来了。
b) 实际上获取到了锁就等于上了锁。如果wait有第二个参数(lambda)，就判断lambda表达式，
如果表达式为false，又将互斥量解锁。然后另一个线程又休眠。
如果表达式为true,则wait返回，流程走下来(此时互斥锁被锁着)。
如果wait没有第二个参数，则wait返回
void inMsgRecvQueue() {
for (int i = 0; i < 100; ++i) {
std::lock_guard<std::mutex> sbguard(my_mutex);
m_msgRecvQueue.push_back(i); //假设这个队列表示玩家的命令
cout << "插入一个元素" << endl;
my_condition.notify_one();
} //占用时间片
}
同时获取锁的可能性：
1) void inMsgRecvQueue()
2) void outMsgRecvQueue()
可能出现同时竞争一个锁的可能性，也就是说如果运行到了outMsgRecvQueue()的逻辑执行语句的时候，队列中至少进去了一个元素，那么就有可能出现in和out并不是按序执行的情况。
out在执行逻辑语句的时候有延迟，此时如果in唤醒，out并不是卡在wait()的状态，那么此时notify_one()调用就没有效果。
深入思考
写代码用在商业中，必须理解。
在线程入口函数中， 队列中可能会存在多条数据，这个时候处理不过来怎么办？开更多的线程处理？或者限流，超过200条数据未处理，就卡住？
