当前位置：首页 > news >正文

【C++ 线程同步终极篇】condition_variable 条件变量 /wait/wait_for /notify 实战精讲

news 2026/5/12 19:00:55

前言

在 C++ 多线程开发中，互斥锁 mutex只能解决 “数据竞争” 问题，但无法解决线程间协调与等待。

例如：

线程 A 必须等线程 B 做完某件事才能继续
多个线程按顺序打印（A→B→C→A→B→C）
生产者生产完，消费者才能消费

这就必须用到std::condition_variable条件变量。

从原理到手写实现，精讲：

wait/wait_for/wait_until用法
虚假唤醒（必须用循环判断！）
惊群效应
带谓词的 wait（自动防虚假唤醒）
超时等待
三道经典题：
三线程轮流打印 0~100
三线程轮流打印 ABC （10 组）
条件变量阻塞与 notify 实战

一、条件变量核心原理

condition_variable必须配合unique_lock<mutex>使用。

它的核心能力：

让线程阻塞等待（释放锁 → 不占 CPU）
被其他线程唤醒（重新抢锁 → 继续执行）

最关键四步（背会！）

当调用cv.wait(lock)时，内部会自动做 4 件事：

unlock解锁（让其他线程能进临界区）
把当前线程加入等待队列
等待被唤醒
被唤醒后重新lock抢锁

二、四种 wait 用法

2.1 基础 wait + while 防虚假唤醒

// 必须用 while！！！ 防止虚假唤醒 while (i == 0) { cv.wait(locker); cerr << "被唤醒... " << endl; }

为什么必须 while？

因为操作系统可能会无缘无故唤醒你（虚假唤醒）。

唤醒后条件不满足，必须继续等。

2.2 带谓词的 wait（推荐写法）

cv.wait(locker, [=]() -> bool { return i == 1; // 条件满足才停止等待 });

等价于：

while(!条件) wait(locker);

系统自动帮你做 while 循环，自动防虚假唤醒。

2.3 wait_for 超时等待

auto status = cv.wait_for(locker, 1000ms); if (status == cv_status::timeout) { // 超时了 } else { // 被唤醒 }

2.4 wait_for + 谓词（最常用、最安全）

cv.wait_for(locker, 1000ms, [ch]() -> bool { return i == 1; });

每 1s 自动醒一次
条件满足就退出
防超时 + 防虚假唤醒

三、主程序示例（可直接运行）

#include<iostream> #include<string> #include<memory> // 智能指针 #include<atomic> // 原子操作 #include<thread> // 线程 #include<chrono> // 时间库 #include<mutex> // 互斥锁 #include<condition_variable> // 条件变量 using namespace std; std::condition_variable cv; // 条件变量：用于线程等待与唤醒 std::mutex mtx; // 互斥锁：保护共享数据 int i = 0; // 共享条件：控制线程是否退出等待 int num = 0; // 统计唤醒次数 // 等待线程函数：被阻塞，直到 i == 1 void Waits(char ch) { // 1. 创建 unique_lock 并自动加锁（必须用 unique_lock，因为 wait 内部要解锁） std::unique_lock<std::mutex> locker(mtx); std::cerr << "waiting... funa : " << ch << endl; // =================== (4) wait_for + 谓词【最安全、最实用、企业级写法】================== // 每 1s 醒一次 + 判断条件 + 防虚假唤醒 + 防死等 bool tag = false; do { // 等待 1000ms，若条件 i==1 满足则退出等待 tag = cv.wait_for(locker, std::chrono::milliseconds(1000), [ch]()->bool { cerr << "[]()->bool{}" << ++num << " " << ch << endl; return i == 1; // 条件满足返回 true }); cerr << " tag: " << tag << endl; } while (!tag); // 等待结束，线程继续执行 std::cerr << ".. finished waiting .i = " << i << "tag: " << tag << endl; } // 唤醒线程函数：负责多次唤醒，最后设置 i=1 void Signals() { // 先休眠 2 秒，让等待线程先进入 wait std::this_thread::sleep_for(std::chrono::seconds(2)); { // 加锁只是为了让打印有序，不影响条件变量 std::lock_guard<std::mutex> locker(mtx); cerr << "Notifying ... \n"; } cv.notify_all(); // 唤醒所有等待线程（会产生惊群效应） // 再次休眠 2 秒 std::this_thread::sleep_for(std::chrono::seconds(2)); { std::lock_guard<std::mutex> locker(mtx); cerr << "Notifying ... \n"; } cv.notify_all(); // 再次唤醒所有 // 最后设置条件 i=1，再唤醒 std::this_thread::sleep_for(std::chrono::seconds(2)); { std::lock_guard<std::mutex> locker(mtx); i = 1; // 满足等待条件 cerr << "Notifying again ... \n"; } cv.notify_all(); // 最终唤醒所有线程，退出等待 } int main() { // 创建 3 个等待线程 + 1 个唤醒线程 std::thread tha(Waits, 'A'); std::thread thb(Waits, 'B'); std::thread thc(Waits, 'C'); std::thread thd(Signals); tha.join(); thb.join(); thc.join(); thd.join(); return 0; }

四、经典题

4.1：三线程轮流打印 0~100

线程 A：打印 0 3 6 9 ...

线程B：打印 1 4 7 10 ...

线程C：打印 2 5 8 11 ...

std::condition_variable cv; std::mutex mtx; int i = 0; const int n = 100; void funa() { std::unique_lock<std::mutex> locker(mtx); while (i <= n) { // 条件不满足就一直等待（防虚假唤醒） while (i <= n && i % 3 != 0) { // 每 10ms 醒来检查一次 cv.wait_for(locker, std::chrono::milliseconds(10)); } if (i <= n) { printf("funa : %d \n", i); } i += 1; cv.notify_one(); // 唤醒一个线程 } } void funb() { std::unique_lock<std::mutex> locker(mtx); while (i <= n) { while (i <= n && i % 3 != 1) { cv.wait_for(locker, std::chrono::milliseconds(10)); } if (i <= n) { printf("funb : %d \n", i); } i += 1; cv.notify_one(); } } void func() { std::unique_lock<std::mutex> locker(mtx); while (i <= n) { while (i <= n && i % 3 != 2) { cv.wait_for(locker, std::chrono::milliseconds(10)); } if (i <= n) { printf("func : %d \n", i); } i += 1; cv.notify_one(); } } int main() { std::thread tha(funa), thb(funb), thc(func); tha.join(); thb.join(); thc.join(); return 0; }

4.2 三线程轮流打印 ABC （10 组）

std::condition_variable cv; std::mutex mtx; int i = 0; const int n = 10; char ch = 'A'; void funa() { std::unique_lock<std::mutex> locker(mtx); for (int j = 0; j < n; ++j) { // 必须是 A 才能打印，否则等待 while (ch != 'A') { cv.wait(locker); } printf("funa %c \n", ch); ch = 'B'; // 切换为 B cv.notify_all();// 唤醒所有线程 } } void funb() { std::unique_lock<std::mutex> locker(mtx); for (int j = 0; j < n; ++j) { while (ch != 'B') { cv.wait(locker); } printf("funb %c \n", ch); ch = 'C'; cv.notify_all(); } } void func() { std::unique_lock<std::mutex> locker(mtx); for (int j = 0; j < n; ++j) { while (ch != 'C') { cv.wait(locker); } printf("func %c \n", ch); ch = 'A'; cv.notify_all(); } } int main() { std::thread tha(funa), thb(funb), thc(func); tha.join(); thb.join(); thc.join(); return 0; }