C++ 11 线程同步之条件变量(基础)

什么是条件变量

条件变量是能够阻止调用线程直到通知恢复的对象，是一个同步原语。他不仅可用于阻塞一个线程还可以同时阻塞多个线程，直到收到另一个线程的通知才会被唤醒。
一般情况条件变量都会与互斥量（锁、mutex）配合使用

条件变量的工作方式

• 拥有条件变量的线程获取互斥量;
• 循环检查某个条件，条件满足则向下执行，条件不满足，则阻塞直到条件满足，再执行;
• 某一个线程满足条件并且执行完之后，调用notify_one或notify_all唤醒一个或者所有等待线程。

条件变量最简单的例子（来自cplusplus）

#include <iostream>           // std::cout
#include <thread>             // std::thread
#include <mutex>              // std::mutex, std::unique_lock
#include <condition_variable> // std::condition_variable

std::mutex              mtx;
std::condition_variable cv;
bool                    ready = false;
void print_id(int id){
	std::unique_lock<std::mutex> lck(mtx);
	while (!ready)
		cv.wait(lck);
	//do something
	std::cout << "thread " << id << '\n';
}

void go(){
	std::unique_lock<std::mutex> lck(mtx);
	ready = true;
	cv.notify_all();
}

int main()
{
	std::thread threads[10];
	// spawn 10 threads:
	for (int i = 0; i < 10; ++i)
		threads[i] = std::thread(print_id, i);
	std::cout << "10 threads ready to race...\n";
	go(); // go!
	for (auto& th : threads)
		th.join();
	return 0;
}

输出顺序不唯一

细节说明：

wait 有两个功能：

• 阻塞该线程的执行,并休眠(省电，不占用cpu)
• 调用 lck.unlock() ，当wait返回时（被唤醒）该线程再次自动获得 mutex
• 被唤醒后的线程可以获得这个锁(自动lock)。

条件变量中只能使用std::unique_lock<std::mutex>

• lock_guard和unique_lock都是管理锁的辅助类工具，都是RAII风格；它们是在定义时获得锁，在析构时释放锁。它们的主要区别在于unique_lock锁机制更加灵活，可以再需要的时候进行lock或者unlock调用，不非得是析构
• condition_variable在wait成员函数内部会先调用参数unique_lock的unlock临时解锁，让出锁的拥有权（以让其它线程获得该锁使用权加锁，改变条件，解锁），然后自己等待notify信号，等到之后，再调用参数unique_lock的lock加锁，处理相关逻辑，最后unique_lock对象销毁时自动解锁。

condition_variable::wait(std::unique_lock<std::mutex>& lck){
      lck.unlock();
      wait_sig();
      lck.lock();
}

条件变量函数定义说明

• wait()成员函数

// 阻塞该线程，直到被唤醒，可能存在虚假唤醒，不推荐使用
void wait(unique_lock<mutex>& _Lck);
//可以普通函数或者lambda表达式,避免虚假唤醒,推荐使用
void wait(unique_lock<mutex>& _Lck, _Predicate _Pred);

• wait_for()成员函数

template <class _Rep, class _Period>
cv_status wait_for(unique_lock<mutex>& _Lck, const chrono::duration<_Rep, _Period>& _Rel_time)

template <class _Rep, class _Period, class _Predicate>
bool wait_for(unique_lock<mutex>& _Lck, const chrono::duration<_Rep, _Period>& _Rel_time, _Predicate _Pred)

与std::condition_variable::wait()相似，但 wait_for可以设定一个时长，在当前线程收到通知或者指定的时间 _Rel_time 超时之前，该线程都会处于阻塞状态，如果超时或者收到唤醒通知，wait_for返回。接下来同wait一致

• wait_until ()成员函数

template <class _Clock, class _Duration>
cv_status wait_until(unique_lock<mutex>& _Lck, const chrono::time_point<_Clock, _Duration>& _Abs_time);

template <class _Clock, class _Duration, class _Predicate>
bool wait_until(unique_lock<mutex>& _Lck, const chrono::time_point<_Clock, _Duration>& _Abs_time, _Predicate _Pred);

cv_status wait_until(unique_lock<mutex>& _Lck, const xtime* _Abs_time);

template <class _Predicate>
bool wait_until(unique_lock<mutex>& _Lck, const xtime* _Abs_time, _Predicate _Pred);

与wait_for类似，只是wait_until可以指定一个时间点，在当前线程收到通知或者指定的时间点超时之前，该线程都会处于阻塞状态。如果超时或者收到唤醒通知，wait_until返回,接下来同wait一致.

• notify_all/notify_one

void notify_one() noexcept { // wake up one waiter
     _Cnd_signal(_Mycnd());
}
void notify_all() noexcept { // wake up all waiters
     _Cnd_broadcast(_Mycnd());
}

notify_one：随机唤醒一个阻塞的线程，而其余的线程将仍然处于阻塞状态，等待下一次唤醒
notify_all：会唤醒所有线程，线程会争抢锁，但只有一个线程会获得到锁，而其余未获得锁的线程也将不再阻塞，而是进入到类似轮询的状态，等待锁资源释放后再去争抢