Boost C++ 库

添加了 boost::asio::config。config 类提供对与执行上下文关联的配置参数的访问。该类旨在供 asio 内部使用，或供构建在 asio 之上的库或用户提供的抽象使用。这些配置参数通常用于微调行为，例如启用或禁用某些优化。在构造执行上下文（例如 io_context）时，调用者可以选择传递 service_maker 以将具体的配置服务安装到上下文中。例如

boost::asio::io_context ctx{boost::asio::config_from_env{}};

配置参数的值使用 config 类访问，传递节、键和默认值

boost::asio::config cfg{ctx};
bool enable_locking = cfg.get("scheduler", "locking", true);

更改了 default_completion_token trait 的主模板以选择 deferred 作为默认完成令牌。因此，大多数异步操作的启动函数默认将返回一个 deferred 异步操作。例如，从 awaitable 协程调用异步操作时，可以省略完成令牌

awaitable<void> echo(ip::tcp::socket& my_socket)
{
  char data[1024];
  for (;;)
  {
    std::size_t n = co_await my_socket.async_read_some(buffer(data));
    co_await async_write(my_socket, buffer(data, n));
  }
}

或者在使用接受异步操作作为函数对象的操作时，例如 experimental::make_parallel_group

experimental::make_parallel_group(
    my_socket.async_read_some(buffer(data)),
    my_timer.async_wait()
  ).async_wait(/* ... */);

扩展了完成令牌适配器 as_tuple、bind_allocator、bind_cancellation_slot、bind_executor、bind_immediate_executor 和 redirect_error，以允许它们用作部分完成令牌适配器。这意味着可以创建它们而无需显式提供完成令牌。相反，当适配器传递给异步操作时，它将自动确定操作的默认完成令牌并对其进行适配。例如，表达式

my_socket.async_read_some(my_buffer, as_tuple)

将返回一个 deferred 异步操作，其完成参数打包在一个元组中。它们也可以使用 deferred 操作的管道运算符应用

error_code e;
co_await (async_write(my_socket, my_buffer) | redirect_error(e));

添加了 cancel_after 和 cancel_at 完成令牌适配器。这些适配器可用于适配任何异步操作，以在指定的持续时间之后或在绝对时间点发出取消信号。例如

my_socket.async_read_some(my_buffer,
    cancel_after(std::chrono::seconds(10),
      [](error_code e, std::size_t n)
      {
        // ...
      }));

此取消在内部使用 basic_waitable_timer 实现。默认情况下，此计时器是使用异步操作的 I/O 执行器创建的。如果操作确实指定了其 I/O 执行器，则可以显式提供计时器

my_socket.async_read_some(my_buffer,
    cancel_after(my_timer, std::chrono::seconds(10),
      [](error_code e, std::size_t n)
      {
        // ...
      }));

这些适配器也可以用作部分完成令牌适配器，例如在

co_await my_socket.async_read_some(my_buffer, cancel_after(5s));

或者

co_await (
    async_write(my_socket, my_buffer) | as_tuple
      | cancel_after(std::chronos::seconds(10)
  );

或者适配其他部分完成令牌适配器

co_await my_socket.async_read_some(my_buffer, cancel_after(5s, as_tuple));

请注意，由于基于计时器的实现引入了并行 async_wait 操作，因此调用者有责任确保异步操作在隐式或显式 strand 中执行。

添加了 composed，它从有状态的实现创建启动函数对象。它类似于 co_composed，但用于常规函数对象而不是 C++20 协程。例如

struct async_echo_implementation
{
  tcp::socket& socket_;
  mutable_buffer buffer_;
  enum { starting, reading, writing } state_;

  template <typename Self>
  void operator()(Self& self,
      error_code error,
      std::size_t n)
  {
    switch (state_)
    {
      // ...
    }
  }
};

template <typename CompletionToken>
auto async_echo(tcp::socket& socket,
    mutable_buffer buffer,
    CompletionToken&& token)
{
  return async_initiate<CompletionToken,
    void(error_code, std::size_t)>(
      composed(
        async_echo_implementation{socket, buffer,
          async_echo_implementation::starting}, socket),
      token, error_code{}, 0);
}

async_compose 函数已更改为 composed 的薄包装器。但是，与 async_compose 不同，composed 允许在操作启动时将参数传递给有状态的实现。

添加了 async_initiate 的重载，这些重载会自动推断完成令牌的类型。例如

async_initiate(co_composed(/* ... */), detached, arg_1, arg_2);

将从参数 detached 推断令牌类型。

添加了自定义操作完成时立即完成时的完成处理程序的执行的能力。此更改添加了 associated_immediate_executor 关联器 traits、bind_immediate_executor 函数和 immediate_executor_binder 适配器。当受支持的操作立即完成时（即在启动函数内），将获取关联的立即执行器，并通过该执行器传递完成处理程序，就像在该执行器上使用 asio::dispatch 一样。默认情况下，立即执行器传递完成处理程序，就像通过操作的 I/O 执行器使用 asio::post 一样。例如，为了允许对 async_read_some 操作的完成处理程序进行递归调用，我们可以指定立即完成通过 system_executor 传递

my_socket.async_read_some(my_buffer,
    bind_immediate_executor(
      system_executor(),
      [](error_code e, size_t n)
      {
        // ...
      }
    )
  );

reactor 类型的套接字和描述符上的异步操作，以及通道上的异步操作，目前支持立即执行。

为缓冲区类型添加了用户定义的字面量。_buf 字面量后缀在命名空间 asio::buffer_literals 中定义，可用于从字符串、二进制整数和十六进制整数文字创建 const_buffer 对象。这些缓冲区字面量可以任意长。例如

  using namespace asio::buffer_literals;

  asio::const_buffer b1 = "hello"_buf;
  asio::const_buffer b2 = 0xdeadbeef_buf;
  asio::const_buffer b3 = 0x0123456789abcdef0123456789abcdef_buf;
  asio::const_buffer b4 = 0b1010101011001100_buf;
  

与缓冲区字面量关联的内存在其程序生命周期内有效。这意味着缓冲区可以安全地用于异步操作

async_write(my_socket, "hello"_buf, my_handler);

通过 signal_set::add 的可选参数公开了 sigaction() 标志。注册信号时，现在可以传递标志来指定与信号关联的行为。这些标志在新类 signal_set_base 中指定为枚举类型，并传递给底层 sigaction() 调用。例如

asio::signal_set sigs(my_io_context);
sigs.add(SIGINT, asio::signal_set::flags::restart);

除非目标操作系统支持 sigaction()，否则指定 flags::dont_care 以外的标志将失败。由于信号注册是全局的，因此冲突的标志（多个注册传递了与 flags::dont_care 不同的标志）也会导致错误。

添加了 consign 完成令牌适配器，可用于将附加值附加到完成处理程序。这通常用于至少保留对象的一个副本（例如智能指针），直到调用完成处理程序。例如

auto timer1 = std::make_shared<asio::steady_timer>(my_io_context);
timer1->expires_after(std::chrono::seconds(1));
timer1->async_wait(
    asio::consign(
      [](boost::system::error_code ec)
      {
        // ...
      },
      timer1
    )
  );

添加了 any_completion_handler<>，可用于类型擦除完成处理程序。一个典型的用例是启用异步操作实现的分开编译。例如

// Header file:

void async_sleep_impl(
    asio::any_completion_handler<void(boost::system::error_code)> handler,
    asio::any_io_executor ex, std::chrono::nanoseconds duration);

template <typename CompletionToken>
inline auto async_sleep(asio::any_io_executor ex,
    std::chrono::nanoseconds duration, CompletionToken&& token)
{
  return asio::async_initiate<
    CompletionToken, void(boost::system::error_code)>(
      async_sleep_impl, token, std::move(ex), duration);
}

// Separately compiled source file:

void async_sleep_impl(
    asio::any_completion_handler<void(boost::system::error_code)> handler,
    asio::any_io_executor ex, std::chrono::nanoseconds duration)
{
  auto timer = std::make_shared<asio::steady_timer>(ex, duration);
  timer->async_wait(asio::consign(std::move(handler), timer));
}

添加了 experimental::co_composed，它有助于使用 C++20 协程轻量级实现用户定义的异步操作。以下示例说明了一个简单的异步操作，该操作根据协程实现了一个 echo 协议

template <typename CompletionToken>
auto async_echo(tcp::socket& socket,
    CompletionToken&& token)
{
  return asio::async_initiate<
    CompletionToken, void(boost::system::error_code)>(
      asio::experimental::co_composed<
        void(boost::system::error_code)>(
          [](auto state, tcp::socket& socket) -> void
          {
            try
            {
              state.throw_if_cancelled(true);
              state.reset_cancellation_state(
                asio::enable_terminal_cancellation());

              for (;;)
              {
                char data[1024];
                std::size_t n = co_await socket.async_read_some(
                    asio::buffer(data), asio::deferred);

                co_await asio::async_write(socket,
                    asio::buffer(data, n), asio::deferred);
              }
            }
            catch (const boost::system::system_error& e)
            {
              co_return {e.code()};
            }
          }, socket),
      token, std::ref(socket));
}

添加了基于范围的 experimental::make_parallel_group() 重载，可用于启动动态大小的异步操作集，其中所有操作都是相同的类型。例如

using op_type = decltype(
    socket1.async_read_some(
      asio::buffer(data1),
      asio::deferred
    )
  );

std::vector<op_type> ops;
ops.push_back(
    socket1.async_read_some(
      asio::buffer(data1),
      asio::deferred
    )
  );
ops.push_back(
    socket2.async_read_some(
      asio::buffer(data2),
      asio::deferred
    )
  );

asio::experimental::make_parallel_group(ops).async_wait(
    asio::experimental::wait_for_all(),
    [](
        std::vector<std::size_t> completion_order,
        std::vector<boost::system::error_code> e,
        std::vector<std::size_t> n
      )
    {
      for (std::size_t i = 0; i < completion_order.size(); ++i)
      {
        std::size_t idx = completion_order[i];
        std::cout << "socket " << idx << " finished: ";
        std::cout << e[idx] << ", " << n[idx] << "\n";
      }
    }
  );

感谢 Klemens Morgenstern 提供了此实现的一部分。

为基于 awaitable<> 的协程添加了直接 co_await 打包为函数对象的操作的能力。例如，使用 deferred

asio::awaitable<void> my_coro()
{
  asio::steady_timer timer(co_await asio::this_coro::executor);
  timer.expires_after(std::chrono::seconds(5));

  co_await timer.async_wait(asio::deferred);
}

或使用手工制作的函数对象

asio::awaitable<void> my_coro()
{
  asio::steady_timer timer(co_await asio::this_coro::executor);
  timer.expires_after(std::chrono::seconds(5));

  co_await [&](auto&& token)
  {
    return timer.async_wait(std::forward<decltype(token)>(token));
  };
}

更改了 spawn() 以使其成为基于完成令牌的异步操作。这引入了符合异步操作要求的新 spawn() 重载。例如

std::string do_read(asio::yield_context yield)
{
  char data[1024];
  size_t n = my_socket.async_read_some(asio::buffer(data), yield);
  return std::string(data, n);
}

asio::spawn(my_executor, do_read,
    [](std::exception_ptr ex, std::string result)
    {
      // ...
    });

这些新的 spawn() 重载支持取消，并且还增强了 basic_yield_context 完成令牌以支持仅移动和可变参数结果类型。当目标为 C++11 及更高版本时，这些函数直接根据 Boost.Context 实现。现有的重载已保留但已弃用。

添加了 is_async_operation trait 和 async_operation 概念。is_async_operation trait 可用于确定是否可以调用函数对象和可选参数来启动异步操作。例如，当使用 deferred 时

auto d = my_timer.async_wait(asio::deferred);
static_assert(asio::is_async_operation<decltype(d)>::value);

或使用手工制作的异步操作

struct my_async_op
{
  asio::ip::tcp::socket& socket_ = ...;

  template <typename Token>
  auto operator()(asio::const_buffer data, Token&& token)
  {
    return asio::async_write(socket_, data,
        std::forward<Token>(token));
  }
};

static_assert(
    asio::is_async_operation<
      my_async_op, asio::const_buffer>::value);

添加了 completion_signature_of trait。completion_signature_of trait（以及相应的类型别名 completion_signature_of_t）可用于确定异步操作的完成签名。例如

auto d = my_timer.async_wait(asio::deferred);
using sig = asio::completion_signature_of<decltype(d)>::type;
// sig is void(error_code)

或使用手工制作的异步操作

struct my_async_op
{
  asio::ip::tcp::socket& socket_ = ...;

  template <typename Token>
  auto operator()(asio::const_buffer data, Token&& token)
  {
    return asio::async_write(socket_, data,
        std::forward<Token>(token));
  }
};

using sig =
  asio::completion_signature_of<
    my_async_op, asio::const_buffer>::type;
// sig is void(error_code, size_t)

添加了对文件的支持。这引入了用于面向流和随机访问文件的新类。例如，要写入新创建的面向流的文件

asio::stream_file file(
    my_io_context, "/path/to/file",
    asio::stream_file::write_only
      | asio::stream_file::create
      | asio::stream_file::truncate);

file.async_write_some(my_buffer,
    [](error_code e, size_t n)
    {
      // ...
    });

或从随机访问文件读取

asio::random_access_file file(
    my_io_context, "/path/to/file",
    asio::random_access_file::read_only);

file.async_read_some_at(1234, my_buffer,
    [](error_code e, size_t n)
    {
      // ...
    });

此功能当前支持 Windows 上的 I/O 完成端口和 Linux 上的 io_uring（定义 BOOST_ASIO_HAS_IO_URING 以启用）。

添加了对可移植管道的支持。此更改添加了对 POSIX 和 Windows 上管道的支持（当 I/O 完成端口可用时）。例如，要创建和使用连接的一对管道对象

asio::readable_pipe read_end;
asio::writable_pipe write_end;
asio::connect_pipe(read_end, write_end);

write_end.async_write_some(my_write_buffer,
    [](error_code e, size_t n)
    {
      // ...
    });

read_end.async_read_some(my_read_buffer,
    [](error_code e, size_t n)
    {
      // ...
    });

添加了对注册缓冲区的支持。mutable_registered_buffer 和 const_registered_buffer 类是表示注册缓冲区的缓冲区序列类型。这些缓冲区通过首先执行缓冲区注册来获得

auto my_registration =
  asio::register_buffers(
      my_execution_context,
      my_buffer_sequence);

注册对象必须在需要缓冲区注册的时间内保持。提供的缓冲区序列表示将要注册的内存位置，调用者必须确保它们在注册期间保持有效。当注册对象被销毁时，注册会自动删除。每个执行上下文最多可以有一个活动注册。

注册对象是注册缓冲区的容器。可以通过迭代容器或通过直接索引访问从中获取缓冲区

asio::mutable_registered_buffer my_buffer
  = my_registration[i];

然后可以将注册缓冲区直接传递给操作

asio::async_read(my_socket, my_buffer,
    [](error_code ec, size_t n)
    {
      // ...
    });

当与描述符、文件、管道和套接字上的读取和写入操作一起使用时，缓冲区注册支持 io_uring 后端。为了可移植性，该工具可以在其他平台上使用，但注册缓冲区将表现为普通缓冲区。

添加了对通道的实验性支持。这添加了模板 experimental::basic_channel 和 experimental::basic_concurrent_channel，别名为 experimental::channel 和 experimental::concurrent_channel。通道可用于将完成作为消息发送。例如

// Create a channel with no buffer space.
channel<void(error_code, size_t)> ch(ctx);

// The call to try_send fails as there is no buffer
// space and no waiting receive operations.
bool ok = ch.try_send(asio::error::eof, 123);
assert(!ok);

// The async_send operation is outstanding until
// a receive operation consumes the message.
ch.async_send(asio::error::eof, 123,
    [](error_code ec)
    {
      // ...
    });

// The async_receive consumes the message. Both the
// async_send and async_receive operations complete
// immediately.
ch.async_receive(
    [](error_code ec, size_t n)
    {
      // ...
    });

添加了 associator 特性。associator 特性用于通用地转发关联器，例如 associated_executor 和 associated_allocator，通过中间完成处理程序。例如

template <typename Handler>
struct intermediate_handler
{
  Handler handler_;

  template <typename... Args>
  void operator()(Args&... args)
  {
    // ...
  }
};

namespace asio {
  template <
      template <typename, typename> class Associator,
      typename Handler,
      typename DefaultCandidate>
  struct associator<
      Associator,
      intermediate_handler<Handler>,
      DefaultCandidate>
  {
    using type =
      typename Associator<Handler, DefaultCandidate>::type;

    static type get(
        const intermediate_handler<Handler>& h,
        const DefaultCandidate& c = DefaultCandidate()) noexcept
    {
      return Associator<Handler, DefaultCandidate>::get(
          h.handler_, c);
    }
  };
} // namespace asio

添加了对具有多个完成签名的异步操作的支持。完成签名还可以指定它们是 noexcept，以及它们是否是左值可调用（因此不“消耗”完成处理程序）或右值可调用（因此确实“消耗”处理程序，表示异步操作结束）。例如

auto my_async_operation(...,
    asio::completion_token_for<
      void(intermediate_result_type) & noexcept,
      void(final_result_type) &&
    > auto&& token)
{
  // ...
}

为 awaitable<> 添加了 operator&& 和 operator||。逻辑运算符 || 和 && 已为 awaitable<> 重载，以允许协程以并行方式轻松等待。

当使用 && 等待时，co_await 表达式会等待直到两个操作都成功完成。作为“短路”评估，如果一个操作因异常而失败，则另一个操作会立即取消。例如

std::tuple<std::size_t, std::size_t> results =
  co_await (
    async_read(socket, input_buffer, use_awaitable)
      && async_write(socket, output_buffer, use_awaitable)
  );

当使用 || 等待时，co_await 表达式会等待直到任一操作成功。作为“短路”评估，如果一个操作成功且未抛出异常，则另一个操作会立即取消。例如

std::variant<std::size_t, std::monostate> results =
  co_await (
    async_read(socket, input_buffer, use_awaitable)
      || timer.async_wait(use_awaitable)
  );

可以通过添加 #include 来启用运算符

#include <boost/asio/experimental/awaitable_operators.hpp>

然后将 experimental::awaitable_operators 命名空间的内容引入作用域

using namespace asio::experimental::awaitable_operators;

添加了 experimental::as_tuple 完成令牌适配器。as_tuple 完成令牌适配器可用于指定应将完成处理程序参数组合到单个元组参数中。as_tuple 适配器可以与 use_awaitable 和结构化绑定结合使用，如下所示

auto [e, n] = co_await socket.async_read_some(
    asio::buffer(data), as_tuple(use_awaitable));

或者，它可以像这样用作默认完成令牌

using default_token = as_tuple_t<use_awaitable_t<>>;
using tcp_socket = default_token::as_default_on_t<tcp::socket>;
// ...
awaitable<void> do_read(tcp_socket socket)
{
  // ...
  auto [e, n] = co_await socket.async_read_some(asio::buffer(data));
  // ...
}

添加了 experimental::append 完成令牌适配器。append 完成令牌适配器可用于在完成签名的末尾传递其他完成处理程序参数。例如

timer.async_wait(
    asio::experimental::append(
      [](boost::system::error_code ec, int i)
      {
        // ...
      },
    42)
  );

std::future<int> f = timer.async_wait(
    asio::experimental::append(
      asio::use_future,
      42
    )
  );

添加了 experimental::prepend 完成令牌适配器。prepend 完成令牌适配器可用于在现有完成处理程序参数之前传递其他参数。例如

timer.async_wait(
    asio::experimental::prepend(
      [](int i, boost::system::error_code ec)
      {
        // ...
      },
    42)
  );

std::future<std::tuple<int, boost::system::error_code>> f = timer.async_wait(
    asio::experimental::prepend(
      asio::use_future,
      42
    )
  );

添加了 experimental::deferred 完成令牌。deferred 完成令牌接受对异步操作启动函数的调用，并将其转换为接受完成令牌的函数对象。例如

auto deferred_op =
  timer.async_wait(
    asio::experimental::deferred);
...
std::move(deferred_op)(
    [](boost::system::error_code ec){ ... });

或者

auto deferred_op =
  timer.async_wait(
    asio::experimental::deferred);
...
std::future<void> =
  std::move(deferred_op)(
    asio::use_future);

延迟令牌还支持链式调用，以创建简单的组合

auto deferred_op =
  timer.async_wait(
    asio::experimental::deferred(
      [&](boost::system::error_code ec)
      {
        timer.expires_after(
            std::chrono::seconds(1));

        return timer.async_wait(
            asio::experimental::deferred);
      });
...
std::future<void> = std::move(deferred_op)(asio::use_future);

添加了 experimental::parallel_group 类和 experimental::make_parallel_group 函数。此实用程序可用于启动并行执行的工作，并等待一个或所有操作完成。parallel_group 实现了对未完成操作的自动取消。例如

experimental::make_parallel_group(
    [&](auto token)
    {
      return stream.async_read_some(asio::buffer(data), token);
    },
    [&](auto token)
    {
      return timer.async_wait(token);
    }
  ).async_wait(
    experimental::wait_for_one(),
    [](
        std::array<std::size_t, 2> completion_order,
        boost::system::error_code ec1, std::size_t n1,
        boost::system::error_code ec2
    )
    {
      // ...
    }
  );

可以使用四个提供的函数对象 wait_for_all、wait_for_one、wait_for_one_success 和 wait_for_one_error 之一或使用自定义函数来指定组的完成条件。parallel_group 类也可以与 deferred 结合使用，如下所示

experimental::make_parallel_group(
    stream.async_read_some(asio::buffer(data), experimental::deferred),
    timer.async_wait(experimental::deferred)
  ).async_wait(
    // ...
  );

注意：为了最大的灵活性，parallel_group 不会自动将执行器传播到组内的操作。

添加了 experimental::promise。promise 类型允许异步操作的抢先执行和同步。例如

auto promise = async_read(
    stream, asio::buffer(my_buffer),
    asio::experimental::use_promise);

... do other stuff while the read is going on ...

promise.async_wait( // completion the operation
    [](error_code ec, std::size_t bytes_read)
    {
      ...
    });

如果不再需要结果，可以安全地忽略 Promise。可以将不同的操作组合起来，以等待所有操作完成或等待一个操作完成（并取消其余操作）。例如，要等待一个完成

auto timeout_promise =
  timer.async_wait(
    asio::experimental::use_promise);

auto read_promise = async_read(
    stream, asio::buffer(my_buffer),
    asio::experimental::use_promise);

auto promise =
  asio::experimental::promise<>::race(
    timeout_promise, read_promise);

promise.async_wait(
    [](std::variant<error_code, std::tuple<error_code, std::size_t>> v)
    {
      if (v.index() == 0) {} //timed out
      else if (v.index() == 1) // completed in time
    });

或等待所有完成

auto write_promise = async_write(
    stream, asio::buffer(my_write_buffer),
    asio::experimental::use_promise);

auto read_promise = async_read(
    stream, asio::buffer(my_buffer),
    asio::experimental::use_promise);

auto promise =
  asio::experimental::promise<>::all(
    write_promise, read_promise);

promise.async_wait(
    [](std::tuple<error_code, std::size_t> write_result,
      std::tuple<error_code, std::size_t> read_result)
    {
    });

感谢 Klemens Morgenstern 为此功能做出的贡献。

添加了 experimental::coro 类模板。coro 类型是用于可恢复函数的 C++20 协程原语，能够将异步等待 (co_await) 和让步 (co_yield) 组合到单个有状态的控制流中。例如

#include <boost/asio.hpp>
#include <boost/asio/experimental/coro.hpp>

using asio::ip::tcp;

asio::experimental::coro<std::string> reader(tcp::socket& sock)
{
  std::string buf;
  while (sock.is_open())
  {
    std::size_t n = co_await asio::async_read_until(
        sock, asio::dynamic_buffer(buf), '\n',
        asio::experimental::use_coro);
    co_yield buf.substr(0, n);
    buf.erase(0, n);
  }
}

asio::awaitable<void> consumer(tcp::socket sock)
{
  auto r = reader(sock);
  auto msg1 = co_await r.async_resume(asio::use_awaitable);
  std::cout << "Message 1: " << msg1.value_or("\n");
  auto msg2 = co_await r.async_resume(asio::use_awaitable);
  std::cout << "Message 2: " << msg2.value_or("\n");
}

asio::awaitable<void> listen(tcp::acceptor& acceptor)
{
  for (;;)
  {
    co_spawn(
        acceptor.get_executor(),
        consumer(co_await acceptor.async_accept(asio::use_awaitable)),
        asio::detached);
  }
}

int main()
{
  asio::io_context ctx;
  tcp::acceptor acceptor(ctx, {tcp::v4(), 54321});
  co_spawn(ctx, listen(acceptor), asio::detached);
  ctx.run();
}

感谢 Klemens Morgenstern 为此功能做出的贡献。

添加了 experimental::as_single 完成令牌适配器。as_single 完成令牌适配器可用于指定应将完成处理程序参数组合到单个参数中。对于具有单个参数的完成签名，该参数按原样传递。对于具有两个或多个参数的签名，这些参数会组合成一个元组。as_single 适配器可以与 use_awaitable 和结构化绑定结合使用，如下所示

auto [e, n] = co_await socket.async_read_some(
    boost::asio::buffer(data), as_single(use_awaitable));

或者，它可以像这样用作默认完成令牌

using default_token = as_single_t<use_awaitable_t<>>;
using tcp_socket = default_token::as_default_on_t<tcp::socket>;
// ...
awaitable<void> do_read(tcp_socket socket)
{
  // ...
  auto [e, n] = co_await socket.async_read_some(boost::asio::buffer(data));
  // ...
}

为 basic_waitable_timer 添加了转换移动构造和赋值。这启用了不同计时器类型之间的移动构造和赋值，前提是执行器类型是可转换的。例如

basic_waitable_timer<
    clock_type,
    traits_type,
    io_context::executor_type
  > timer1(my_io_context);

basic_waitable_timer<
    clock_type,
    traits_type,
    any_io_executor // polymorphic wrapper
  > timer2(std::move(timer1));

添加了 co_spawn 的重载，用于启动可等待对象。此更改允许我们编写

co_spawn(executor,
    echo(std::move(socket)),
    detached);

而不是

co_spawn(executor,
    [socket = std::move(socket)]() mutable
    {
      return echo(std::move(socket));
    },
    detached);

为处理程序跟踪添加了源位置支持。新的 BOOST_ASIO_HANDLER_LOCATION((file_name, line, function_name)) 宏可用于通知处理程序跟踪机制源位置。此宏声明一个放置在堆栈上的对象。然后，当使用位置信息启动异步操作时，它会在表示异步操作开始的 n*m 行之前，使用 <action> n^m 输出行。例如

  @asio|1589423304.861944|>7|ec=system:0,bytes_transferred=5
  @asio|1589423304.861952|7^8|in 'async_write' (...../../include/asio/impl/write.hpp:330)
  @asio|1589423304.861952|7^8|called from 'do_write' (handler_tracking/async_tcp_echo_server.cpp:62)
  @asio|1589423304.861952|7^8|called from 'operator()' (handler_tracking/async_tcp_echo_server.cpp:51)
  @asio|1589423304.861952|7*8|socket@0x7ff61c008230.async_send
  @asio|1589423304.861975|.8|non_blocking_send,ec=system:0,bytes_transferred=5
  @asio|1589423304.861980|<7|

如果 std::source_location 或 std::experimental::source_location 可用，则 use_awaitable_t 令牌（当默认构造或用作默认完成令牌时）也将导致处理程序跟踪为每个新创建的异步操作输出源位置。use_awaitable_t 对象也可以使用位置信息显式构造。

添加了 handlerlive.pl 工具，该工具处理处理程序跟踪输出以生成“活动”处理程序的列表。活动处理程序是那些与待处理异步操作关联的处理程序，以及当前正在执行的处理程序。例如

cat output.txt | perl handlerlive.pl

或者

perl handerlive.pl < output.txt

或者

perl handlerlive.pl output.txt

添加了 handlertree.pl 工具，该工具过滤处理程序跟踪输出，以仅包括树中生成指定处理程序的那些事件。例如，要过滤输出以仅包括与处理程序 123、456 及其前身关联的事件

  cat output.txt | perl handlertree.pl 123 456

或者

  perl handlertree.pl 123 456 < output.txt

此脚本可以与 handerlive.pl 和 handlerviz.pl 结合使用，以生成“活动”异步操作链的图表。例如

  cat output.txt | \
    perl handlertree.pl perl handlerlive.pl output.txt | \
    perl handlerviz.pl | \
    dot -Tsvg > output.svg

将嵌套模板类型 rebind_executor 添加到所有 I/O 对象类型，作为将其通用地重新绑定以使用替代 I/O 执行器的方法。例如

using my_socket_type = tcp::socket::rebind_executor<my_executor_type>::other;

添加了 default_completion_token 特征，以便每个 I/O 执行器类型现在都具有关联的默认完成令牌类型。此特征可以在异步操作声明中使用，如下所示

template <
    typename IoObject,
    typename CompletionToken =
      typename default_completion_token<
        typename IoObject::executor_type
      >::type
  >
auto async_fyz(
    IoObject& io_object,
    CompletionToken&& token =
      typename default_completion_token<
        typename IoObject::executor_type
      >::type{}
  );

如果未特化，则此特征类型为 void，这意味着给定 I/O 执行器没有可用的默认完成令牌类型。

为 use_awaitable 完成令牌特化了 default_completion_token 特征，以便可以按以下示例所示使用它

auto socket = use_awaitable.as_default_on(tcp::socket(my_context));
// ...
co_await socket.async_connect(my_endpoint); // Defaults to use_awaitable.

在此示例中，socket 对象的类型从 tcp::socket 转换为具有默认完成令牌设置为 use_awaitable 的 I/O 执行器。或者，可以直接计算套接字类型

using tcp_socket = use_awaitable_t<>::as_default_on_t<tcp::socket>;
tcp_socket socket(my_context);
// ...
co_await socket.async_connect(my_endpoint); // Defaults to use_awaitable.

确保执行器类型传播到新接受的套接字。当同步或异步接受新连接，但在未指定执行器或执行上下文的情况下，接受操作现在将正确地将执行器类型从 acceptor 传播到 socket。例如，如果您的 acceptor 类型是

basic_socket_acceptor<ip::tcp, my_executor_type>

那么您接受的套接字类型将是

basic_stream_socket<ip::tcp, my_executor_type>