📕条件变量

与本文无关的知识联系：

一、call_once

• 函数模板，第一个参数为标记，第二个参数为要调用的函数名，如test()
• 功能：保证写入第二个参数的函数(如test() )只能被调用一次。具备互斥量的能力，但互斥量消耗的资源少，更高效
• call_once()， 第一个参数的标记为:std::once_flag,实际上once_flag是一个结构体，记录函数是否已调用过。

例子：

//用once_flag实现单例模式 std::once_flag flag; class Singleton { public:     static void CreateInstance()//call_once保证其只被调用一次     {         instance = new Singleton;     }     //两个线程同时执行到这里，其中一个线程要等另外一个线程执行完毕 	static Singleton * getInstance() {          call_once(flag, CreateInstance);          return instance; 	} private: 	Singleton() {} 	static Singleton *instance; }; Singleton * Singleton::instance = NULL;  

本文正题开始：

二、condition_variable

• 实际上是一个类，是一个和条件相关的类，说白了就是等待一个条件达成！这个类需要和互斥量配合工作，用的时候我们要生成这个类对象，下面都是该类中的方法。

2.1 wait()

先看例子：

std::mutex myMutex; std::unique_lock<std::mutex> uniLock(myMutex); std::condition_variable cv; //带两个参数 cv.wait(uniLock, [this] {     	if (!msgRecvQueue.empty()) return true;     	return false;     });   //只有一个参数 cv.wait(uniLock);  

• wait()用来等待一个东西，第一个参数是要操作的锁，第二个参数是函数对象(不懂函数对象可以去百度理解，我们后面举例中都采用lambda表达式)
• 功能：①如果第二个参数的lambda表达式返回值是false，那么wait()将解锁互斥量，并阻塞到本行；②如果第二个参数的lambda表达式返回值是true，那么wait()直接返回并继续执行。
• 如果没有第二个参数，那么效果跟第二个参数lambda表达式返回false效果一样，wait()将解锁互斥量，并阻塞到本行。
• 阻塞到其他某个线程调用notify_one()成员函数为止。

当其他线程用notify_one()或者notify_all() 将本线程wait()唤醒后，这个wait恢复后:

1、wait()不断尝试获取互斥量锁，如果获取不到那么流程就卡在wait()这里等待获取继续获取锁，如果获取到了，那么wait()就继续执行2

2.1、如果wait有第二个参数就判断这个lambda表达式。

a)如果表达式为false，那wait又对互斥量解锁，然后又休眠，等待再次被notify_one()唤醒
b)如果lambda表达式为true，则wait返回，流程可以继续执行（此时互斥量已被锁住）。
2.2、如果wait没有第二个参数，则wait返回，流程走下去。

2.2 wait_for()

std::condition_variable::wait_for的原型有两种：

//第一种不带pre的 template <class Rep, class Period>   cv_status wait_for (unique_lock<mutex>& lck,                       const chrono::duration<Rep,Period>& rel_time); //第二种，带有pred template <class Rep, class Period, class Predicate>        bool wait_for (unique_lock<mutex>& lck,                       const chrono::duration<Rep,Period>& rel_time, Predicate pred);  

即我们可以写三个参数，我们看看带谓词pre的版本（pre其实也就是wait的第二个参数），wait_for会阻塞其所在线程（该线程应当拥有lock），直至超过了rel_time，或者谓词返回true。在阻塞的同时会自动调用lck.unlock()让出线程控制权。对上述行为进行总结：

• 只要谓词返回true（阻塞期间只要notify了才会看谓词状态），立刻唤醒线程（返回值为true）；
• 当谓词为false，没超时就继续阻塞，超时了就唤醒（此时返回值为false）；
• 当其他线程使用notify_one或者notify_all进行唤醒时，取决于谓词的状态，若为false，则为虚假唤起，线程依然阻塞。

2.3 notify_one()

• 只唤醒等待队列中的第一个线程，不存在锁争用（同队列中不存在），所以能够立即获得锁。其余的线程不会被唤醒，需要等待再次调用notify_one()或者notify_all()。

2.4 notify_all()

• 会唤醒所有等待队列中阻塞的线程，存在锁争用，只有一个线程能够获得锁，而其余的会接着尝试获得锁(类似轮询)

  tips: ，java必须在锁内（与wait线程一样的锁）调用notify。但c++是不需要上锁调用的，如果在锁里调用，可能会导致被立刻唤醒的线程继续阻塞（因为锁被notify线程持有）。c++标准在通知调用中，直接将等待线程从条件变量队列转移到互斥队列，而不唤醒它，来避免此"hurry up and wait"场景。我在做多线程的题目的时候，notify_one 是在锁内末尾的时候调用的。

代码的优化：

参考一下我的笔记中：拿出数据的函数：

第一种写法：

//拿取数据的函数 bool outMsgPro(int& command) {          { 		std::lock_guard<std::mutex> myGuard(myMutex); 		if (!msgRecvQueue.empty()) {//非空就进行操作 			command = msgRecvQueue.front(); 			msgRecvQueue.pop(); 			return true; 		}     }      //其他操作代码 	return false; } 

不管信息接收队列(msgRecvQueue)是不是空，都要加锁解锁，大大降低了效率------这个问题在设计模式中单例模式也有说明

进一步优化：第二种写法(正常优化写法)

//拿取数据的函数 bool outMsgPro(int& command) {     //双重锁定     if (!msgRecvQueue.empty()) {                  std::lock_guard<std::mutex> myGuard(myMutex); 		if (!msgRecvQueue.empty()) {//非空就进行操作 			command = msgRecvQueue.front(); 			msgRecvQueue.pop(); 			return true; 		}            }	      //其他操作代码 	return false; } 

再进一步优化写法：第三种写法

//拿取数据的函数 std::condition_variable cv; void outMsgPro(int& command) {          std::lock_guard<std::mutex> myGuard(myMutex);     //采用wait方式，拿到数据     cv.wait(myGuard, [this] {         if (!msgRecvQueue.empty()) return true;         return false;     });     command = msgRecvQueue.front();     msgRecvQueue.pop();     myGuard.unlock();      //其他操作代码     return; }