C++ 异步编程模式：回调、Future/Promise 与协程对比

C++ 异步编程模式：回调、Future/Promise 与协程对比 (编程专家讲座)

各位观众老爷们，大家好！欢迎来到今天的C++异步编程专场。我是你们的老朋友，一个在代码堆里摸爬滚打多年的老码农。今天咱们不讲虚的，直接上干货，好好聊聊C++里那些让人又爱又恨的异步编程模式：回调、Future/Promise，还有近年来风头正劲的协程。

咱们先说个段子：话说当年，老码农写了个网络请求，结果程序卡死了。老板问他怎么回事，老码农委屈地说：“CPU在等数据回来啊！”老板一拍桌子：“等？等什么等！你不会让它去干点别的吗？”

这个段子说明啥？说明在现代程序设计中，尤其是在高并发、IO密集型的场景下，同步阻塞那一套早就玩不转了。我们需要异步编程，让CPU在等待IO操作完成的时候，还能做其他事情，提高效率，避免程序卡死。

那么，C++提供了哪些异步编程的利器呢？咱们一个一个来扒。

一、回调 (Callbacks): 异步编程的元老

回调，可以说是异步编程的老祖宗了。它的核心思想很简单：你先告诉我，事情办完了之后该找谁（也就是回调函数），我办完事就通知你。

优点：

• 简单直接： 概念简单，容易理解。
• 应用广泛： 几乎所有的异步API都支持回调。

缺点：

• 回调地狱 (Callback Hell)： 当多个异步操作嵌套在一起时，代码会变成金字塔形，可读性极差，难以维护，俗称“回调地狱”。
• 错误处理困难： 错误处理分散在各个回调函数中，难以集中管理。
• 难以调试： 堆栈信息不完整，调试困难。

代码示例：

#include <iostream>
#include <functional> // std::function

// 模拟一个异步操作
void asyncOperation(int input, std::function<void(int)> callback) {
    // 模拟耗时操作
    std::cout << "Starting async operation with input: " << input << std::endl;
    // 假设经过一段时间后，操作完成，结果为 input * 2
    int result = input * 2;
    std::cout << "Async operation completed, result: " << result << std::endl;
    // 调用回调函数，将结果传递出去
    callback(result);
}

int main() {
    // 定义回调函数
    auto myCallback = [](int result) {
        std::cout << "Received result in callback: " << result << std::endl;
    };

    // 发起异步操作，并传入回调函数
    asyncOperation(10, myCallback);

    std::cout << "Main thread continues to execute..." << std::endl;

    // 为了让程序不立即退出，可以等待一段时间
    std::cin.get();
    return 0;
}

在这个例子中，asyncOperation 函数模拟了一个异步操作。它接受一个 input 和一个 callback 函数作为参数。当异步操作完成后，它会调用 callback 函数，并将结果传递给它。

可以看到，使用回调函数来实现异步操作确实简单，但如果我们需要连续执行多个异步操作，并且每个操作都依赖于前一个操作的结果，代码就会变得非常复杂，难以维护，这就是回调地狱。

二、Future/Promise: 异步编程的救星

为了解决回调地狱的问题，C++11引入了 Future 和 Promise。它们就像异步操作的“期货”交易：Promise 负责“生产”结果，Future 负责“消费”结果。

优点：

• 解决回调地狱： 可以使用 then 方法链式调用，避免回调嵌套。
• 统一的错误处理： 可以通过 try-catch 块捕获异步操作中的异常。
• 更易于调试： 堆栈信息更完整。

缺点：

• 稍微复杂： 概念比回调函数稍微复杂一些。
• 仍然是回调： then 方法本质上还是回调，只是封装得更好。

代码示例：

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

// 模拟一个异步操作，返回一个 future
std::future<int> asyncOperation(int input) {
    std::promise<int> promise;
    std::future<int> future = promise.get_future();

    // 在另一个线程中执行耗时操作
    std::thread([input, promise = std::move(promise)]() mutable {
        std::cout << "Starting async operation in thread: " << std::this_thread::get_id() << " with input: " << input << std::endl;
        // 模拟耗时操作
        std::this_thread::sleep_for(std::chrono::seconds(1));
        int result = input * 2;
        std::cout << "Async operation completed in thread: " << std::this_thread::get_id() << ", result: " << result << std::endl;
        // 设置 promise 的值，通知 future
        promise.set_value(result);
    }).detach();

    return future;
}

int main() {
    // 发起异步操作，获得 future
    std::future<int> future = asyncOperation(10);

    std::cout << "Main thread continues to execute, thread id: " << std::this_thread::get_id() <<  std::endl;

    // 等待 future 的结果，并获取它
    int result = future.get();

    std::cout << "Received result in main thread: " << result << std::endl;

    return 0;
}

在这个例子中，asyncOperation 函数创建了一个 Promise 和一个 Future。它在一个新的线程中执行耗时操作，并将结果设置到 Promise 中。Future 对象可以用来获取异步操作的结果。future.get()会阻塞当前线程，直到结果可用。

如果我们想连续执行多个异步操作，可以使用 then 方法链式调用：

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

// 模拟一个异步操作，返回一个 future
std::future<int> asyncOperation(int input) {
    std::promise<int> promise;
    std::future<int> future = promise.get_future();

    // 在另一个线程中执行耗时操作
    std::thread([input, promise = std::move(promise)]() mutable {
        std::cout << "Starting async operation in thread: " << std::this_thread::get_id() << " with input: " << input << std::endl;
        // 模拟耗时操作
        std::this_thread::sleep_for(std::chrono::seconds(1));
        int result = input * 2;
        std::cout << "Async operation completed in thread: " << std::this_thread::get_id() << ", result: " << result << std::endl;
        // 设置 promise 的值，通知 future
        promise.set_value(result);
    }).detach();

    return future;
}

int main() {
    // 发起第一个异步操作，获得 future
    std::future<int> future1 = asyncOperation(10);

    // 使用 then 方法链式调用第二个异步操作
    auto future2 = future1.then([](std::future<int> f) {
        int result1 = f.get();
        std::cout << "Received result1 in then: " << result1 << std::endl;
        //发起第二个异步操作，以第一个操作的结果作为输入
        return asyncOperation(result1);
    });

    //获取第二个异步操作的结果
    int result2 = future2.get().get();
    std::cout << "Received result2 in main thread: " << result2 << std::endl;

    return 0;
}

请注意，future2.get().get() 是因为 future1.then 返回的是 std::future<std::future<int>>，需要两次 get() 才能获取最终结果。

虽然 Future/Promise 解决了回调地狱的问题，但 then 方法本质上还是回调，只是封装得更好，代码看起来更清晰。

三、协程 (Coroutines): 异步编程的未来

C++20 引入了协程，这是一种更高级的异步编程模型。协程允许函数在执行过程中挂起 (suspend) 和恢复 (resume)，而不需要像传统的多线程那样进行上下文切换。

优点：

• 同步代码风格： 可以使用类似同步代码的风格编写异步代码，大大提高了代码的可读性和可维护性。
• 零成本抽象： 协程的上下文切换成本非常低，几乎可以忽略不计。
• 更好的性能： 相比于多线程，协程可以减少线程切换的开销。

缺点：

• 学习曲线陡峭： 协程的概念比较复杂，需要理解 co_await、co_yield、co_return 等关键字。
• 编译器支持： 需要 C++20 或更高版本的编译器支持。
• 库支持： 需要配合特定的异步库使用，比如 asio、cppcoro 等。

代码示例 (使用 cppcoro 库)：

#include <iostream>
#include <cppcoro/task.hpp>
#include <cppcoro/sync_wait.hpp>
#include <cppcoro/when_all.hpp>
#include <cppcoro/async_generator.hpp>
#include <thread>
#include <chrono>

cppcoro::task<int> asyncOperation(int input) {
    std::cout << "Starting async operation in thread: " << std::this_thread::get_id() << " with input: " << input << std::endl;
    // 模拟耗时操作
    std::this_thread::sleep_for(std::chrono::seconds(1));
    int result = input * 2;
    std::cout << "Async operation completed in thread: " << std::this_thread::get_id() << ", result: " << result << std::endl;
    co_return result;
}

cppcoro::task<> multipleAsyncOperations() {
    auto task1 = asyncOperation(10);
    auto task2 = asyncOperation(20);

    auto [result1, result2] = co_await cppcoro::when_all(task1, task2);

    std::cout << "Results from multiple async operations: " << result1 << ", " << result2 << std::endl;
}

cppcoro::async_generator<int> generateNumbers() {
    for (int i = 0; i < 5; ++i) {
        co_yield i;
    }
}

int main() {
    // 使用 sync_wait 等待协程完成
    cppcoro::sync_wait(multipleAsyncOperations());

    std::cout << "Main thread continues to execute..." << std::endl;

    // 使用 async_generator
    for (auto i : generateNumbers()) {
        std::cout << "Generated number: " << i << std::endl;
    }

    return 0;
}

在这个例子中，asyncOperation 函数是一个协程。它使用 co_return 返回一个值。co_await 关键字用于挂起协程，等待异步操作完成。multipleAsyncOperations 演示了如何并发执行多个协程，并使用 cppcoro::when_all 等待所有协程完成。generateNumbers展示了如何使用 async_generator 构建一个异步的生成器。

可以看到，使用协程编写异步代码，可以像编写同步代码一样，大大提高了代码的可读性和可维护性。

关键字解释：

• co_await： 挂起当前协程，等待一个 awaitable 对象 (比如 future) 完成。
• co_yield： 在一个生成器协程中，产生一个值。
• co_return： 返回一个值，并结束协程。

四、三种异步编程模式的对比

为了更直观地了解这三种异步编程模式的优缺点，我们用一个表格来总结一下：

特性	回调 (Callbacks)	Future/Promise	协程 (Coroutines)
难度	简单	中等	复杂
可读性	低	中等	高
维护性	低	中等	高
错误处理	分散	统一	统一
调试	困难	较易	容易
性能	较高	中等	高
适用场景	简单的异步操作	中等复杂度的异步操作	高并发、IO密集型场景
是否解决回调地狱	否	是	是

总结：

• 回调： 简单粗暴，适合简单的异步操作，但容易陷入回调地狱。
• Future/Promise： 解决了回调地狱的问题，但本质上还是回调，代码可读性有限。
• 协程： 异步编程的未来，可以用同步代码的风格编写异步代码，提高代码的可读性和可维护性，但学习曲线陡峭。

五、选择哪种异步编程模式？

那么，在实际开发中，我们应该选择哪种异步编程模式呢？

• 对于简单的异步操作， 比如只需要执行一个异步请求，并且不需要处理复杂的依赖关系，回调函数仍然是一个不错的选择。
• 对于中等复杂度的异步操作， 比如需要连续执行多个异步操作，并且每个操作都依赖于前一个操作的结果，Future/Promise 是一个更好的选择。
• 对于高并发、IO密集型的场景， 比如网络服务器、数据库应用等，协程是最佳选择。

当然，这并不是绝对的。在实际开发中，我们需要根据具体的场景，综合考虑代码的可读性、可维护性、性能等因素，选择最合适的异步编程模式。

六、最后的小贴士

• 不要过度使用异步编程： 异步编程虽然可以提高程序的性能，但也会增加代码的复杂性。只有在真正需要的时候才使用异步编程。
• 注意线程安全： 在多线程环境下，需要注意线程安全问题。可以使用锁、原子变量等同步机制来保护共享资源。
• 选择合适的异步库： C++有很多优秀的异步库，比如 asio、cppcoro 等。选择一个合适的异步库可以大大简化异步编程的难度。
• 多练习： 熟能生巧。只有通过大量的实践，才能真正掌握异步编程的技巧。

好了，今天的讲座就到这里。希望大家能够对C++异步编程有更深入的了解。记住，代码不是写给机器看的，而是写给人看的。写出清晰、可读、可维护的代码，才是程序员的终极目标。

下次再见！