19、异步编程模型:std::future/promise、std::async、协程(C++20)入门

说到异步编程,很多C++开发者第一反应就是「线程池+回调」。说实话,我早年也是这么干的。直到有一次我在一个交易系统里,回调嵌套了五六层,调试时差点把自己绕晕。嗯,从那以后我就开始认真研究C++标准库提供的异步方案了。

这一章,咱们聊聊C++里三种主流的异步编程手段:std::future/promise、std::async,还有C++20引入的协程。它们各有各的适用场景,用好了能让你的代码既高效又清爽。

19.1 为什么需要异步编程?

先问个问题:你写过一个函数,调用后要等好几秒才返回吗?比如读取一个大文件、请求网络数据、或者做一次复杂的计算。

同步模式下,主线程就卡在那儿了。用户界面无响应,其他任务也排着队干等。这显然不是我们想要的。

异步编程的核心思想很简单:把耗时操作丢到后台去跑,主线程继续干别的事。等后台完事了,再通知主线程取结果。

我个人习惯把异步编程比作「点外卖」。你下单(发起异步任务),然后该干嘛干嘛(继续执行主逻辑)。外卖到了(任务完成),你取餐(获取结果)。多顺畅。

核心要点:异步编程不是为了提升单次计算的速度,而是为了提高系统的吞吐量和响应性。

19.2 std::future 和 std::promise:最基础的异步通道

std::future 和 std::promise 是一对搭档。它们共同实现了一个「生产者-消费者」模型:

  • promise:生产者,负责在后台线程里设置一个值(或异常)。
  • future:消费者,负责在需要的时候获取这个值。

说白了,promise 就是「我答应你,将来会把结果给你」。future 就是「我等着你兑现承诺」。

19.2.1 基本用法

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

int main() {
    // 创建一个 promise 和对应的 future
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();

    // 启动一个线程,执行耗时计算
    std::thread t([&prom]() {
        std::this_thread::sleep_for(std::chrono::seconds(2));
        prom.set_value(42);  // 设置结果
    });

    // 主线程可以干点别的事...
    std::cout << "主线程继续工作..." << std::endl;

    // 需要结果时,调用 get() 获取
    int result = fut.get();  // 这里会阻塞,直到 promise 设置了值
    std::cout << "结果: " << result << std::endl;

    t.join();
    return 0;
}

你看,主线程在调用 fut.get() 之前,可以自由地做其他事情。这就是异步的魅力。

小提示:future::get() 只能调用一次。如果你需要多次检查结果是否就绪,可以用 future::wait_for() 或 future::valid()。

19.2.2 传递异常

我在项目中遇到过一种情况:后台任务可能抛出异常。如果直接让线程崩溃,那整个程序就挂了。promise 提供了优雅的异常传递机制:

std::promise<int> prom;
std::future<int> fut = prom.get_future();

std::thread t([&prom]() {
    try {
        // 模拟一个可能出错的操作
        throw std::runtime_error("数据读取失败");
        prom.set_value(100);  // 不会执行到这里
    } catch(...) {
        prom.set_exception(std::current_exception());  // 传递异常
    }
});

try {
    int result = fut.get();  // 这里会重新抛出异常
} catch(const std::exception& e) {
    std::cerr << "捕获异常: " << e.what() << std::endl;
}

t.join();

嗯,这里要注意:set_exception 必须在 promise 被销毁前调用,否则 future 那边会得到一个「broken promise」异常。

19.3 std::async:更高级的异步任务

说实话,手动管理 promise 和 thread 有点繁琐。大多数时候,我们只是想让一个函数异步执行,然后拿结果。std::async 就是干这个的。

19.3.1 基本用法

#include <iostream>
#include <future>

int compute(int x) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return x * x;
}

int main() {
    // 异步启动 compute 函数
    std::future<int> fut = std::async(std::launch::async, compute, 10);

    std::cout << "主线程继续..." << std::endl;

    int result = fut.get();  // 等待结果
    std::cout << "计算结果: " << result << std::endl;

    return 0;
}

你看,代码简洁多了。不用手动创建线程,不用管理 promise,一个 std::async 全搞定。

19.3.2 启动策略

std::async 有两个启动策略,我建议你根据场景选择:

策略 含义 适用场景
std::launch::async 强制在新线程上异步执行 需要真正的并行,任务耗时较长
std::launch::deferred 延迟执行,直到调用 get() 或 wait() 任务可能不需要执行,或者想控制执行时机
注意:如果不指定策略,默认是 std::launch::async | std::launch::deferred,由实现决定。我曾经在一个项目中因为这个默认行为踩过坑——某些平台上任务被延迟执行了,导致性能不符合预期。所以,我建议你总是显式指定策略。

19.4 C++20 协程:轻量级异步新范式

协程是C++20引入的重磅特性。说实话,刚接触时我觉得它有点抽象。但用多了就会发现,它比回调式的异步编程优雅太多了。

协程的核心思想是:一个函数可以暂停执行,把控制权交还给调用者,然后在合适的时候恢复执行。 你想想看,这不就是异步编程的天然模型吗?

19.4.1 协程的基本概念

C++20 的协程是「无栈协程」。它不像线程那样有独立的栈空间,而是通过编译器生成的代码来保存和恢复执行状态。这意味着:

  • 创建和切换开销极低:比线程轻量得多
  • 可以创建成千上万个:线程可不敢这么玩
  • 需要手动管理生命周期:嗯,这是代价

19.4.2 一个简单的协程示例

先看一个最简单的协程:

#include <iostream>
#include <coroutine>
#include <future>

// 一个简单的协程返回类型
struct SimpleTask {
    struct promise_type {
        SimpleTask get_return_object() {
            return SimpleTask{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };

    std::coroutine_handle<promise_type> handle;
    explicit SimpleTask(std::coroutine_handle<promise_type> h) : handle(h) {}
    ~SimpleTask() { if (handle) handle.destroy(); }
};

// 一个协程函数
SimpleTask myCoroutine() {
    std::cout << "协程开始执行" << std::endl;
    co_await std::suspend_always{};  // 暂停
    std::cout << "协程恢复执行" << std::endl;
}

int main() {
    auto task = myCoroutine();  // 创建协程,执行到第一个暂停点
    std::cout << "主线程继续..." << std::endl;
    // 这里协程已经执行完了,因为 final_suspend 返回 suspend_never
    return 0;
}

你可能会觉得这个例子有点复杂。没错,C++20 的协程暴露了太多底层细节。不过别担心,实际项目中我们通常会用封装好的库,比如 cppcoro 或者自己封装一层。

19.4.3 协程的实际应用场景

我在一个网络库项目中用过协程。传统的异步网络编程,要么用回调(回调地狱),要么用状态机(代码难以维护)。用协程后,代码写起来就像同步一样自然:

// 伪代码,展示协程的优雅
Task<void> handleConnection(Connection conn) {
    auto request = co_await conn.readRequest();  // 异步读,暂停
    auto response = processRequest(request);
    co_await conn.sendResponse(response);        // 异步写,暂停
    // 协程自动结束
}

你看,每一行 co_await 就是一个异步操作。代码读起来就像同步顺序执行一样,但实际上每个 co_await 都会暂停协程,让出线程给其他协程使用。

协程 vs 线程:协程是「协作式」的,主动让出控制权。线程是「抢占式」的,由操作系统调度。协程适合 I/O 密集型任务,线程适合 CPU 密集型任务。

19.5 如何选择?

说了这么多,到底该用哪个?我个人的经验是这样的:

  • 简单的异步任务:用 std::async,最省事
  • 需要精细控制线程生命周期:用 std::promise/future + 手动线程管理
  • 复杂的异步流程,比如多个异步操作串联:用协程,代码最清晰
  • 高性能场景,需要大量并发连接:协程是首选,线程开销太大

我曾经在一个项目中,用 std::async 处理了上百个并发任务。结果发现线程创建销毁的开销比任务本身还大。后来改用协程,性能提升了三倍多。嗯,选对工具真的很重要。

19.6 避坑指南

最后,分享几个我踩过的坑:

坑1:future 的 get() 只能调用一次。 如果你需要多次检查结果,考虑用 std::shared_future。
坑2:std::async 返回的 future 析构时会阻塞等待。 如果你不关心结果,记得把 future 存起来,或者用 std::move 转移所有权。
坑3:协程的 promise_type 必须正确实现。 特别是 initial_suspend 和 final_suspend 的返回值,决定了协程的行为。搞错了会导致内存泄漏或崩溃。

好了,这一章的内容就到这里。异步编程是C++进阶的必修课,掌握了它,你就能写出更高效、更优雅的并发代码。下一章,咱们聊聊更高级的并发模式——线程池和任务队列。