C++ 11 新特性 多线程支持

C++11 引入的 多线程支持 ，标志着 C++ 正式迈入原生并发编程的时代。在此之前，开发者必须依赖平台特定的 API（如 POSIX 的 pthread 或 Windows 的 CreateThread），代码难以移植且晦涩难懂。

C++11 标准库（<thread>, <mutex>, <atomic>, <future>）将多线程编程提升到了语言级抽象。

它的核心目标是：提供一套跨平台、类型安全且高效的工具，让开发者能轻松利用多核处理器的能力，同时通过 RAII 机制规避死锁和资源泄漏。

下面我将从核心组件、实战案例、底层机制及避坑指南四个方面为你详细介绍。

1. 核心组件概览

C++11 的多线程库主要由以下四部分组成：

• std::thread：线程管理的基石，用于启动和管理线程。
• std::mutex & std::lock_guard：用于保护共享数据，防止"数据竞争"。
• std::atomic：提供无锁（lock-free）的原子操作，用于高性能计数或标志位。
• std::future & std::async：用于异步任务，优雅地获取线程执行结果。

2. 实战案例：从入门到进阶

为了让你更好地理解，我将通过三个递进的例子来展示这些特性的用法。

🌱 案例一：基础线程管理 (std::thread)

这是最简单的"发射后不管"模式，或者需要等待任务结束的场景。

场景：主线程启动两个子线程分别打印奇数和偶数。

#include <iostream>
#include <thread>
#include <vector>
#include <chrono>

// 线程执行的函数
void print_numbers(const std::string& label, int start, int end) {
    for (int i = start; i < end; ++i) {
        std::cout << label << ": " << i << std::endl;
        // 模拟耗时操作，让线程切换更明显
        std::this_thread::sleep_for(std::chrono::milliseconds(50)); 
    }
}

int main() {
    // 1. 创建线程对象
    // 注意：线程在构造时立即开始执行
    std::thread t1(print_numbers, "奇数线程", 1, 5);
    std::thread t2(print_numbers, "偶数线程", 2, 6);

    std::cout << "主线程: 等待子线程结束..." << std::endl;

    // 2. 加入 (Join) 线程
    // 主线程阻塞，直到 t1 和 t2 执行完毕
    // 如果不 join 而直接退出 main，子线程会被强制终止（std::terminate）
    t1.join();
    t2.join();

    std::cout << "主线程: 所有任务完成！" << std::endl;
    return 0;
}

🛡️ 案例二：线程安全与锁 (std::mutex & std::lock_guard)

当多个线程同时修改同一个变量（如计数器）时，会发生数据竞争，导致结果不可预测。我们需要用锁来保护。

场景：两个线程同时对一个全局计数器加 1。

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

std::mutex mtx; // 互斥锁，用于保护共享资源
int shared_counter = 0;

void safe_increment(int id, int iterations) {
    for (int i = 0; i < iterations; ++i) {
        // 【关键点】使用 std::lock_guard (RAII 机制)
        // 1. 构造时自动加锁 (mtx.lock())
        // 2. 析构时（作用域结束）自动解锁 (mtx.unlock())
        // 即使中间发生异常，锁也能被正确释放，防止死锁
        std::lock_guard<std::mutex> lock(mtx);
        
        // 临界区：同一时间只能有一个线程执行这里的代码
        shared_counter++;
        
        // lock 离开作用域，自动解锁
    }
}

int main() {
    const int threads_count = 5;
    const int iterations = 1000;
    std::vector<std::thread> threads;

    for (int i = 0; i < threads_count; ++i) {
        threads.emplace_back(safe_increment, i, iterations);
    }

    for (auto& t : threads) {
        t.join();
    }

    // 预期结果：5 * 1000 = 5000
    std::cout << "最终计数: " << shared_counter << std::endl; 
    return 0;
}

🚀 案例三：异步任务与获取结果 (std::async & std::future)

std::thread 只能"发射"，很难直接拿回结果。std::async 和 std::future 组合解决了这个问题，就像"点外卖"：你下单（async），拿到一张小票（future），你可以继续做别的事，等饭好了凭小票取餐（get）。

场景：异步计算一个耗时的斐波那契数列。

#include <iostream>
#include <future>
#include <chrono>
#include <thread>

// 一个耗时的计算任务
long long fibonacci(int n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

int main() {
    std::cout << "主线程: 开始异步计算..." << std::endl;

    // 【关键点】std::async 启动异步任务
    // std::launch::async 强制在新线程中运行
    std::future<long long> result = std::async(std::launch::async, fibonacci, 40);

    // 主线程在等待结果期间可以做其他事（比如打印进度）
    while (result.wait_for(std::chrono::milliseconds(100)) != std::future_status::ready) {
        std::cout << "计算中..." << std::endl;
    }

    // 【关键点】.get() 获取结果
    // 如果任务没完成，这里会阻塞等待；如果完成了，直接返回结果
    long long value = result.get();

    std::cout << "计算结果: " << value << std::endl;
    return 0;
}

3. 底层机制：RAII 与 原子操作

🛡️ RAII 锁机制 (std::lock_guard)

在 C++98 中，我们容易忘记 unlock()，或者在异常路径下忘记解锁，导致死锁。C++11 引入了 RAII（资源获取即初始化）风格的锁。
std::lock_guard 在构造时加锁，在析构（离开作用域）时自动解锁。这保证了无论函数是正常返回还是抛出异常，锁都会被释放。

⚡ 原子操作 (std::atomic)

对于简单的变量（如 int counter），使用 mutex 可能会带来性能开销（因为涉及内核态切换）。std::atomic<T> 利用 CPU 的底层指令（如 x86 的 LOCK 前缀指令）保证操作的原子性，无需锁即可实现线程安全。

#include <atomic>
#include <thread>

std::atomic<int> atomic_counter(0); // 原子计数器

void atomic_increment() {
    // 这里的 ++ 操作是原子的，不需要加锁，速度极快
    atomic_counter++; 
}

4. 总结与避坑指南

特性	用途	核心优势
std::thread	启动线程	跨平台，统一接口
std::mutex	互斥锁	保护临界区
std::lock_guard	锁的包装器	自动加解锁，防止死锁
std::atomic	原子变量	高性能，无锁并发
std::future	异步结果	优雅地获取线程返回值

⚠️ 避坑指南

1. 必须 join 或 detach ：
   std::thread 对象析构时，如果线程还在运行且没有 join 或 detach，程序会直接崩溃（调用 std::terminate）。务必在作用域结束前处理。
2. 避免数据竞争 ：
   只要有多线程读写同一数据，且至少有一个是写操作，就必须加锁或使用原子变量。
3. 小心死锁 ：
   如果在不同线程中以不同顺序获取多个锁（例如线程 A 锁 1 然后锁 2，线程 B 锁 2 然后锁 1），会导致死锁。尽量使用 std::lock 一次性锁定多个互斥量，或遵循固定的加锁顺序。
4. 不要传递局部变量的引用给 detach 的线程 ：
   如果线程分离了（后台运行），而主线程退出了，局部变量被销毁，子线程访问该引用会导致悬空引用，引发未定义行为。

一句话建议：

优先使用 std::async 处理需要返回结果的简单任务；对于复杂的线程管理，使用 std::thread 配合 std::lock_guard ；对于高频计数器，使用 std::atomic。

代码解读

async、future 和 launch 这几个概念彻底捋顺。

你可以把这套异步机制想象成**"在餐厅点餐"**的过程，这样就很好理解了：

🍽️ 核心概念拆解

std::async ------ "点餐"这个动作

• 含义 ：它的作用是启动一个异步任务。就像你在餐厅前台点了一份"斐波那契大餐"。
• 作用 ：你告诉系统："嘿，帮我运行这个函数（fibonacci），但我现在不想等它，你先干着，回头我来拿结果。"
• 返回值 ：它不会直接给你结果，而是给你一张**"取餐凭证"**（也就是 std::future）。

std::future ------ "取餐凭证"

• 含义 ：它是一个模板类 ，用来保存异步任务未来的结果。
• 作用 ：它就像一个容器，刚开始是空的。当后台的任务（fibonacci）算完后，会把结果放进这个容器里。
• 关键点 ：你只能通过它来获取一次结果（.get()），取完之后它就空了（类似于一次性票据）。

std::launch::async ------ "强制外卖配送"

• 含义 ：这是一个策略标志 ，告诉 std::async 该怎么干活。
• 作用 ：
  • std::launch::async：强制立刻 在一个新线程里运行任务（就像叫了外卖，骑手马上出发送过来）。
  • std::launch::deferred：延迟执行 。直到你主动去要结果（.get()）的那一瞬间，它才会在当前线程里运行（就像你说"做好了给我打电话"，没电话之前厨师根本不动手）。
  • 默认（不写）：让编译器自己决定（通常优先选延迟，为了省资源）。

---

🧩 重新梳理代码逻辑

现在我们带着这些概念，一行行看刚才那段代码，是不是就清晰多了：

// 1. 启动任务
// 翻译：调用 async（点餐），强制开启新线程（std::launch::async），去运行 fibonacci(40)（做大餐）。
// 返回值 result 是一个 future（取餐凭证），用来以后领取结果。
std::future<long long> result = std::async(std::launch::async, fibonacci, 40);

// 2. 等待期间做别的事
// 翻译：拿着凭证（result），每隔 100毫秒 问一下："好了没？"（wait_for）。
// 如果没好（!= ready），我就打印一下"计算中..."，继续干别的事（而不是傻等着）。
while (result.wait_for(std::chrono::milliseconds(100)) != std::future_status::ready) {
    std::cout << "计算中..." << std::endl;
}

// 3. 获取结果
// 翻译：好了！我要取餐了！调用 .get()。
// 如果任务还没完（虽然上面循环确保了完了，但语法上 get 会阻塞），这里会等待。
// 拿到结果后，赋值给 value。
long long value = result.get();

📌 总结

• std::async ：发起者。负责把任务扔到后台去跑。
• std::future ：通信者。负责把后台算好的结果传回给主线程。
• std::launch::async ：指挥官。强制要求"必须开新线程跑"，防止任务被延迟执行。