C++ 标准库 <condition_variable>（实战总结）

C++ 标准库 <condition_variable> 的核心机制与实战应用

在多线程编程中，线程之间的协调与同步是一个绕不开的难题。想象一下，你有一家餐厅，服务员（线程）在等待顾客（主线程）点餐后才开始准备食物。如果服务员不停地轮询“有没有人点餐？”，那不仅浪费资源，还容易出错。这种“忙等”行为在编程中称为 忙等待（busy-waiting），是效率低下且不可取的方案。

C++ 标准库中的 <condition_variable> 正是为了解决这类问题而生的。它与 std::mutex 配合使用，提供了一种高效、安全的线程间通信机制，让线程可以在条件不满足时“休眠”等待，一旦条件满足，再被唤醒继续执行。这种机制就像餐厅里服务员拿着一个“叫号器”——只有当有人点餐（条件满足），叫号器才会响，服务员才会醒来工作。

本篇文章将带你从零开始理解 C++ 标准库 <condition_variable> 的基本用法、常见陷阱以及实战案例，帮助你真正掌握多线程同步的艺术。

条件变量的基本组成与工作流程

C++ 标准库 <condition_variable> 的核心由两个类构成：

• std::condition_variable：用于等待和唤醒线程。
• std::condition_variable_any：支持任意类型的互斥锁，但性能略低。

通常我们使用 std::condition_variable，它必须配合 std::unique_lock<std::mutex> 一起使用。三者关系可以比喻为：

一个守门人（mutex）负责保护共享资源，一个叫号器（condition_variable）负责通知，一个等待者（线程）在条件不满足时“睡着”等通知。

核心流程如下：

1. 线程获取互斥锁（lock）。
2. 检查条件是否满足。
3. 若不满足，调用 wait()，释放锁并进入等待状态。
4. 当其他线程通过 notify_one() 或 notify_all() 唤醒时，等待线程重新获取锁，检查条件。
5. 条件满足后，继续执行。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void worker_thread() {
    // 1. 获取互斥锁
    std::unique_lock<std::mutex> lock(mtx);
    
    // 2. 等待条件 ready 变为 true
    cv.wait(lock, []{ return ready; });
    
    // 3. 条件满足，开始工作
    std::cout << "Worker thread is running!" << std::endl;
}

void main_thread() {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    
    // 1. 获取互斥锁
    std::lock_guard<std::mutex> lock(mtx);
    
    // 2. 设置条件为 true
    ready = true;
    
    // 3. 唤醒一个等待的线程
    cv.notify_one();
    
    std::cout << "Main thread signaled the worker." << std::endl;
}

int main() {
    std::thread t1(worker_thread);
    std::thread t2(main_thread);
    
    t1.join();
    t2.join();
    
    return 0;
}

代码说明：

• cv.wait(lock, []{ return ready; }) 是关键：它会自动释放锁，等待通知，被唤醒后重新加锁，并再次检查 lambda 表达式是否为真。
• notify_one() 只唤醒一个等待线程，notify_all() 唤醒所有。
• 使用 std::lock_guard 是为了确保 ready = true 操作在锁保护下完成，避免竞态。

条件变量的三种等待方式：wait、wait_for、wait_until

std::condition_variable 提供了三种等待方法，分别适用于不同场景：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void timed_worker() {
    std::unique_lock<std::mutex> lock(mtx);
    
    // 等待最多 3 秒，或条件满足提前返回
    auto result = cv.wait_for(lock, std::chrono::seconds(3), []{ return ready; });
    
    if (result) {
        std::cout << "Condition met, worker started!" << std::endl;
    } else {
        std::cout << "Timeout: condition not met within 3 seconds." << std::endl;
    }
}

int main() {
    std::thread t1(timed_worker);
    
    std::this_thread::sleep_for(std::chrono::seconds(2));
    
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    
    cv.notify_one();
    
    t1.join();
    return 0;
}

关键点：

• wait_for 返回 true 表示条件满足，false 表示超时。
• 适合用于网络请求、资源加载等有时间限制的操作。

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

生产者-消费者是多线程编程的经典问题。使用 C++ 标准库 <condition_variable> 可以优雅地实现。

#include <iostream>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <chrono>

std::queue<int> buffer;
std::mutex mtx;
std::condition_variable cv;

const int MAX_SIZE = 5;

void producer() {
    for (int i = 1; i <= 10; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        
        // 等待缓冲区有空位
        cv.wait(lock, []{ return buffer.size() < MAX_SIZE; });
        
        buffer.push(i);
        std::cout << "Produced: " << i << " (buffer size: " << buffer.size() << ")" << std::endl;
        
        // 唤醒消费者
        cv.notify_one();
        
        // 模拟生产耗时
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

void consumer() {
    for (int i = 1; i <= 10; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        
        // 等待缓冲区有数据
        cv.wait(lock, []{ return !buffer.empty(); });
        
        int item = buffer.front();
        buffer.pop();
        std::cout << "Consumed: " << item << " (buffer size: " << buffer.size() << ")" << std::endl;
        
        // 唤醒生产者
        cv.notify_one();
        
        // 模拟消费耗时
        std::this_thread::sleep_for(std::chrono::milliseconds(150));
    }
}

int main() {
    std::thread p(producer);
    std::thread c(consumer);
    
    p.join();
    c.join();
    
    return 0;
}

设计思路：

• 生产者等待缓冲区未满，消费者等待缓冲区非空。
• 通过 notify_one() 唤醒对方，避免资源浪费。
• 使用 std::queue 作为共享缓冲区，std::mutex 保护其访问。

常见陷阱与最佳实践

在使用 C++ 标准库 <condition_variable> 时，有几个常见错误需要特别注意：

1. 虚假唤醒（Spurious Wakeup）

即使没有调用 notify_*，线程也可能被意外唤醒。因此，永远不要用 if 判断条件，必须用 while。

// ❌ 错误写法
if (ready) {
    cv.wait(lock);
}

// ✅ 正确写法
while (!ready) {
    cv.wait(lock);
}

2. 锁未正确保护条件变量

条件变量的等待必须在锁的保护下进行。否则可能在 wait() 调用前，条件已经被修改。

3. 通知与等待顺序问题

如果先调用 notify_one()，再调用 wait()，线程将永远等待。建议使用“先等待，后通知”的顺序。

总结与建议

C++ 标准库 <condition_variable> 是多线程编程中不可或缺的工具。它解决了忙等待的问题，让线程在等待时真正“休眠”，节省 CPU 资源，提升程序效率。

• 掌握 wait、wait_for、wait_until 三种等待方式。
• 善用 std::unique_lock 与 std::lock_guard。
• 始终使用 while 检查条件，防止虚假唤醒。
• 在生产者-消费者等场景中，合理使用 notify_one() 和 notify_all()。

对于初学者来说，建议先从简单的“线程通知”例子入手，再逐步构建复杂模型。多写、多调试，才能真正掌握同步的精髓。

在现代 C++ 编程中，C++ 标准库 <condition_variable> 已成为多线程程序的“标配”。无论你是开发后台服务、游戏引擎，还是嵌入式系统，理解并熟练使用它，都是迈向高级开发者的重要一步。