【C/C++】C++并发编程：std::async与std::thread深度对比_std::async和std::thread的区别-CSDN博客

本文链接：https://blog.csdn.net/YZJincsdn/article/details/148067972

文章目录

C++并发编程：std::async与std::thread深度对比

C++并发编程：std::async与std::thread深度对比

在 C++ 中，std::async 和 std::thread 都是用于并发编程的工具，但它们在实现方式、资源管理和适用场景上有显著区别。

1 核心设计目的以及区别

特性	`std::async`	`std::thread`
目标	简化异步任务的启动和结果获取	提供底层线程的直接控制
抽象层级	高级抽象（封装线程和结果管理）	低级抽象（直接操作线程）
典型场景	需要异步执行并获取结果的短期任务	需要精细控制线程生命周期的复杂任务

特性	`std::thread`	`std::async`
线程创建	直接创建新线程	可能创建新线程，也可能延迟执行（取决于策略）
返回值	无返回值，需通过共享变量传递结果	返回 `std::future`，可异步获取结果
资源管理	需手动管理线程生命周期（`join()`/`detach()`）	自动管理任务生命周期，`future` 析构时自动处理
异常处理	线程内未捕获的异常会导致程序崩溃	异常会被捕获并存储在 `future` 中
执行策略	总是立即执行	可指定 `std::launch::async`（立即执行）或 `std::launch::deferred`（延迟执行）
适用场景	需要精细控制线程行为（如优先级、同步）	需要异步执行并获取结果，或延迟执行任务

特性	`std::async`	`std::thread`
返回值传递	通过 `std::future` 自动获取结果	需手动传递（如 `std::promise` 或全局变量）
异常处理	异常通过 `future.get()` 自动传递到调用线程	线程内未捕获的异常会导致 `std::terminate`
示例	`auto f = std::async(func); try { f.get(); } catch(...) {}`	`std::promise<int> p; auto f = p.get_future(); std::thread t([&p]{ try { p.set_value(func()); } catch(...) { p.set_exception(...); } });`

特性	`std::async`	`std::thread`
线程生命周期	`std::future` 析构时自动等待线程完成（若策略为 `async`）	必须显式调用 `join()` 或 `detach()`，否则程序终止
资源泄漏风险	低（自动管理）	高（需手动管理）
示例	`cpp { auto f = std::async(func); } // 自动等待`	`cpp std::thread t(func); t.join(); // 必须显式调用`

特性	`std::async`	`std::thread`
线程池支持	可能使用线程池（依赖编译器实现）	每次创建新线程
适用场景	短期任务（避免频繁创建线程的开销）	长期任务或需要独占线程的场景
性能风险	若默认策略非异步，可能意外延迟执行	频繁创建线程可能导致资源耗尽

2 详细对比分析

线程创建与执行

std::thread
- 强制创建新线程：无论系统资源是否充足，都会立即启动新线程执行任务。
- 资源风险：若线程数量过多（如超过系统限制），可能导致程序崩溃。
- 示例：
```
std::thread t([](){ /* 任务代码 */ });
t.join(); // 必须手动等待线程结束
```
std::async
- 策略控制：
  ◦ std::launch::async：强制创建新线程执行任务。
  ◦ std::launch::deferred：延迟执行，仅在调用 get() 或 wait() 时执行（不创建新线程）。
  ◦ 默认策略（async | deferred）：由系统决定是否创建线程。
- 资源优化：可能复用线程池中的线程，减少创建开销。
- 示例：
```
auto fut = std::async(std::launch::async, [](){ return 42; });
int result = fut.get(); // 阻塞等待结果
```

返回值与结果获取

std::thread
- 无法直接获取返回值，需通过共享变量或回调函数传递结果。
- 示例：
```
int result = 0;
std::thread t([&result](){ result = 42; });
t.join();
```

std::async

通过 std::future 自动获取返回值，支持异步等待。

示例：

auto fut = std::async([](){ return 42; });
int result = fut.get(); // 阻塞获取结果

异常处理

std::thread

线程内抛出的异常若未被捕获，会导致程序终止。

示例：

std::thread t([](){ throw std::runtime_error("error"); });
t.join(); // 程序崩溃

std::async

异常会被捕获并存储在 std::future 中，调用 get() 时重新抛出。

示例：

auto fut = std::async([](){ throw std::runtime_error("error"); });
try { fut.get(); } 
catch (const std::exception& e) { /* 处理异常 */ }

性能与资源消耗

std::thread
- 高开销：线程创建和销毁涉及操作系统调度，频繁使用可能导致性能瓶颈。
- 适用场景：需要长期运行的独立任务（如后台服务线程）。
std::async
- 低开销：可能复用线程池中的线程，减少创建/销毁成本。
- 适用场景：短时任务或需要灵活调度的工作（如并行计算、I/O 密集型操作）。

3 代码对比示例

任务：并行计算并返回结果

使用 std::thread：

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

int compute() {
    return 42;
}

int main() {
    std::thread t(compute);
    // 无法直接获取结果，需通过共享变量
    t.join();
    return 0;
}

使用 std::async：

#include <iostream>
#include <future>

int compute() {
    return 42;
}

int main() {
    auto fut = std::async(compute);
    int result = fut.get(); // 直接获取结果
    std::cout << "Result: " << result << std::endl;
    return 0;
}

4 适用场景建议

场景	推荐工具	原因
需要获取异步任务结果	`std::async`	通过 `std::future` 简化结果传递，避免共享变量竞争
需要控制线程优先级或调度策略	`std::thread`	提供底层线程控制能力
短时任务或高并发场景	`std::async`	可能复用线程池，减少资源开销
长时间运行的后台服务线程	`std::thread`	需要保持线程活跃状态

优先 std::async 的场景：
- 需要异步执行并获取结果。
- 关注异常安全和代码简洁性。
- 短期任务，避免手动管理线程。
优先 std::thread 的场景：
- 需要精确控制线程生命周期（如分离线程、自定义调度）。
- 长期运行的后台任务（如服务线程）。
- 需要跨线程共享复杂状态或资源。

5 总结

std::thread：适合需要直接控制线程行为、长期运行的任务，但需手动管理生命周期和结果传递。
std::async：适合需要异步执行并获取结果、或希望系统自动优化资源使用的场景，但对执行策略需谨慎选择。
std::async 的隐藏阻塞：std::future 析构时会隐式等待任务完成，可能导致意外阻塞。
线程局部存储（TLS）：std::async 的线程可能复用，导致 TLS 状态残留。
编译器差异：std::async 的线程池行为（如线程复用策略）可能因编译器实现不同而不同。

维度	`std::async`	`std::thread`
结果获取	自动通过 `future`	需手动使用 `promise` 或共享变量
异常传播	自动传递异常	需手动捕获并处理
线程管理	自动等待线程完成	需显式调用 `join()`/`detach()`
灵活性	适合简单任务	适合需要精细控制的场景
性能优化	可能复用线程（依赖实现）	直接控制线程创建和销毁