C++ std::condition_variable::wait

std::condition_variable提供了两个等待函数：wait()和wait_for().条件变量是需要和一个互斥锁mutex配合使用，调用wait（）之前应该先获得mutex，当线程调用 wait() 后将被阻塞，当wait陷入休眠是会自动释放mutex。直到另外某个线程调用 notify_one或notify_all唤醒了当前线程。当线程被唤醒时，此时线程是已经自动占有了mutex。
std::condition_variable::wait
1.
void wait( std::unique_lockstd::mutex& lock );
2
template< class Predicate >
void wait( std::unique_lockstd::mutex& lock, Predicate pred );

在第二种情况下（即设置了 Predicate），只有当 pred 条件为false 时调用 wait() 才会阻塞当前线程，并且在收到其他线程的通知后只有当 pred 为 true 时才会被解除阻塞，第二种情况等效以下代码：

while (!pred()) {
wait(lock);
}

例子

#include <iostream>
#include <condition_variable>
#include <thread>
#include <chrono>
 
std::condition_variable cv;
std::mutex cv_m; // mutex的作用有三个:
                 // 1) 同步访问i
                 // 2) 同步访问std::cerr输出
                 // 3) 同步条件变量cv，收到notify_all的时候，只有获得锁才会被唤醒
int i = 0;
 
void waits()
{
    std::unique_lock<std::mutex> lk(cv_m);
    std::cerr << "Waiting... \n";
    cv.wait(lk, []{return i == 1;});
    std::cerr << "...finished waiting. i:"<<i<<std::endl;
}
 
void signals()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
        std::lock_guard<std::mutex> lk(cv_m);
        std::cerr << "Notifying...\n";
    }
    cv.notify_all();
 
    std::this_thread::sleep_for(std::chrono::seconds(1));
 
    {
        std::lock_guard<std::mutex> lk(cv_m);
        i = 1;
        std::cerr << "Notifying again...\n";
    }
    cv.notify_all();
}
 
int main()
{
    std::thread t1(waits), t2(waits), t3(waits), t4(signals);
    t1.join(); 
    t2.join(); 
    t3.join();
    t4.join();
}

输出如下，main第一次调用notify_all的时候，i为0,(i==1)不成立，所以线程也不会被唤醒

Waiting…
Waiting…
Waiting…
Notifying…
Notifying again…
…finished waiting. i:1
…finished waiting. i:1
…finished waiting. i:1