C++线程同步-条件变量（std::condition_variable）

        线程同步是指线程间需要按照预定的先后次序顺序进行的行为。一个线程的执行需要依赖另一个线程的消息，当它没有得到另一个线程的消息时应等待，知道消息到达才被唤醒。

条件变量（std::condition_variable）

        C++11中新增了对条件变量的支持，当std::condition_variable对象的某个wait函数被调用的时候，它使用std::unique_lock(std::mutex)来锁住当前线程，当前线程会一直被阻塞，直到另外一个线程在同一个std::condition_variable对象上调用notify(one or all)来唤醒当前线程。

#include <iostream>               
#include <thread>                
#include <mutex>                
#include <condition_variable>    
 
std::mutex mtx; .
std::condition_variable cv; 
bool flag = false; 
 
void doSomething(int event)
{
	std::unique_lock <std::mutex> ulock(mtx);
 
	while (!flag)
	{
		/*
			如果flag不为 true,当前线程被阻塞, 当flag变为 true 之后, 线程被唤醒, 继续往下执行,会打印当前的event.
		*/
		cv.wait(ulock);
	}
	std::cout << "do " << event << std::endl;
}
 
void wake()
{
	std::unique_lock <std::mutex> lck(mtx);
	flag = true; // 设置flag为 true.
	cv.notify_all(); // 唤醒所有线程.
}
 
int main()
{
	std::thread threads[5];
	
	for (int i = 0; i < 5; ++i)
		threads[i] = std::thread(doSomething, i);
 
	std::cout << "5 threads running...\n";
	wake(); 
 
	for (auto & th : threads)
		th.join();
 
	return 0;
}

std::condition_variable::wait()函数

unconditional	void wait(std::unique_lock<std::mutex>& lock);
predicate	template< class Predicate > void wait( std::unique_lock< std::mutex >& lock, Predicate stop_waiting );

        在当前线程调用wait()后将被阻塞（此时当前线程已经获得了mutex锁），直到另一个线程调用notify唤醒当前线程。在线程被阻塞时，wait()函数会主动调用mutex锁的.unlock()来释放锁，使得其他阻塞在这个锁上面的进程可以继续执行。另外，在其他线程调用notify唤醒当前线程后，wait()函数也会主动调用mutex锁的.lock()来保持mutex锁的状态与wait()被调用时保持一致。

        在设置了Predicate的情况下，只有当stop_waiting条件为false时调用wait()才会阻塞当前线程，并且在收到其他线程的通知后只有当stop_waiting条件为true时才会被解除则塞。

        第二种情况的示例如下：

#include <iostream>                
#include <thread>               
#include <mutex>               
#include <condition_variable>    

std::mutex mtx;
std::condition_variable cv;

int ready = 0;
bool isReady()
{
    return ready != 0;
}

// 消费者线程.
void consume(int n)
{
    for (int i = 0; i < n; ++i) {
        std::unique_lock <std::mutex> lock(mtx);
        cv.wait(lock, isReady);
        std::cout << ready << '\n';
        ready = 0;
    }
}

int main()
{
    std::thread consumer_thread(consume, 10); // 消费者线程.

    // 主线程为生产者线程, 生产 5 个产品.
    for (int i = 0; i < 5; ++i) {
        while (isReady())
            std::this_thread::yield();
        std::unique_lock <std::mutex> lck(mtx);
        ready = i + 1;
        cv.notify_one();
    }

    consumer_thread.join();

    return 0;
}

std::condition_variable::notify_one函数

         std::condition_variable的实现中有一个等待队列来保存阻塞在它之上的线程。       

         std::condition_variable::notify_one:唤醒等待队列中的某个等待（wait）线程。如果当前没有等待线程，则该函数什么也不做，如果同时存在多个等待线程，则唤醒某个线程是不确定的。

std::condition_variable::notify_all函数

        std::condition_variable::notify_all：唤醒等待队列中所有的线程

std::condition_variable::wait_for()函数  

unconditional	template <class Rep, class Period>   cv_status wait_for (unique_lock<mutex>& lck,                       const chrono::duration<Rep,Period>& rel_time);
predicate	template <class Rep, class Period, class Predicate>        bool wait_for (unique_lock<mutex>& lck,                       const chrono::duration<Rep,Period>& rel_time, Predicate pred);

        从功能上来说和wait()相似，但是wait_for()可以指定一个时间段，如果当前线程收到通知前或者指定时间超时前，都会处于阻塞状态，而在超时或者收到其他线程的通知后，wait_for()将返回。

        wait_for第2个版本的最后一个参数表示wait_for的预测条件，只有当pred为false时调用wait_for()才会阻塞当前线程，在收到其他线程的通知后，只有pred为true时，才会唤醒当前线程。

std::condition_variable::wait_until()函数 

unconditional	template <class Clock, class Duration> cv_status wait_until (unique_lock<mutex>& lck, const chrono::time_point<Clock,Duration>& abs_time);
predicate	template <class Clock, class Duration, class Predicate> bool wait_until (unique_lock<mutex>& lck, const chrono::time_point<Clock,Duration>& abs_time, Predicate pred);

        与wait_for类似，只是wait_until函数是指定了一个时间点