C++ 多线程同步之条件变量实战

运行该程序，消费者线程在队列空的时候会一直循环检查，造成不必要的 CPU 开销。

C++ 标准库中的条件变量

C++11 标准库在 <condition_variable> 头文件中提供了 std::condition_variable 类，它需要与 std::mutex 配合使用，实现线程间的高效等待与通知。

std::condition_variable 的核心接口

1. wait(unique_lock& lck)
   • 调用该函数的线程会释放持有的互斥锁，并进入阻塞状态。
   • 直到被其他线程的 notify_one() 或 notify_all() 唤醒。
   • 唤醒后，线程会重新获取互斥锁，然后继续执行。
2. wait(unique_lock& lck, Predicate pred)
   • 带条件的等待，只有当 pred 条件为 false 时才会阻塞。
   • 被唤醒后会先检查条件，条件满足才会继续执行，否则再次阻塞。
   • 该重载可以避免虚假唤醒问题。
3. notify_one()
   • 唤醒一个正在等待该条件变量的线程。
   • 如果有多个线程等待，随机唤醒其中一个。
4. notify_all()
   • 唤醒所有正在等待该条件变量的线程。

搭配 std::unique_lock 的原因

std::condition_variable 的 wait() 函数要求传入 std::unique_lock，而不是 std::lock_guard。 这是因为 wait() 过程中需要临时释放锁，而 std::unique_lock 支持手动解锁和加锁，std::lock_guard 仅支持构造加锁、析构解锁，无法满足需求。

核心结论：条件变量必须与 std::unique_lock 配合使用，才能实现等待时释放锁、唤醒后重新加锁的逻辑。

条件变量实战：解决等待 - 通知问题

我们使用 std::condition_variable 改造上述轮询反例，实现高效的生产者 - 消费者模型：

#include<iostream>
#include<thread>
#include<mutex>
#include<queue>
#include<condition_variable>
using namespace std;
queue<int> data_queue;
mutex mtx;
condition_variable cv;
bool is_produced = false;
// 生产完成标志
// 生产者
void producer(){
    for(int i =1; i <=5;++i){
        lock_guard<mutex> lock(mtx);
        data_queue.push(i);
        cout <<"生产者生产数据："<< i << endl;
    }
    is_produced = true;
    cv.notify_all();
    // 生产完成，唤醒所有等待的消费者
}
// 消费者（条件变量方式）
void consumer(){
    unique_lock<mutex> lock(mtx);
    // 等待条件：队列不为空 或 生产已完成
    cv.wait(lock,[]{return !data_queue.empty()|| is_produced;});
    while(!data_queue.empty()){
        int data = data_queue.front();
        data_queue.pop();
        cout <<"消费者消费数据："<< data << endl;
    }
}
int main(){
    thread t_producer(producer);
    thread t_consumer(consumer);
    t_producer.join();
    t_consumer.join();
    return 0;
}

运行该程序，消费者线程在没有数据时会进入等待状态，不会浪费 CPU 资源。 生产者生产完成后唤醒消费者，消费者再进行数据消费。

解决虚假唤醒问题

虚假唤醒指的是线程在没有被 notify_one()/notify_all() 唤醒的情况下，也可能从 wait() 中返回。 为了避免这种情况，我们必须使用带条件的 wait() 重载版本，通过判断条件是否满足来决定是否继续执行。

例如，在消费者线程中，我们用 cv.wait(lock, [](){ return !data_queue.empty() || is_produced; }) 替代无参的 wait()，确保只有在队列有数据或生产完成时，线程才会被唤醒并继续执行。

实战案例：多生产者 - 多消费者模型

我们实现一个支持多个生产者和多个消费者的模型，使用条件变量保证线程间的同步协作：

#include<iostream>
#include<thread>
#include<mutex>
#include<queue>
#include<condition_variable>
#include<vector>
using namespace std;
const int MAX_QUEUE_SIZE = 5;
// 队列最大容量
queue<int> data_queue;
mutex mtx;
condition_variable cv_producer;
// 生产者条件变量
condition_variable cv_consumer;
// 消费者条件变量
bool stop_flag = false;
// 停止标志
// 生产者函数
void producer_func(int id){
    for(int i =1; i <=3;++i){
        unique_lock<mutex> lock(mtx);
        // 等待队列有空位
        cv_producer.wait(lock,[]{return data_queue.size()< MAX_QUEUE_SIZE || stop_flag;});
        if(stop_flag) break;
        int data = id *10+ i;
        data_queue.push(data);
        cout <<"生产者"<< id <<"生产数据："<< data <<"，队列大小："<< data_queue.size()<< endl;
        cv_consumer.notify_one();
        // 唤醒一个消费者
    }
}
// 消费者函数
void consumer_func(int id){
    while(true){
        unique_lock<mutex> lock(mtx);
        // 等待队列有数据
        cv_consumer.wait(lock,[]{return !data_queue.empty()|| stop_flag;});
        if(stop_flag && data_queue.empty()) break;
        int data = data_queue.front();
        data_queue.pop();
        cout <<"消费者"<< id <<"消费数据："<< data <<"，队列大小："<< data_queue.size()<< endl;
        cv_producer.notify_one();
        // 唤醒一个生产者
    }
}
int main(){
    // 创建 2 个生产者线程和 3 个消费者线程
    vector<thread> producers;
    vector<thread> consumers;
    for(int i =1; i <=2;++i){
        producers.emplace_back(producer_func, i);
    }
    for(int i =1; i <=3;++i){
        consumers.emplace_back(consumer_func, i);
    }
    // 等待所有生产者完成
    for(auto& t : producers){
        t.join();
    }
    // 设置停止标志，唤醒所有消费者
    stop_flag = true;
    cv_consumer.notify_all();
    // 等待所有消费者完成
    for(auto& t : consumers){
        t.join();
    }
    cout <<"所有生产和消费任务完成"<< endl;
    return 0;
}

运行效果：

1. 生产者线程会在队列满时等待，队列有空位时继续生产。
2. 消费者线程会在队列空时等待，队列有数据时继续消费。
3. 生产完成后设置停止标志，唤醒所有消费者线程并退出，避免线程阻塞。

条件变量与互斥锁的协同要点

1. 条件变量必须搭配互斥锁使用：wait() 函数需要先获取互斥锁，才能保证条件判断的线程安全。
2. 优先使用带条件的 wait()：可以有效避免虚假唤醒，确保线程在正确的条件下被唤醒。
3. notify_one() 和 notify_all() 的选择：
   • 当只需要唤醒一个等待线程时，使用 notify_one()，效率更高。
   • 当需要唤醒所有等待线程时，使用 notify_all()，比如生产完成后通知所有消费者。

本章小结

1. 条件变量用于解决多线程间的等待 - 通知问题，避免了轮询造成的 CPU 资源浪费。
2. std::condition_variable 必须与 std::unique_lock 配合使用，核心接口是 wait()、notify_one() 和 notify_all()。
3. 带条件的 wait() 重载版本可以解决虚假唤醒问题，是实际开发中的首选。
4. 生产者 - 消费者模型是条件变量的典型应用场景，通过合理设计条件可以实现高效的线程协作。