（参考：https://www.cnblogs.com/haippy/p/3252041.html）
std::condition_variable 是条件变量。当 std::condition_variable 对象的某个 wait 函数被调用的时候，它使用 std::unique_lock(通过 std::mutex) 来锁住当前线程。当前线程会一直被阻塞，直到另外一个线程在相同的 std::condition_variable 对象上调用了 notification 函数来唤醒当前线程。
std::condition_variable 对象通常使用 std::unique_lock<std::mutex> 来等待。
#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 do_print_id(int id)
{
std::unique_lock <std::mutex> lck(mtx);
while (!ready) // 如果标志位不为 true, 则等待...
cv.wait(lck); // 当前线程被阻塞, 当全局标志位变为 true 之后,
// 线程被唤醒, 继续往下执行打印线程编号id.
std::cout << "thread " << id << '
';
}
void go()
{
std::unique_lock <std::mutex> lck(mtx);
ready = true; // 设置全局标志位为 true.
cv.notify_all(); // 唤醒所有线程.
}
int main()
{
std::thread threads[10];
// spawn 10 threads:
for (int i = 0; i < 10; ++i)
threads[i] = std::thread(do_print_id, i);
std::cout << "10 threads ready to race...
";
go(); // go!
for (auto & th:threads)
th.join();
return 0;
}
以leetcode的一道例题来说明这个使用方法。
首先是题目：
我们提供了一个类：
public class Foo {
public void one() { print("one"); }
public void two() { print("two"); }
public void three() { print("three"); }
}
三个不同的线程将会共用一个 Foo 实例。
线程 A 将会调用 one() 方法
线程 B 将会调用 two() 方法
线程 C 将会调用 three() 方法
请设计修改程序，以确保 two() 方法在 one() 方法之后被执行，three() 方法在 two() 方法之后被执行。
示例 1:
输入: [1,2,3]
输出: "onetwothree"
解释:
有三个线程会被异步启动。
输入 [1,2,3] 表示线程 A 将会调用 one() 方法，线程 B 将会调用 two() 方法，线程 C 将会调用 three() 方法。
正确的输出是 "onetwothree"。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/print-in-order
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
可以看出，leetcode的测试主线程会实例化Foo，但是只有一个对象，然后该对象会被传入3个线程，三个线程分别调用one, two, three。要求不论怎么运行，输出结果都是1,2,3。很显然，最保险的方式是利用共享的信号量来逐级阻塞two，three的运行。这里采用C++的条件变量和互斥锁来解决。
首先要分析的有一点，因为只有一个对象，而这个对象被传入三个线程，所以三个线程会指向同一个内存（因为传给三个线程的是指针），所以对象了里面定义的成员变量是共享的。本人的实现如下：
class Foo {
private:
int counter=1;
std::mutex mtx; // 全局互斥锁.
std::condition_variable cv1;
std::condition_variable cv2;
public:
Foo() {
}
void first(function<void()> printFirst) {
std::unique_lock <std::mutex> lck(mtx); //使用同一个互斥锁的进行会相互影响
// printFirst() outputs "first". Do not change or remove this line.
printFirst();
counter++;
cv1.notify_all();
}
void second(function<void()> printSecond) {
std::unique_lock <std::mutex> lck(mtx); //使用同一个互斥锁的进行会相互影响
// printSecond() outputs "second". Do not change or remove this line.
while(counter!=2){
cv1.wait(lck);
}
printSecond();
counter++;
cv2.notify_all();
}
void third(function<void()> printThird) {
std::unique_lock <std::mutex> lck(mtx); //使用同一个互斥锁的进行会相互影响
while(counter!=3){
cv2.wait(lck);
}
// printThird() outputs "third". Do not change or remove this line.
printThird();
}
};
首先定义4个类成员：
int counter=1;
std::mutex mtx; // 全局互斥锁.
std::condition_variable cv1;
std::condition_variable cv2;
这里counter用来标记轮到那个函数运行；
mtx是全局互斥的锁，等于一个跨线程的信号。
cv1和cv2是两个条件变量。
对于第一个函数：
void first(function<void()> printFirst) {
std::unique_lock <std::mutex> lck(mtx); //使用同一个互斥锁的进行会相互影响
// printFirst() outputs "first". Do not change or remove this line.
printFirst();
counter++;
cv1.notify_all();
}
毫无疑问，它必须是第一个打印，所以前面不需要给它设置障碍（函数第一句初始化一个锁对象也可以不要，应该显然没用到，我这里只是统一写一下）。
当打印过后，我们对counter计数，指示下一个要运行的是打印2的函数。同时告诉条件变量cv1，所有在互斥锁mtx影响下，等待条件变量cv1的线程都可以继续运行了（无需等待）。
对于第二个函数：
void second(function<void()> printSecond) {
std::unique_lock <std::mutex> lck(mtx); //使用同一个互斥锁的进行会相互影响
// printSecond() outputs "second". Do not change or remove this line.
while(counter!=2){
cv1.wait(lck);
}
printSecond();
counter++;
cv2.notify_all();
}
这个函数的第一句是有用的，使用mtx初始化一个互斥锁。当counter不是2的时候，就使用绑定了互斥锁的条件变量把当前变量阻塞。当cv1提供了提醒后，就可以唤醒当前线程。然后当前线程会判断counter是否为2，为2则打印two。。然后counter加计数，然后将cv2对应的线程解开。