c++ multi-threading多线程编程_c++ thread库用法

std::thread构造后必须join或detach，否则析构时调用std::terminate终止程序；传参默认拷贝，引用需std::ref；共享数据须用mutex等同步机制避免data race。

std::thread 构造后必须 detach 或 join，否则程序崩溃

构造 std::thread 对象后，若其处于“可加入”（joinable）状态而未调用 join() 或 detach()，析构时会调用 std::terminate()，直接终止进程——这不是异常，无法捕获。

• 常见错误：在函数内创建 std::thread 但忘记处理，尤其在提前 return 或异常路径中
• 推荐做法：用 RAII 封装，比如自定义 scoped_thread，或立即 join()（适合需等待完成的场景）
• detach() 后线程后台运行，与主线程生命周期解耦，但要注意避免访问已销毁对象（如局部变量、栈内存）

void do_work() { /* ... */ }
int main() {
    std::thread t{do_work};
    // ❌ 错误：t 析构前未 join/detach
    // ✅ 正确之一：t.join();
    // ✅ 正确之二：t.detach();
}

传递参数给 std::thread 时默认按值拷贝，引用需 wrap with std::ref

std::thread 构造函数对参数执行完美转发，但**所有参数默认按值传递并拷贝**。若想传引用，必须显式包装为 std::ref(x) 或 std::cref(x)；否则你在线程里操作的是副本，主函数中的原始变量不受影响。

• 传指针安全，但需确保所指对象生命周期长于线程执行时间
• 传 lambda 捕获引用同理：若用 [&] 捕获局部变量，线程可能访问已销毁栈帧
• 移动语义可用：std::thread t{func, std::move(obj)};，此时原对象失效

void increment(int& x) { ++x; }
int main() {
    int a = 0;
    std::thread t{increment, std::ref(a)}; // ✅ 引用传递
    t.join();
    // a == 1
}

共享数据不加锁导致 data race，std::mutex 是最常用同步原语

多个线程同时读写同一内存位置（至少一个为写），且无同步机制，即构成 data race —— 行为未定义（可能 crash、静默错值、优化器乱序重排）。std::mutex 是最基础也最常用的互斥方案。

• 务必成对使用 lock()/unlock()，推荐用 std::lock_guard 或 std::unique_lock 自动管理
• 避免锁粒度太粗（性能差）或太细（易漏锁、死锁）；优先保护最小必要临界区
• 不要跨线程传递未加锁的裸指针/引用指向共享对象；考虑用 std::shared_ptr 配合 mutex 管理所有权和访问

#include 
std::mutex mtx;
int counter = 0;
void safe_increment() {
std::lock_guard lock{mtx}; // 析构自动 unlock
++counter;
}

std::async + std::future 更适合“启动即等待结果”的任务模型

当你要启动一个异步计算，并稍后获取返回值，std::async 比手动管理 std::thread 更简洁、更安全：它自动处理线程生命周期、异常传播和结果同步。

• 默认策略是 std::launch::async | std::launch::deferred，编译器可选择延迟执行（调用 get() 时才运行），也可能立即启动新线程
• 若强制立即并发，用 std::async(std::launch::async, func, args...)
• std::future::get() 是阻塞调用，且只能调用一次；多次调用抛 std::future_error

auto fut = std::async([]{ return 42; });
int result = fut.get(); // 阻塞直到完成，返回 42

多线程最难的不是语法，而是判断哪些数据真正共享、谁负责生命周期、锁是否覆盖了所有访问路径——哪怕只漏一个读操作，data race 就可能在压力测试时才爆发。