C++如何使用condition_variable条件变量

在C++多线程编程场景中，当多个线程需要协同完成某个任务，或者某个线程需要等待特定条件满足后再继续执行时，条件变量condition_variable就是非常合适的同步工具。它需要和互斥锁配合使用，避免线程在检查条件和等待条件满足的过程中出现竞态条件。

condition_variable核心概念

condition_variable是C++11标准库引入的同步原语，定义在<condition_variable>头文件中，它的作用是阻塞一个或多个线程，直到收到另一个线程的通知，或者超时、发生虚假唤醒。它必须和std::mutex配合使用，因为等待条件的线程需要先释放互斥锁，被唤醒后再重新获取互斥锁，这个过程中互斥锁负责保护共享条件的访问。

核心成员方法

• wait：阻塞当前线程，直到被通知或者发生虚假唤醒，调用时会先释放传入的互斥锁，被唤醒后重新获取互斥锁再返回。
• wait_for：阻塞线程指定的时长，超时后自动返回。
• wait_until：阻塞线程直到指定的时间点，到点后自动返回。
• notify_one：唤醒一个正在等待该条件变量的线程。
• notify_all：唤醒所有正在等待该条件变量的线程。

基础使用示例：生产者消费者模型

生产者消费者是条件变量最典型的应用场景，生产者线程生产数据放入队列，消费者线程从队列中取数据消费，当队列为空时消费者需要等待，队列满时生产者需要等待。

完整代码实现

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

// 定义队列最大容量
const int QUEUE_MAX_SIZE = 5;
// 共享队列
std::queue<int> data_queue;
// 互斥锁，保护共享队列
std::mutex queue_mutex;
// 条件变量，用于队列非空通知
std::condition_variable not_empty;
// 条件变量，用于队列未满通知
std::condition_variable not_full;
// 数据编号，用于标识生产的数据
int data_id = 0;

// 生产者线程函数
void producer(int producer_id) {
    while (true) {
        // 生产数据
        int data = data_id++;
        {
            // 获取互斥锁
            std::unique_lock<std::mutex> lock(queue_mutex);
            // 等待队列未满，第二个参数是谓词，避免虚假唤醒
            not_full.wait(lock, []() {
                return data_queue.size() < QUEUE_MAX_SIZE;
            });
            // 队列未满，放入数据
            data_queue.push(data);
            std::cout << "生产者" << producer_id << "生产数据：" << data << "，当前队列大小：" << data_queue.size() << std::endl;
        }
        // 释放锁后通知消费者队列非空
        not_empty.notify_one();
        // 模拟生产耗时
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

// 消费者线程函数
void consumer(int consumer_id) {
    while (true) {
        int data;
        {
            // 获取互斥锁
            std::unique_lock<std::mutex> lock(queue_mutex);
            // 等待队列非空，谓词避免虚假唤醒
            not_empty.wait(lock, []() {
                return !data_queue.empty();
            });
            // 队列非空，取出数据
            data = data_queue.front();
            data_queue.pop();
            std::cout << "消费者" << consumer_id << "消费数据：" << data << "，当前队列大小：" << data_queue.size() << std::endl;
        }
        // 释放锁后通知生产者队列未满
        not_full.notify_one();
        // 模拟消费耗时
        std::this_thread::sleep_for(std::chrono::milliseconds(150));
    }
}

int main() {
    // 创建2个生产者线程
    std::vector<std::thread> producers;
    for (int i = 0; i < 2; i++) {
        producers.emplace_back(producer, i + 1);
    }
    // 创建3个消费者线程
    std::vector<std::thread> consumers;
    for (int i = 0; i < 3; i++) {
        consumers.emplace_back(consumer, i + 1);
    }
    // 等待所有线程执行（实际场景中可添加退出逻辑）
    for (auto& t : producers) {
        t.join();
    }
    for (auto& t : consumers) {
        t.join();
    }
    return 0;
}

使用注意事项

避免虚假唤醒

虚假唤醒是指线程在没有收到对应通知的情况下，wait方法就返回了，这是操作系统层面的正常现象。因此调用wait方法时，必须传入一个谓词（返回bool的可调用对象），wait方法会在被唤醒后检查谓词，如果谓词返回false就继续等待，这样就能避免虚假唤醒导致的问题。上面的示例中wait的第二个参数就是谓词，用来检查队列是否未满或者非空。

互斥锁的使用规范

condition_variable的wait方法要求传入的是std::unique_lock<std::mutex>类型的锁，不能使用std::lock_guard，因为wait方法需要能够释放和重新获取互斥锁，而lock_guard不支持手动释放。同时，共享条件（比如示例中的队列大小）的访问必须放在互斥锁的保护范围内，否则会出现竞态条件。

notify的选择

如果只需要唤醒一个等待线程，使用notify_one即可，减少线程上下文切换的开销；如果需要唤醒所有等待线程，比如共享状态发生变更，所有等待线程都需要重新检查条件，这时候才使用notify_all。如果错误使用notify_all，会导致不必要的线程唤醒，降低程序性能。

超时等待的使用

如果需要线程等待一段时间就自动返回，可以使用wait_for或者wait_until方法，比如下面的示例是等待1秒后如果还没被通知就返回：

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

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

void wait_with_timeout() {
    std::unique_lock<std::mutex> lock(mtx);
    // 等待1秒，超时或者收到通知返回
    if (cv.wait_for(lock, std::chrono::seconds(1), []() { return ready; })) {
        std::cout << "等待成功，条件已满足" << std::endl;
    } else {
        std::cout << "等待超时，条件未满足" << std::endl;
    }
}

condition_variable多线程同步std_thread互斥锁wait_notify修改时间：2026-07-09 14:15:33