C++ 多线程同步：条件变量 condition_variable 实战 | 极客日志

C++算法

C++ 多线程同步：条件变量 condition_variable 实战

C++ 条件变量用于解决多线程等待通知问题。通过 std::condition_variable 配合 std::mutex 和 std::unique_lock，实现线程间高效协作。核心接口包括 wait、notify_one 和 notify_all。使用带谓词的 wait 可避免虚假唤醒。典型应用为生产者 - 消费者模型，相比轮询机制显著降低 CPU 消耗。多生产者多消费者场景需结合队列容量限制与停止标志管理线程生命周期。

机器人发布于 2026/3/24更新于 2026/5/89 浏览

C++ 多线程同步：条件变量 condition_variable 实战

C++ 标准库中的条件变量

在多线程编程中，线程需要等待某个条件满足后再执行。例如生产者生产数据后，消费者才能消费；队列不为空时，消费者才能从中取数据。如果仅用互斥锁实现，消费者线程只能不断轮询检查条件，这会造成 CPU 资源的浪费。

引入场景

单纯的轮询会导致 CPU 空转，降低程序运行效率，条件变量就是为解决这类问题而生的。

以下是一个简单的轮询反例，消费者不断检查队列是否有数据：

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

using namespace std;

queue<int> data_queue;
mutex mtx;

// 生产者
void producer() {
    for (int i = 1; i <= 5; ++i) {
        lock_guard<mutex> lock(mtx);
        data_queue.push(i);
        cout << "生产者生产数据：" << i << endl;
    }
}

// 消费者（轮询方式）
void consumer() {
    while (true) {
        lock_guard<mutex> lock(mtx);
        if (!data_queue.empty()) {
            int data = data_queue.front();
            data_queue.pop();
            cout << "消费者消费数据：" << data << endl;
            if (data == ) ;
        }
        
    }
}

{
    ;
    ;
    t_producer.();
    t_consumer.();
     ;
}

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

using namespace std;

queue<int> data_queue;
mutex mtx;
condition_variable cv;
bool is_produced = false;

// 生产者
void producer() {
    for (int i = 1; i <= 5; ++i) {
        lock_guard<mutex> lock(mtx);
        data_queue.push(i);
        cout << "生产者生产数据：" << i << endl;
    }
    is_produced = true;
    cv.notify_all();
}

// 消费者（条件变量方式）
void consumer() {
    unique_lock<mutex> lock(mtx);
    cv.wait(lock, [](){ return !data_queue.empty() || is_produced; });
    while (!data_queue.empty()) {
        int data = data_queue.front();
        data_queue.pop();
        cout << "消费者消费数据：" << data << endl;
    }
}

int main() {
    thread t_producer(producer);
    thread t_consumer(consumer);
    t_producer.join();
    t_consumer.join();
    return 0;
}

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

using namespace std;

const int MAX_QUEUE_SIZE = 5;
queue<int> data_queue;
mutex mtx;
condition_variable cv_producer;
condition_variable cv_consumer;
bool stop_flag = false;

// 生产者函数
void producer_func(int id) {
    for (int i = 1; i <= 3; ++i) {
        unique_lock<mutex> lock(mtx);
        cv_producer.wait(lock, [](){ return data_queue.size() < MAX_QUEUE_SIZE || stop_flag; });
        if (stop_flag) break;
        int data = id * 10 + i;
        data_queue.push(data);
        cout << "生产者" << id << "生产数据：" << data << "，队列大小：" << data_queue.size() << endl;
        cv_consumer.notify_one();
    }
}

// 消费者函数
void consumer_func(int id) {
    while (true) {
        unique_lock<mutex> lock(mtx);
        cv_consumer.wait(lock, [](){ return !data_queue.empty() || stop_flag; });
        if (stop_flag && data_queue.empty()) break;
        int data = data_queue.front();
        data_queue.pop();
        cout << "消费者" << id << "消费数据：" << data << "，队列大小：" << data_queue.size() << endl;
        cv_producer.notify_one();
    }
}

int main() {
    vector<thread> producers;
    vector<thread> consumers;
    for (int i = 1; i <= 2; ++i) {
        producers.emplace_back(producer_func, i);
    }
    for (int i = 1; i <= 3; ++i) {
        consumers.emplace_back(consumer_func, i);
    }
    for (auto& t : producers) {
        t.join();
    }
    stop_flag = true;
    cv_consumer.notify_all();
    for (auto& t : consumers) {
        t.join();
    }
    cout << "所有生产和消费任务完成" << endl;
    return 0;
}