第28章 多线程编程基础

想象一下厨房里只有一个厨师，他必须依次完成洗菜、切菜、炒菜，这就是单线程。如果引入两个厨师同时工作，一个负责洗切，一个负责烹饪，效率就大大提升，这就是多线程的核心价值——让程序“同时”做多件事，充分利用现代多核CPU的计算能力。

C++多线程支持的发展

C++在2011年发布的C++11标准之前，多线程编程依赖平台特定的API，如Windows的CreateThread或POSIX的pthread_create。这导致代码可移植性极差。C++11将线程支持纳入了标准库<thread>，为开发者提供了统一、可移植的并发编程工具。

创建你的第一个线程

使用std::thread创建线程非常简单，只需将可调用对象（函数、函数对象、lambda表达式）传递给它的构造函数。我在一个日志处理项目中首次使用多线程，将耗时的文件写入操作放到后台，主线程的响应速度立刻提升了5倍以上。

// 一个将在新线程中执行的函数
void backgroundTask() {
    std::cout << "新线程ID: " << std::this_thread::get_id() << std::endl;
    for(int i = 0; i < 3; ++i) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << "后台任务执行中... " << i+1 << std::endl;
    }
}

int main() {
    std::cout << "主线程ID: " << std::this_thread::get_id() << std::endl;

    // 创建线程对象，传入函数指针，线程立即开始执行
    std::thread t(backgroundTask);

    // 主线程继续自己的工作
    std::cout << "主线程在忙别的..." << std::endl;

    // 等待后台线程执行完毕
    t.join();

    std::cout << "主线程结束。" << std::endl;
    return 0;
}

共享数据的噩梦：数据竞争

当多个线程不加控制地读写同一块内存时，就会发生数据竞争（Data Race）。结果变得不可预测，这是多线程Bug的主要来源。

int shared_counter = 0; // 共享数据

void increment() {
    for(int i = 0; i < 100000; ++i) {
        ++shared_counter; // 危险操作！
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    // 我们期望shared_counter是200000，但实际运行结果总是小于它
    std::cout << "Final counter: " << shared_counter << std::endl;
    return 0;
}

为什么++shared_counter不是原子的？它至少包含三个步骤：从内存加载值到寄存器、增加寄存器值、存回内存。两个线程的这三个步骤可能交织，导致部分增加操作被覆盖。

互斥量：给共享数据加锁

为了解决数据竞争，我们需要互斥量（Mutex， Mutual Exclusion）。它的作用就像公共厕所的门锁，一个线程进去“使用资源”时锁上门，其他线程只能在门口等待，用完后解锁，下一个线程才能进入。

C++11提供了std::mutex。保护数据的关键模式是：用互斥量保护数据，而不是保护代码。你需要确保所有访问共享数据的路径都先获得锁。

#include <mutex>
std::mutex mtx; // 互斥量
int shared_counter = 0;

void safe_increment() {
    for(int i = 0; i < 100000; ++i) {
        mtx.lock();   // 加锁
        ++shared_counter;
        mtx.unlock(); // 解锁
    }
}

但直接使用lock()和unlock()非常危险，如果临界区代码抛出异常，可能导致锁永远无法释放，造成死锁。因此，永远优先使用RAII风格的锁管理器，如std::lock_guard。

void safer_increment() {
    for(int i = 0; i < 100000; ++i) {
        std::lock_guard<std::mutex> lock(mtx); // 构造时加锁，析构时自动解锁
        ++shared_counter;
    } // lock_guard在此析构，自动调用mtx.unlock()
}

死锁：当线程互相等待

死锁（Deadlock）是多线程编程中另一个经典问题。典型场景是两个线程各自持有一把锁，同时试图获取对方持有的锁，于是两者都无限期地等待下去。

C++标准库提供了std::lock函数来一次性锁定多个互斥量，且保证不会死锁。它通常与std::lock_guard的延迟锁定特性配合使用。

std::mutex mtx1, mtx2;

void process_with_two_locks() {
    // 使用std::lock一次性锁定两个互斥量，避免死锁
    std::lock(mtx1, mtx2);
    // 使用std::lock_guard管理锁的所有权，adopt_lock表示已锁定
    std::lock_guard<std::mutex> lock1(mtx1, std::adopt_lock);
    std::lock_guard<std::mutex> lock2(mtx2, std::adopt_lock);

    // 安全地访问受两个互斥量保护的资源...
}

等待与通知：条件变量

互斥量解决了同步问题，但有时线程需要等待某个条件成立（例如，任务队列不为空）。忙等待（不断循环检查）会浪费CPU。条件变量std::condition_variable允许线程在等待时休眠，并在条件可能满足时被唤醒。

一个典型的生产者-消费者模型：

#include <queue>
#include <condition_variable>

std::queue<int> data_queue;
std::mutex queue_mtx;
std::condition_variable data_cond;

void data_preparation_thread() {
    for(int i = 0; i < 10; ++i) {
        int data = i;
        {
            std::lock_guard<std::mutex> lock(queue_mtx);
            data_queue.push(data);
        } // 锁在此作用域结束释放
        data_cond.notify_one(); // 通知一个等待的消费者
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

void data_processing_thread() {
    while(true) {
        std::unique_lock<std::mutex> lock(queue_mtx); // 必须用unique_lock
        // 等待条件成立。如果条件不满足，会原子地解锁互斥量并阻塞线程
        data_cond.wait(lock, []{ return !data_queue.empty(); });
        // 被唤醒后，锁已重新获取，且队列非空
        int data = data_queue.front();
        data_queue.pop();
        lock.unlock(); // 可以提前解锁，处理数据时不需锁
        std::cout << "处理数据: " << data << std::endl;
        if(data == 9) break;
    }
}

线程安全的数据结构设计

仅仅在外部加锁使用STL容器（如std::vector, std::queue）是不够的，因为STL容器本身不是线程安全的。你需要封装一个线程安全的包装器。这里有个隐藏的坑：即使每个成员函数都加锁，多个操作的组合（如检查空再弹出）也不是原子的。

对于大多数应用，一个简单的线程安全队列封装就足够了：

template<typename T>
class ThreadSafeQueue {
private:
    mutable std::mutex mtx_;
    std::queue<T> data_queue_;
    std::condition_variable cond_;
public:
    ThreadSafeQueue() = default;

    void push(T new_value) {
        std::lock_guard<std::mutex> lock(mtx_);
        data_queue_.push(std::move(new_value));
        cond_.notify_one();
    }

    // 等待并弹出，提供原子性
    void wait_and_pop(T& value) {
        std::unique_lock<std::mutex> lock(mtx_);
        cond_.wait(lock, [this]{ return !data_queue_.empty(); });
        value = std::move(data_queue_.front());
        data_queue_.pop();
    }

    bool empty() const {
        std::lock_guard<std::mutex> lock(mtx_);
        return data_queue_.empty();
    }
};