c++中std::condition_variable、wait_for() 和 wait_until()的使用详解和示例

std::condition_variable 是 C++11 引入的一个 线程同步原语，用于实现线程之间的 等待与通知机制，配合 std::mutex 一起使用。

1、 用途概述

它通常用于以下场景：

• 生产者-消费者模型；
• 等待某一条件满足（例如缓冲区不为空）；
• 实现线程阻塞、解阻塞机制；
• 控制线程顺序执行。

2、 使用核心原理

成员函数：

注意：

• wait() 必须配合 std::unique_lock<std::mutex> 使用；
• 必须用 while 轮询条件，避免 虚假唤醒；
• 被唤醒时会自动尝试重新上锁。

3、 简单示例：生产者-消费者

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

std::mutex mtx;
std::condition_variable cv;
std::queue<int> buffer;
const unsigned int MAX_BUFFER_SIZE = 5;

void producer(int id) {
    for (int i = 0; i < 10; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [] { return buffer.size() < MAX_BUFFER_SIZE; }); // 等待缓冲区非满
        buffer.push(i);
        std::cout << "Producer " << id << " produced: " << i << "\n";
        cv.notify_all(); // 通知消费者线程
    }
}

void consumer(int id) {
    for (int i = 0; i < 10; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [] { return !buffer.empty(); }); // 等待缓冲区非空
        int val = buffer.front();
        buffer.pop();
        std::cout << "Consumer " << id << " consumed: " << val << "\n";
        cv.notify_all(); // 通知生产者线程
    }
}

int main() {
    std::thread p1(producer, 1);
    std::thread c1(consumer, 1);

    p1.join();
    c1.join();
    return 0;
}

示例详解

cv.wait(lock, []{ return 条件; });

该语句表示：

• 如果条件为 false，线程阻塞并自动释放锁；
• 如果为 true，直接继续执行；
• 被 notify_one() 或 notify_all() 唤醒时，会再次检测条件，防止虚假唤醒。

4、 常见问题与注意事项

5、 实用建议

1. 始终使用 wait(lock, predicate) 形式；
2. 在共享资源操作之间加锁，确保线程安全；
3. 用 notify_one() 通知单个等待线程，notify_all() 通知全部（可导致“惊群”）；
4. 不要用 std::lock_guard，wait() 需要能释放和重新上锁的 unique_lock。

6、wait_for和wait_until

wait_for() 和 wait_until() 区别

都返回一个 std::cv_status，表示唤醒原因：

• cv_status::no_timeout：被 notify_one/all() 唤醒；
• cv_status::timeout：超时了（条件还不满足）。

示例：超时等待队列数据（使用 wait_for）

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

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

bool data_ready = false;

void consumer_with_timeout() {
    std::unique_lock<std::mutex> lock(mtx);
    std::cout << "Consumer waiting for data...\n";

    // 等待最多 3 秒
    if (cv.wait_for(lock, std::chrono::seconds(3), [] { return data_ready; })) {
        // 如果在 3 秒内 data_ready == true
        std::cout << "Consumer got data: " << buffer.front() << "\n";
        buffer.pop();
    } else {
        std::cout << "Consumer timed out waiting for data.\n";
    }
}

void producer_delayed() {
    std::this_thread::sleep_for(std::chrono::seconds(5));  // 故意延迟超过超时时间
    std::unique_lock<std::mutex> lock(mtx);
    buffer.push(42);
    data_ready = true;
    std::cout << "Producer produced data.\n";
    cv.notify_one();
}

int main() {
    std::thread consumer(consumer_with_timeout);
    std::thread producer(producer_delayed);

    consumer.join();
    producer.join();
    return 0;
}

示例：使用 wait_until（指定时间点）

void consumer_wait_until() {
    std::unique_lock<std::mutex> lock(mtx);
    auto expire_time = std::chrono::steady_clock::now() + std::chrono::seconds(3);

    std::cout << "Consumer waiting until specific time...\n";
    if (cv.wait_until(lock, expire_time, [] { return data_ready; })) {
        std::cout << "Consumer got data: " << buffer.front() << "\n";
        buffer.pop();
    } else {
        std::cout << "Consumer wait_until expired without data.\n";
    }
}

总结要点

• wait_for 是等待相对时间，适合写成固定超时逻辑；
• wait_until 是等待绝对时间点，适合调度定时任务；
• 永远使用谓词版本（wait_for(lock, duration, pred)）来避免虚假唤醒；
• 返回值可以判断是超时还是正常唤醒。