多线程编程4. std::condition_variable

1 简介

用于线程的同步，用来实现线程等待和通知机制。
条件变量通常与互斥量一起使用。std::mutex用于确保在任何时候只有一个线程可以访问共享数据，而std::condition_variable则用于在特定条件下唤醒等待的线程。
主要原理：

1. 等待条件： 线程检查条件是否满足。如果不满足，线程会释放互斥锁并进入等待状态。
2. 通知其他线程： 当条件可能已经变为真的事件发生时，另一个线程会通知等待的线程。
3. 重新检查条件： 被通知的线程重新获取互斥锁，并重新检查条件。如果条件仍然不满足，线程可能会再次等待。

2 主要函数介绍

• wait(std::unique_lock<std::mutex>& lock, Predicate pred = [](){return false;})
  第二个参数为等待条件，是一个返回bool值的可调用对象，默认返回false。当执行到该语句时，
  如果条件对象返回false：使当前线程进入等待状态，直到另一个线程调用notify_one()或notify_all()。在等待期间，lock参数指定的互斥锁会被自动释放，允许其他线程访问共享数据。当线程被唤醒时，互斥锁会再次被锁定。
  如果条件对象返回true：条件成立，且成功获取互斥量的所有权，则线程继续执行。

• wait_for(std::unique_lockstd::mutex& lock, std::chrono::duration<Rep, Period> rel_time)
  与wait()类似，但允许指定一个超时时间。如果超时时间到达而条件仍未成立，线程将停止等待并继续执行。

• wait_until(std::unique_lockstd::mutex& lock, std::chrono::time_point<Clock, Duration> abs_time)
  与wait_for()类似，但允许指定一个绝对时间作为超时时间。

• notify_one()
  唤醒等待在condition_variable上的一个线程（如果有的话）
  其他线程如果有condition_variable.wait()，则 condition_variable.notify_one() 就会唤醒一个对应的线程，但是不一定唤醒哪一个。

• notify_all()
  唤醒等待在condition_variable上的所有线程。

3 主要步骤和代码

主要步骤：

1. 创建一个 std::condition_variable 对象。
2. 创建一个互斥锁 std::mutex 对象，用来保护共享资源的访问。
3. 在需要等待条件变量的地方
4. 使用 std::unique_lock< std::mutex > 对象锁定互斥锁
5. 并调用 std::condition_variable::wait()、std::condition_variable::wait_for() 或 std::condition_variable::wait_until() 函数等待条件变量。
6. 在其他线程中需要通知等待的线程时，调用 std::condition_variable::notify_one() 或 std::condition_variable::notify_all() 函数通知等待的线程。

示例代码：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
std::mutex g_mutex;
std::condition_variable g_cv;
std::queue<int> g_queue;

void Producer() {
    for (int i = 0; i < 10; i++) {
        {            
            std::unique_lock<std::mutex> lock(g_mutex);
            g_queue.push(i);  // 创建多个任务
            std::cout << "Producer: produced " << i << std::endl;
        }
        g_cv.notify_one();  // 每次添加一个任务则通知一个线程执行任务       
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}
void Consumer() {    
    while (true) {        
        std::unique_lock<std::mutex> lock(g_mutex);
        g_cv.wait(lock, []() {  // 等待，直到任务队列 g_queue 不为空，则继续往下执行
            return !g_queue.empty();
        });        
        int value = g_queue.front();
        g_queue.pop();
        std::cout << "Consumer: consumed " << value << std::endl;
    }
}
int main() {    
    std::thread producer_thread(Producer);    
    std::thread consumer_thread(Consumer);
    producer_thread.join();
    consumer_thread.join();    
    return 0;
}