C++ 多线程同步之条件变量（condition_variable）实战
C++ 多线程同步之条件变量（condition_variable）实战
💡 学习目标：掌握 C++ 标准库中条件变量的使用方法，理解条件变量与互斥锁的协同工作机制，能够解决多线程间的等待-通知问题。
💡 学习重点：std::condition_variable 的核心接口、wait() 与 notify_one()/notify_all() 的配合使用、生产者-消费者模型的实现。
49.1 条件变量的引入场景
在多线程编程中，我们经常会遇到线程需要等待某个条件满足后再执行的场景。
比如生产者线程生产数据后，消费者线程才能消费；队列不为空时，消费者才能从中取数据。
如果仅用互斥锁实现，消费者线程只能不断轮询检查条件，这会造成 CPU 资源的浪费。
⚠️ 注意事项：单纯的轮询会导致 CPU 空转，降低程序运行效率，条件变量就是为解决这类问题而生的。
举个简单的轮询反例，消费者不断检查队列是否有数据：
#include<iostream>#include<thread>#include<mutex>#include<queue>usingnamespace std; queue<int> data_queue; mutex mtx;// 生产者voidproducer(){for(int i =1; i <=5;++i){ lock_guard<mutex>lock(mtx); data_queue.push(i); cout <<"生产者生产数据："<< i << endl;}}// 消费者（轮询方式）voidconsumer(){while(true){ lock_guard<mutex>lock(mtx);if(!data_queue.empty()){int data = data_queue.front(); data_queue.pop(); cout <<"消费者消费数据："<< data << endl;if(data ==5)break;}// 没有数据时，依然会不断循环检查，浪费CPU}}intmain(){ thread t_producer(producer); thread t_consumer(consumer); t_producer.join(); t_consumer.join();return0;}运行该程序，消费者线程在队列空的时候会一直循环检查，造成不必要的 CPU 开销。
49.2 C++ 标准库中的条件变量
C++11 标准库在 <condition_variable> 头文件中提供了 std::condition_variable 类，它需要与 std::mutex 配合使用，实现线程间的高效等待与通知。
49.2.1 std::condition_variable 的核心接口
- wait(unique_lock& lck)
- 调用该函数的线程会释放持有的互斥锁，并进入阻塞状态。
- 直到被其他线程的
notify_one()或notify_all()唤醒。 - 唤醒后，线程会重新获取互斥锁，然后继续执行。
- wait(unique_lock& lck, Predicate pred)
- 带条件的等待，只有当
pred条件为false时才会阻塞。 - 被唤醒后会先检查条件，条件满足才会继续执行，否则再次阻塞。
- 该重载可以避免虚假唤醒问题。
- 带条件的等待，只有当
- notify_one()
- 唤醒一个正在等待该条件变量的线程。
- 如果有多个线程等待，随机唤醒其中一个。
- notify_all()
- 唤醒所有正在等待该条件变量的线程。
49.2.2 搭配 std::unique_lock 的原因
std::condition_variable 的 wait() 函数要求传入 std::unique_lock，而不是 std::lock_guard。
这是因为 wait() 过程中需要临时释放锁，而 std::unique_lock 支持手动解锁和加锁，std::lock_guard 仅支持构造加锁、析构解锁，无法满足需求。
✅ 核心结论：条件变量必须与 std::unique_lock 配合使用，才能实现等待时释放锁、唤醒后重新加锁的逻辑。
49.3 条件变量实战：解决等待-通知问题
我们使用 std::condition_variable 改造 49.1 节的轮询反例，实现高效的生产者-消费者模型：
#include<iostream>#include<thread>#include<mutex>#include<queue>#include<condition_variable>usingnamespace std; queue<int> data_queue; mutex mtx; condition_variable cv;bool is_produced =false;// 生产完成标志// 生产者voidproducer(){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();// 生产完成，唤醒所有等待的消费者}// 消费者（条件变量方式）voidconsumer(){ 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;}}intmain(){ thread t_producer(producer); thread t_consumer(consumer); t_producer.join(); t_consumer.join();return0;}运行该程序，消费者线程在没有数据时会进入等待状态，不会浪费 CPU 资源。
生产者生产完成后唤醒消费者，消费者再进行数据消费。
49.3.1 解决虚假唤醒问题
虚假唤醒指的是线程在没有被 notify_one()/notify_all() 唤醒的情况下，也可能从 wait() 中返回。
为了避免这种情况，我们必须使用带条件的 wait() 重载版本，通过判断条件是否满足来决定是否继续执行。
例如，在消费者线程中，我们用 cv.wait(lock, [](){ return !data_queue.empty() || is_produced; }) 替代无参的 wait()，确保只有在队列有数据或生产完成时，线程才会被唤醒并继续执行。
49.4 实战案例：多生产者-多消费者模型
我们实现一个支持多个生产者和多个消费者的模型，使用条件变量保证线程间的同步协作：
#include<iostream>#include<thread>#include<mutex>#include<queue>#include<condition_variable>#include<vector>usingnamespace std;constint MAX_QUEUE_SIZE =5;// 队列最大容量 queue<int> data_queue; mutex mtx; condition_variable cv_producer;// 生产者条件变量 condition_variable cv_consumer;// 消费者条件变量bool stop_flag =false;// 停止标志// 生产者函数voidproducer_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();// 唤醒一个消费者}}// 消费者函数voidconsumer_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();// 唤醒一个生产者}}intmain(){// 创建 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;return0;}✅ 运行效果：
- 生产者线程会在队列满时等待，队列有空位时继续生产。
- 消费者线程会在队列空时等待，队列有数据时继续消费。
- 生产完成后设置停止标志，唤醒所有消费者线程并退出，避免线程阻塞。
49.5 条件变量与互斥锁的协同要点
- 条件变量必须搭配互斥锁使用：
wait()函数需要先获取互斥锁，才能保证条件判断的线程安全。 - 优先使用带条件的
wait()：可以有效避免虚假唤醒，确保线程在正确的条件下被唤醒。 notify_one()和notify_all()的选择：- 当只需要唤醒一个等待线程时，使用
notify_one()，效率更高。 - 当需要唤醒所有等待线程时，使用
notify_all()，比如生产完成后通知所有消费者。
- 当只需要唤醒一个等待线程时，使用
49.6 本章小结
- 条件变量用于解决多线程间的等待-通知问题，避免了轮询造成的 CPU 资源浪费。
std::condition_variable必须与std::unique_lock配合使用，核心接口是wait()、notify_one()和notify_all()。- 带条件的
wait()重载版本可以解决虚假唤醒问题，是实际开发中的首选。 - 生产者-消费者模型是条件变量的典型应用场景，通过合理设计条件可以实现高效的线程协作。
