多线程 一个线程等待某种事件发生

背景：某个线程在能够完成其任务之前可能需要等待另一个线程完成其任务。

例如：坐夜间列车，为了能够不坐过站，

1，整夜保持清醒，但是这样你就会非常累，不能够睡觉。

2，如果你知道几点会到你要下车的站，就可以提前定个闹钟，然后睡觉等待闹钟叫醒你，但是如果车中间有延误，闹钟响了，但是还没到你要下次的站；还有一种更恶劣的情况就是，闹钟还没响，但是列车已经过站了。

3，最好的办法就是，快到站前，有个人能把你叫醒。

为了能够达到上面场景3的效果，条件变量(Condition variable)就登场了。

对应上面的3个场景，请看下面的代码。

场景1的代码：

while(某个条件){//这个条件由另一个线程来变更，所以就一直循环来检查这个条件，CPU就得不到休息，浪费系统的性能
    
}

场景2的代码：

std::unique_lock<std::mutex> lk(m);
while(某个条件){//这个条件由另一个线程来变更，先睡眠一会，等待别的线程变更这个条件，CPU得到了休息，节省了系统的性能
    lk.unlock();
    sleep(休眠一定的时间);
    lk.lock();
}
//缺点：无法准确知道要休眠多长的时间。休眠时间过长就会导致响应过慢，休眠时间过短，醒来发现条件还没被变更，还得继续休眠。

场景3的代码：

#include <iostream>
#include <mutex>
#include <queue>
#include <condition_variable>
#include <thread>
#include <unistd.h>//sleep

std::mutex mut;
std::queue<int> data_queue;//-------------------①
std::condition_variable data_cond;

void data_preparation_thread(){
  int data = 0;
  while(true){
    data++;
    std::lock_guard<std::mutex> lk(mut);
    data_queue.push(data);//-------------------②
    data_cond.notify_one();//-------------------③
    std::cout << "after  notify_one" << std::endl; 
    //std::this_thread::sleep_for(1000);
    sleep(1);
  }
}

void data_process_thread(){
  while(true){
    std::unique_lock<std::mutex> lk(mut);//-------------------④
    std::cout << "before wait" << std::endl; 
    data_cond.wait(lk, []{return !data_queue.empty();});//-------------------⑤
    std::cout << "after  wait" << std::endl;
    int data = data_queue.front();
    std::cout << data << std::endl;
    data_queue.pop();
    lk.unlock();//-------------------⑥
    //假设处理数据data的函数process要花费大量时间，所以提前解锁
    //process(data);
  }
}
int main(){
  std::thread t1(data_preparation_thread);
  std::thread t2(data_process_thread);
  t1.join();
  t2.join();
}

1，有一个在多个线程间传递数据的队列①，修改队列前锁定队列，把数据压入队列②，压入完成后通知等待它的线程，说：我已经把数据做好，你们可以使用了③。

2，另一个线程使用队列前，先锁定这个队列④，注意是用std::unique_lock而不是std::lock_guard，理由后面说。

3，data_cond.wait()，检查队列里是否有数据(用的是lambda函数,也可以是普通函数)，

• 如果条件不满足(lambda函数返回false)，wait解锁这个互斥元，并将该线程置于阻塞状态，继续等待notify_onde()来唤醒它。
• 如果条件满足(lambda函数返回true)，wait继续锁定这个互斥元，执行wait后面的代码。

这就是为什么使用std::unique_lock而不是std::lock_guard。等待中的线程必须解锁互斥元，并在wait返回true的时候重新锁定这个互斥元，std::lock_guard没有这个功能。如果线程在等待期间不解锁互斥元，把数据压入队列的线程就无法锁定这个互斥元，就无法压入数据，就无法执行notify_one()，所以等待的线程就永远处于等待状态。。。

4，std::unique_lock另外的灵活性，假设得到队列里的数据后，要做一个特别耗时的处理，做这个耗时的处理前就应该解锁这个互斥元⑥，std::unique_lock提供了这个灵活性，而std::lock_guard没有提供这个灵活性。

5，notify_one()后，另一个wait的线程不是马上就被唤醒！！！

github源代码

编译方法：

g++ -g condition_vari-4.1.cpp -std=c++11  -pthread