C++并发编程实战：深入理解条件变量与线程同步机制-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00272/article/details/148505504

C++并发编程实战：深入理解条件变量与线程同步机制

Cplusplus-Concurrency-In-Practice A Detailed Cplusplus Concurrency Tutorial 《C++ 并发编程指南》项目地址: https://gitcode.com/gh_mirrors/cp/Cplusplus-Concurrency-In-Practice

引言

在多线程编程中，条件变量(Condition Variable)是实现线程间同步的重要工具。本文将系统性地介绍C++标准库中的条件变量机制，帮助开发者掌握这一关键并发编程技术。

条件变量概述

条件变量是一种同步原语，它允许线程在特定条件不满足时进入等待状态，直到其他线程通知条件可能已发生变化。这种机制避免了忙等待，提高了CPU资源利用率。

C++11标准在<condition_variable>头文件中提供了两种条件变量实现：

std::condition_variable：基础条件变量
std::condition_variable_any：更通用的条件变量实现

核心组件解析

1. condition_variable类

std::condition_variable是C++标准库提供的主要条件变量实现，其核心方法包括：

wait()：使当前线程进入等待状态
notify_one()：唤醒一个等待线程
notify_all()：唤醒所有等待线程

典型使用模式需要配合互斥锁(mutex)使用：

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

// 等待线程
std::unique_lock<std::mutex> lck(mtx);
while(!ready) {
    cv.wait(lck);
}

// 通知线程
{
    std::lock_guard<std::mutex> lck(mtx);
    ready = true;
}
cv.notify_one();

2. condition_variable_any类

std::condition_variable_any是更通用的实现，可以与任何满足基本要求的锁类型配合使用，而不仅仅是std::unique_lock<std::mutex>。

条件变量与互斥锁的配合

条件变量必须与互斥锁配合使用，这是为了防止以下问题：

丢失唤醒：在检查条件和开始等待之间发生通知
虚假唤醒：线程在没有收到明确通知的情况下被唤醒

正确的使用模式应遵循"检查-等待"循环：

std::unique_lock<std::mutex> lck(mtx);
while(!condition) {
    cv.wait(lck);
}

与Pthread条件变量的对比

C++的std::condition_variable与POSIX的pthread_cond_t在功能上相似，但接口设计有所不同：

| 特性 | std::condition_variable | pthread_cond_t | |---------------------|------------------------|----------------| | 初始化方式 | 构造函数 | pthread_cond_init | | 销毁方式 | 析构函数 | pthread_cond_destroy | | 等待接口 | wait() | pthread_cond_wait | | 定时等待 | wait_for(), wait_until() | pthread_cond_timedwait | | 通知接口 | notify_one(), notify_all() | pthread_cond_signal, pthread_cond_broadcast |

C++版本提供了更安全的RAII封装，减少了资源泄漏的风险。

实际应用示例

生产者-消费者模型

#include <queue>
#include <mutex>
#include <condition_variable>

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

void producer() {
    for(int i = 0; i < 10; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        buffer.push(i);
        cv.notify_one();
    }
}

void consumer() {
    while(true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{return !buffer.empty();});
        int value = buffer.front();
        buffer.pop();
        std::cout << "Consumed: " << value << std::endl;
    }
}

线程池任务调度

条件变量常用于线程池实现中，用于工作线程等待新任务的到来：

class ThreadPool {
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop = false;
    
public:
    void start() {
        for(size_t i = 0; i < num_threads; ++i) {
            workers.emplace_back([this] {
                while(true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(queue_mutex);
                        condition.wait(lock, 
                            [this]{ return stop || !tasks.empty(); });
                        if(stop && tasks.empty()) return;
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
        }
    }
    
    // 其他成员函数...
};