【多线程编程进阶】：std::condition_variable的错误处理和异常安全实战

# 1. 多线程编程进阶概述

多线程编程是现代软件开发中不可或缺的一部分，尤其是在需要利用多核处理器能力的高性能计算场景。随着CPU核心数的不断增加，合理有效地管理多个线程，确保线程间的高效通信和协调，是实现高性能应用的关键。

在多线程编程中，线程同步是一大挑战。开发者需要解决竞态条件、死锁等问题，确保数据的一致性和程序的稳定性。传统的同步机制，如互斥锁(Mutexes)，虽然提供了基本的同步能力，但也带来了诸如效率低下和复杂性增加等问题。因此，开发者们在实践中不断寻找更好的同步工具。

在本章中，我们将探讨`std::condition_variable`这一现代C++库提供的线程同步机制。它能够在线程间建立基于特定条件的通知机制，从而在某些条件下唤醒线程，提高线程利用率和程序的运行效率。通过深入了解和实践，`std::condition_variable`会成为我们构建高效多线程应用中的得力助手。

# 2. std::condition_variable的基础

## 2.1 多线程同步机制回顾

### 2.1.1 互斥锁(Mutexes)的基本使用

互斥锁（Mutex）是多线程编程中用于同步的基本工具。它确保了共享资源在同一时间只有一个线程可以访问，防止了并发访问导致的数据不一致问题。

#include <mutex>

std::mutex mtx;

void print_even(int n) {
    for (int i = 0; i < n; ++i) {
        mtx.lock();  // 保证同一时刻只有一个线程可以执行下面的代码
        if (i % 2 == 0) {
            std::cout << i << " ";
        }
        mtx.unlock();  // 解锁，允许其他线程获取互斥锁
    }
}

void print_odd(int n) {
    for (int i = 0; i < n; ++i) {
        mtx.lock();
        if (i % 2 != 0) {
            std::cout << i << " ";
        }
        mtx.unlock();
    }
}

int main() {
    std::thread t1(print_even, 100);
    std::thread t2(print_odd, 100);
    t1.join();
    t2.join();
    return 0;
}

### 2.1.2 条件变量与互斥锁的关系

条件变量通常与互斥锁一起使用，允许线程在某个条件不满足时被阻塞，直到其他线程改变了条件并发出通知。

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

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

void print_id(int id) {
    std::unique_lock<std::mutex> lck(mtx);
    while (!ready) {
        cv.wait(lck);  // 当条件不满足时，阻塞当前线程并释放锁
    }
    std::cout << "Thread " << id << '\n';
}

void go() {
    std::unique_lock<std::mutex> lck(mtx);
    ready = true;  
    cv.notify_all();  // 唤醒所有等待线程
}

int main() {
    std::thread threads[10];
    for (int i = 0; i < 10; ++i) {
        threads[i] = std::thread(print_id, i);
    }
    std::cout << "10 threads ready to race...\n";
    go();                   // 通知所有线程，条件已满足
    for (auto& th : threads) {
        th.join();
    }
    return 0;
}

## 2.2 std::condition_variable的引入和优势

### 2.2.1 std::condition_variable的定义和功能

std::condition_variable是C++11中引入的一种同步原语，用于阻塞一个或多个线程，直到另外一个线程修改了共享数据，并且发出一个条件变量的通知。与std::mutex相比，它允许线程在某些条件不满足时主动放弃CPU资源，降低了资源的竞争。

### 2.2.2 与std::mutex结合使用的实例分析

std::mutex mut;
std::condition_variable cond;
std::queue<int> data_queue;  // 用于存储生产和消费数据的队列
bool ready = false;
bool processed = false;

void consume() {
    while (true) {
        std::unique_lock<std::mutex> lock(mut);
        while (data_queue.empty() && !processed) {  // 当队列为空且没有处理完的数据时，等待
            cond.wait(lock);
        }

        if (!data_queue.empty()) {
            int data = data_queue.front();
            data_queue.pop();
            std::cout << "Consumed " << data << std::endl;
            processed = true;
            cond.notify_one();  // 通知生产者数据被消费
        }

        if (data_queue.empty()) {  // 检查是否有更多的数据需要处理
            break;
        }
    }
}

void produce() {
    for (int i = 0; i < 10; ++i) {
        std::unique_lock<std::mutex> lock(mut);
        data_queue.push(i);  // 生产数据
        std::cout << "Produced " << i << std::endl;
        processed = false;
        cond.notify_one();  // 通知消费者有一个新的数据可消费
    }
}

int main() {
    std::thread producer(produce);
    std::thread consumer(consume);
    producer.join();
    consumer.join();
    return 0;
}

以上代码演示了如何结合使用`std::mutex`和`std::condition_variable`，创建了一个简单的生产者-消费者模型。在生产者线程中，每当生产一个数据后，通过条件变量通知消费者线程有新数据可供消费。在消费者线程中，通过等待条件变量来暂停执行，直到生产者线程通知有新的数据到来。这样可以有效避免消费者线程忙等待（busy-waiting），提高程序的效率和性能。

# 3. std::condition_variable的错误处理策略

## 3.1 常见错误类型及示例

### 3.1.1 条件变量的伪唤醒问题

在多线程环境中，条件变量的伪唤醒是一种常见的问题。伪唤醒指的是线程在没有收到特定通知的情况下，仍然被唤醒的现象。这可能导致线程继续执行，但此时状态可能并未达到其等待的条件。

**代码示例：**

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

std::condition_variable cv;
std::mutex cv_m;
int cargo = 0;

bool ready = false;

void consumer() {
    std::unique_lock<std::mutex> lk(cv_m);
    while (!ready) {
        cv.wait(lk);
    }
    std::cout << "Consuming " << cargo << std::endl;
}

void producer() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
        std::lock_guard<std::mutex> lk(cv_m);
        cargo = 42;
        ready = true;
    }
    cv.notify_one();
}

int main() {
    std::thread t1(consumer);
    std::threa