在我们进入答案之前，请注意：

你不应该在任何情况下，get()或wait()未来的boost::asio::awaitable从同一个线程中运行的协程的执行者。

话虽如此。

第三个参数 to co_spawn()，几乎每个例子都盲目地设置为魔法detached常数？它的作用是告诉boost::asio协程完成后要做什么。detached只是意味着“什么都不做”。因此，从 an 实现未来的规范方式awaitable<>应该是通过该机制。

幸运的是，asio 已经提供了use_future完成令牌。将其作为第三个参数传递给co_spawn()它，它将返回std::future<>匹配返回类型的 a。

boost::asio::awaitable<void> foo();
boost::asio::awaitable<int> bar();

std::future<void> foo_fut = boost::asio:co_spawn(io_context, foo(), boost::asio::use_future);
std::future<int> bar_fut = boost::asio:co_spawn(io_context, bar(), boost::asio::use_future);

这是一个完整的例子：

#include <boost/asio/io_context.hpp>
#include <boost/asio/co_spawn.hpp>
#include <boost/asio/use_future.hpp>

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

using boost::asio::awaitable;
using boost::asio::co_spawn;
using boost::asio::io_context;
using boost::asio::use_future;

awaitable<void> foo() {
  // Simulate foo taking a while to run
  std::this_thread::sleep_for(std::chrono::seconds(1));
  std::cout << "foon";
  co_return;
}

int main() {
  try {
    io_context context;
    std::future<void> fut = co_spawn(context, foo(), use_future);

    std::thread waiter([fut=std::move(fut)](){
        std::cout << "AAAn";
        fut.wait();
        std::cout << "BBBn";
    });

    context.run();

    waiter.join();
  
  } catch(const std::exception &ex) {
    std::cerr << ex.what() << std::endl;
  }
  return 0;
}

显然，这意味着您需要访问 io 上下文才能生成未来。

如果您已经在协程内部并且无法访问 io_context，那么您必须在调用子程序之前创建未来，并在完成未来之前创建co_await它的结果。std::promise<>非常适合该任务：

awaitable<void> sub_foo() {
  co_return;
}

awaitable<void> foo() {
  std::promise<void> prom;
  auto fut = prom.get_future();
  // send the future somewhere
  
  co_await sub_foo();

  prom.set_value();

  co_return;
}

如果您不在协程中，并且无权访问 io_context，那么您首先无法调用协程。因此，这两种方法中的任何一种都应该让您满意。