C++中的异步编程：使用 std::async 与 std::future

作者

在现代 C++（C++11 及之后的标准）中，异步编程变得异常重要。尤其是在需要长时间运行的 I/O、计算密集型任务以及多核 CPU 上并行处理时，合理地使用异步技术可以显著提升程序性能和响应性。本文将从基础概念讲起，逐步展示如何在 C++ 中使用 std::async、std::future 以及 std::promise 来实现非阻塞任务调度，并结合实战案例说明使用细节和常见陷阱。

1. 何为异步编程？

异步（Asynchronous）指的是在执行某个操作时不阻塞调用线程，而是让操作在后台完成。程序可以在等待结果时继续执行其他任务。与同步（blocking）相对的是同步：调用者会被阻塞，直到被调用的操作完成。

异步编程的核心是任务（Task）和结果的分离：我们把需要时间的操作包装成一个任务对象，然后让它在后台执行，最终通过某种手段获取结果。

2. C++ 标准库中的异步工具

2.1 std::async

std::async 是一个函数模板，用来在后台线程中执行指定的函数。其原型如下：

template< class Function, class... Args >
std::future< std::invoke_result_t<Function, Args...> >
async( std::launch policy, Function&& f, Args&&... args );
  • policy：控制任务的执行方式，可取 std::launch::async、std::launch::deferred 或两者按位或组合。
    • async：立即在新线程中启动任务。
    • deferred：任务被延迟到第一次取值（如 get()）时才执行，且在调用线程中执行。
  • 返回值：std::future，代表将来会得到的结果。

2.2 std::future 与 std::promise

  • **`std::future `**：一个占位符，表示未来某个时刻会获得 `T` 类型的值。你可以通过 `future.get()` 阻塞获取结果，也可以通过 `future.wait()` 等待任务完成。
  • **`std::promise `**：与 `future` 配合使用，提供一种方式让异步任务主动把结果交给 `future`。通过 `promise.set_value(value)` 把值传递给对应的 `future`。

在许多情况下，只用 std::async 即可满足需求；若需要更细粒度的控制（如手动触发、跨线程共享），可结合 promise 与 future。

3. 代码示例：使用 std::async

下面展示一个典型场景：我们有一个耗时的数值计算（斐波那契数），并且想在主线程中继续做其他工作。

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

long long fibonacci(int n) {
    if (n <= 1) return n;
    return fibonacci(n-1) + fibonacci(n-2);
}

int main() {
    // 在后台线程异步执行 fibonacci(40)
    std::future<long long> fut = std::async(std::launch::async, fibonacci, 40);

    // 主线程做一些别的事情
    std::cout << "主线程在做别的事情...\n";
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout << "主线程继续工作。\n";

    // 等待后台任务完成并获取结果
    long long result = fut.get(); // 这里会阻塞直到计算完成
    std::cout << "斐波那契结果: " << result << std::endl;
    return 0;
}

运行流程：

  1. async 立即在一个新线程中开始计算。
  2. 主线程在这段时间里继续执行，示例中使用 sleep 模拟其他任务。
  3. 当调用 fut.get() 时，如果后台任务还未完成，主线程会阻塞；若已完成，直接返回结果。

3.1 延迟执行（deferred）

如果你想让任务在真正需要结果时才执行，可以使用 deferred：

auto fut = std::async(std::launch::deferred, fibonacci, 40);
// 此时 fibonacci 并未运行
std::cout << "稍后才需要结果\n";
long long result = fut.get(); // 此时才开始执行

注意：deferred 可能导致所有等待操作（如 get()）都在主线程上执行，导致不真正并行。

4. 进阶：结合 std::packaged_task 与 std::thread

如果你想在多线程环境中手动控制任务的执行，可以用 std::packaged_task：

#include <thread>

std::packaged_task<int()> task(fibonacci, 40);
std::future <int> fut = task.get_future();

std::thread t(std::move(task)); // 手动创建线程来执行 task
// 或者在需要时启动
t.join(); // 等待线程完成
int result = fut.get();

packaged_task 允许你把一个可调用对象包装为一个任务，并在任何线程中执行，同时提供一个 future 接口获取结果。

5. 异步编程的常见陷阱

陷阱 说明 解决方案
过度并发 频繁创建 async 任务会产生大量线程，导致上下文切换成本高昂。 控制任务数量，使用线程池（如 std::async 的 launch::async 在大多数实现中会使用线程池）或第三方线程池库。
死锁 在 async 里又创建 async 并使用同一 future 的 get()，可能造成死锁。 避免在 async 内部再 async，或使用 wait_for/wait_until 等非阻塞等待。
异常传播 async 的后台任务抛出异常，future.get() 会重新抛出。 在后台任务中捕获异常并通过 promise 传递错误信息，或者在 future.get() 周围使用 try/catch。
资源泄漏 未 join() 或 detach() 的线程会导致程序退出异常。 确保 future.get() 或 future.wait()，或在任务完成后显式 join()。
不确定的执行顺序 deferred 与 async 的混用可能导致不确定的执行时机。 明确使用策略，并在设计上避免不确定性。

6. 结语

C++ 标准库为我们提供了丰富而简洁的异步编程工具。std::async 与 std::future 的组合，既能快速实现后台任务，又能在需要时保持同步的接口；std::promise、std::packaged_task 则进一步提升了灵活性，满足更复杂的多线程协作需求。掌握这些工具，配合线程池、协程（C++20 std::future 兼容协程）等技术，你就能在大多数场景下实现高效、可维护的并发程序。

如有兴趣深入了解，可进一步探索：

  • std::thread 与线程池实现细节
  • std::async 与协程的结合（C++20 co_spawn）
  • std::experimental::future 与 std::experimental::parallelism 提供的并行算法

祝你在 C++ 的异步世界里编程愉快！

发表评论