线程同步与互斥：条件变量与生产者-消费者模型详解

暗茧

1. 线程同步与互斥基础

1.1 同步的核心概念

在并发编程中，同步的本质是在保证数据安全的前提下，让线程访问资源具有可预测的顺序性。想象一下银行柜台办理业务的情景：多个客户（线程）需要访问同一个柜台（共享资源），如果没有排队机制（同步），所有人都会一拥而上争夺服务，导致混乱。

同步机制的关键特点：

需要建立在互斥的基础上（先保证安全，再考虑顺序）
通过排队等待机制实现有序访问
避免了线程无限制地竞争资源

注意：同步不是替代互斥，而是在互斥基础上增加顺序控制。就像银行既要防止多人同时操作同一个账户（互斥），又要让客户按顺序办理业务（同步）。

1.2 同步与互斥的关系

互斥和同步是并发控制的两个核心维度：

mermaid复制graph TD
    A[并发控制] --> B[互斥]
    A --> C[同步]
    B --> D[解决同时访问问题]
    B --> E[工具：互斥锁、读写锁]
    C --> F[解决执行顺序问题]
    C --> G[工具：条件变量、信号量]

互斥关注的是"能不能访问"的问题，而同步解决的是"谁先谁后"的问题。在实际开发中，我们通常需要同时使用这两种机制：

纯互斥场景：线程访问顺序不可预测
互斥+同步场景：线程按预定顺序访问资源

2. 条件变量深度解析

2.1 条件变量工作原理

条件变量可以理解为线程间的通知机制，它包含两个核心组件：

等待队列：存放等待特定条件的线程
通知机制：当条件满足时唤醒等待线程

工作流程示例：

线程A检查条件，发现不满足
线程A加入等待队列并释放锁
线程B修改共享状态使条件满足
线程B发送通知唤醒等待线程
线程A被唤醒，重新检查条件

2.2 关键API详解

2.2.1 pthread_cond_wait的原子性

pthread_cond_wait(&cond, &mutex)的内部操作是原子的，这保证了：

将线程加入等待队列
释放互斥锁
将线程设为等待状态

这三个操作要么全部完成，要么都不执行，避免了竞态条件。如果这三个操作不是原子的，可能会出现以下问题：

c复制// 错误示例：非原子操作导致的问题
pthread_mutex_lock(&mutex);
while(条件不满足){
    pthread_mutex_unlock(&mutex);  // 非原子操作点1
    // 这里如果发生线程切换...
    pthread_cond_wait(&cond);      // 非原子操作点2
    // 可能导致信号丢失
}

2.2.2 通知函数的选择

函数	行为特点	适用场景
pthread_cond_signal	唤醒至少一个等待线程	资源有限，只需唤醒一个消费者
pthread_cond_broadcast	唤醒所有等待线程	状态变化影响所有等待者

经验法则：在不确定有多少线程需要被唤醒时优先使用broadcast，但要注意可能引发的"惊群效应"。

2.3 条件变量的正确使用模式

正确的条件变量使用模板：

c复制pthread_mutex_lock(&mutex);
while(条件不满足){  // 必须用while而不是if
    pthread_cond_wait(&cond, &mutex);
}
// 处理临界区
pthread_mutex_unlock(&mutex);

关键注意事项：

必须用while循环检查条件，防止虚假唤醒
条件检查必须在锁的保护下进行
修改条件状态时也需要持有锁

3. 生产者-消费者模型实现

3.1 模型核心思想

生产者-消费者模型解决的是有界缓冲区问题，其核心约束可以总结为：

生产者不能向满缓冲区添加数据
消费者不能从空缓冲区取出数据
缓冲区访问必须互斥

模型优势体现在：

解耦：生产者和消费者不需要知道对方的存在
缓冲：平衡生产速度和消费速度的差异
并发：生产和消费过程可以并行进行

3.2 基于阻塞队列的实现

3.2.1 BlockingQueue设计要点

cpp复制template <class T>
class BlockQueue {
private:
    std::queue<T> q_;
    int maxcap_;
    pthread_mutex_t mutex_;
    pthread_cond_t c_cond_;  // 消费者条件变量
    pthread_cond_t p_cond_;  // 生产者条件变量
    
public:
    void push(const T& item) {
        pthread_mutex_lock(&mutex_);
        while(q_.size() == maxcap_) {
            pthread_cond_wait(&p_cond_, &mutex_);
        }
        q_.push(item);
        pthread_cond_signal(&c_cond_);
        pthread_mutex_unlock(&mutex_);
    }
    
    T pop() {
        pthread_mutex_lock(&mutex_);
        while(q_.empty()) {
            pthread_cond_wait(&c_cond_, &mutex_);
        }
        T item = q_.front();
        q_.pop();
        pthread_cond_signal(&p_cond_);
        pthread_mutex_unlock(&mutex_);
        return item;
    }
};

3.2.2 多生产者多消费者问题

在多生产者和多消费者场景下，需要注意：

虚假唤醒：使用while循环而非if判断条件
通知策略：通常使用signal而非broadcast避免过度竞争
性能优化：可以设置高低水位线减少通知频率

3.3 基于环形队列的实现

3.3.1 环形队列设计特点

cpp复制template<class T>
class RingQueue {
private:
    std::vector<T> ringqueue_;
    int cap_;
    int c_step_;  // 消费者位置
    int p_step_;  // 生产者位置
    sem_t cdata_sem_;  // 数据信号量
    sem_t pspace_sem_; // 空间信号量
    pthread_mutex_t c_mutex_;
    pthread_mutex_t p_mutex_;
    
public:
    void Push(const T& item) {
        sem_wait(&pspace_sem_);  // P(空间)
        pthread_mutex_lock(&p_mutex_);
        ringqueue_[p_step_] = item;
        p_step_ = (p_step_ + 1) % cap_;
        pthread_mutex_unlock(&p_mutex_);
        sem_post(&cdata_sem_);   // V(数据)
    }
    
    void Pop(T* item) {
        sem_wait(&cdata_sem_);   // P(数据)
        pthread_mutex_lock(&c_mutex_);
        *item = ringqueue_[c_step_];
        c_step_ = (c_step_ + 1) % cap_;
        pthread_mutex_unlock(&c_mutex_);
        sem_post(&pspace_sem_);  // V(空间)
    }
};

3.3.2 信号量的使用技巧

信号量初始化：
- 空间信号量初始化为缓冲区容量
- 数据信号量初始化为0
PV操作顺序：
- 生产者：先P(空间)，再V(数据)
- 消费者：先P(数据)，再V(空间)
锁与信号量的配合：
- 先操作信号量，再操作锁
- 信号量控制资源数量，锁保护具体操作

4. 线程池设计与实现

4.1 线程池核心组件

一个完整的线程池通常包含以下部分：

任务队列：存放待处理的任务
工作线程组：执行任务的线程集合
同步机制：包括互斥锁和条件变量
管理接口：任务提交、线程控制等方法

4.2 线程池实现关键点

4.2.1 工作线程函数

cpp复制static void* handler(void* args) {
    Thread_pool* tp = static_cast<Thread_pool*>(args);
    while(true) {
        tp->lock();
        while(tp->is_empty()) {
            tp->sleep();
        }
        Task t = tp->pop();
        tp->unlock();
        t();  // 执行任务
    }
    return nullptr;
}

4.2.2 任务调度流程

主线程创建线程池
工作线程启动并等待任务
外部提交任务到队列
线程池唤醒工作线程
工作线程获取并执行任务
重复步骤3-5

4.3 性能优化策略

动态线程数：根据负载自动调整线程数量
任务优先级：实现优先级队列支持紧急任务
工作窃取：空闲线程从其他线程的任务队列窃取任务
批量提交：支持任务组批量提交减少锁竞争

5. 线程安全实践

5.1 STL容器线程安全

STL容器默认不是线程安全的，使用时需要注意：

读操作：多个线程同时读是安全的
写操作：任何写操作都需要同步
复合操作：即使由读操作组成的复合操作也需要同步

cpp复制// 不安全示例
if(!queue.empty()) {  // 竞态条件
    Item item = queue.front();
    queue.pop();
}

// 安全写法
pthread_mutex_lock(&mutex);
if(!queue.empty()) {
    Item item = queue.front();
    queue.pop();
}
pthread_mutex_unlock(&mutex);

5.2 智能指针线程安全

智能指针的线程安全特性：

unique_ptr：完全线程安全（因为不可共享）
shared_ptr：
- 引用计数操作是原子的
- 指向的对象访问需要额外同步
- 不同shared_ptr实例可以安全地从多个线程访问

cpp复制// 安全使用示例
std::shared_ptr<Data> global_ptr;

void thread_func() {
    std::shared_ptr<Data> local_ptr;
    {
        std::lock_guard<std::mutex> lock(global_mutex);
        local_ptr = global_ptr;  // 引用计数原子增加
    }
    // 使用local_ptr不需要锁
}

5.3 单例模式线程安全

5.3.1 双重检查锁定模式

cpp复制template <typename T>
class Singleton {
    volatile static T* inst;
    static std::mutex lock;
public:
    static T* GetInstance() {
        if(inst == nullptr) {  // 第一次检查
            std::lock_guard<std::mutex> guard(lock);
            if(inst == nullptr) {  // 第二次检查
                inst = new T();
            }
        }
        return inst;
    }
};

5.3.2 注意事项

volatile关键字：防止编译器优化导致指令重排
内存屏障：确保初始化顺序正确
静态局部变量：C++11后可用更简洁的静态局部变量实现

cpp复制// C++11后推荐的线程安全单例
template<typename T>
class Singleton {
public:
    static T& GetInstance() {
        static T instance;
        return instance;
    }
};