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

条件变量的基本概念与工作机制

在C++多线程编程中，当多个线程需要协同处理任务，或者某个线程必须等待某个特定条件成立之后才能继续向下执行时，<condition_variable>所提供的条件变量是一种非常关键的同步工具。它通常要和互斥锁一起配合工作，原因在于等待条件的线程在检查条件以及进入等待状态的过程中，必须保证对共享数据的访问是受保护的，否则就会出现竞态条件，导致程序行为不可预期。

条件变量本身并不保存条件状态，它只是提供了一种线程间的通知机制。一个线程在条件不满足时调用等待方法阻塞自己，另一个线程在改变了共享状态并使条件满足时，通过通知方法唤醒等待者。这种协作模式有效降低了忙等待带来的CPU资源浪费。条件变量定义在<condition_variable>头文件中，是C++11标准引入的重要同步原语。

从底层机制来看，当线程调用等待方法时，会先原子性地释放传入的互斥锁，然后将自己挂起到等待队列中；当其他线程发出通知或者发生超时、虚假唤醒时，该线程会被唤醒并重新获取互斥锁，接着返回到调用处。正因为等待过程涉及锁的释放与重获，所以条件变量必须配合支持这一操作的锁类型使用，而不能使用不支持手动释放的简易锁。

核心成员方法说明

条件变量类提供了若干关键方法，理解它们对于正确运用该工具十分重要。下面列出常用成员及其作用：

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

需要特别注意的是，wait方法存在只接受锁对象以及同时接受锁和谓词两种重载形式。使用带谓词的版本能够自动处理虚假唤醒，因为方法内部会在被唤醒后反复检查谓词，只有谓词为真才真正返回。

基于条件变量的生产者消费者实现

生产者消费者模型是条件变量最典型的应用场景之一。在该模型中，生产者线程负责生成数据并放入共享队列，消费者线程从队列中取出数据进行消费。当队列为空时，消费者应当等待；当队列达到上限时，生产者应当等待。借助两个条件变量分别表达“队列非空”和“队列未满”，可以清晰高效地完成线程协作。

下面示例展示了完整的代码实现。我们使用std::queue作为共享缓冲区，用std::mutex保护其访问，用两个std::condition_variable分别通知消费者和生产者。生产者在放入数据前等待队列未满，消费者在取数据前等待队列非空，并在离开锁作用域后发出相应通知。

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

// 队列最大容量
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++;
        {
            // 获取 unique_lock 锁
            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() {
    std::vector<std::thread> producers;
    for (int i = 0; i < 2; i++) {
        producers.emplace_back(producer, i + 1);
    }
    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;
}

上述代码通过两个 condition_variable 实例实现了生产和消费速率的解耦。生产者在队列满时自动挂起，消费者在队列空时自动挂起，彼此通过通知机制恢复执行，避免了轮询检查造成的资源损耗。

条件变量使用中的关键注意点

在实际工程中使用条件变量，有几个容易出错的地方必须重视。首先是虚假唤醒问题。虚假唤醒是指线程在没有收到对应通知的情况下，wait方法就返回了，这是操作系统调度层面可能发生的正常现象。因此，调用 wait 时应当始终传入一个返回布尔值的谓词，wait 在被唤醒后会检查该谓词，若条件仍不满足就继续等待，从而屏蔽虚假唤醒的干扰。

其次是互斥锁的使用规范。条件变量的等待方法要求传入std::unique_lock<std::mutex>类型的锁，而不能使用std::lock_guard。因为 wait 方法内部需要临时释放锁并在唤醒后重新获取，lock_guard 不支持手动释放，无法满足这一要求。此外，所有对共享条件（如队列大小、标志位）的读取与修改，都必须置于互斥锁的保护范围内，否则会产生数据竞争。

关于通知方法的选择也有讲究。如果只需唤醒一个等待线程来处理新状态，使用notify_one即可，这样可以减少不必要的上下文切换；只有当共享状态的改变需要所有等待线程都重新评估条件时，才应使用notify_all。若滥用 notify_all，会导致大量线程被同时唤醒却又只有少数能真正继续执行，从而降低性能。

超时等待的正确写法

除了无限等待，条件变量还支持超时等待，即线程只等待一段时间，若超时仍未收到通知且条件不满足就自行返回。这可以通过wait_for或wait_until实现。以下示例演示了等待一秒的超时报错逻辑：

#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;
    }
}

该写法将超时时间与谓词结合，既能在条件达成时及时苏醒，也能在指定时长后自动脱离等待，适合需要定期巡检或防止永久阻塞的场景。

总结与要点回顾

条件变量是C++多线程同步中不可或缺的工具，它解决了线程间高效等待与通知的问题。通过本文的阐述可以看出，正确使用条件变量必须把握几个核心原则：始终与std::unique_lock及互斥锁配合；利用谓词消除虚假唤醒；依据场景合理选择 notify_one 与 notify_all；在需要限等待时采用 wait_for 或 wait_until。

从生产者消费者模型可以看到，条件变量让线程在条件不足时主动挂起，在条件变更后被精准唤醒，相比忙等待显著节约了计算资源。开发者在编写多线程程序时，应当把这些机制内化到代码结构中，确保共享数据访问安全且线程协作流畅。

建议进一步结合线程池、异步任务队列等复杂结构练习条件变量的运用，并借助线程检测工具验证是否存在漏通知或死锁隐患，从而在真实项目中构建出健壮的并发系统。

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