使用 C++ 20 协程降低异步网络编程复杂度

传统异步回调 vs C++20协程

协程是一种函数对象，可以设置锚点做暂停，然后再该锚点恢复继续运行。它是如何应用在网络异步编程方面的，请对比下面的两种代码风格：

基于回调的异步网络编程

先来看一个异步编程的典型例子 (伪代码)：
async_resolve({host, port}, [](auto endpoint){
  async_connect(endpoint, [](auto error_code){
    async_handle_shake([](auto error_code){
        send_data_ = build_request();
 
        async_write(send_data_, [](auto error_code){
            async_read();
        });
    });
  });
});
 
void async_read() {
    async_read(response_, [](auto error_code){
        if(!finished()) {
            append_response(recieve_data_);
            async_read();
        }else {
            std::cout<<"finished ok\n";
        }
    });
}
基于异步回调的 client 流程如下：
  • 异步域名解析
  • 异步连接
  • 异步 SSL 握手
  • 异步发送数据
  • 异步接收数
这个代码有很多回调函数，使用回调的时候还有一些陷阱，比如如何保证安全的回调、如何让异步读实现异步递归调用，如果再结合异步业务逻辑，回调的嵌套层次会更深，我们已经看到callback hell 的影子了！可能也有读者觉得这个程度的异步回调还可以接受，但是如果工程变大，业务逻辑变得更加复杂，回调层次越来越深，维护起来就很困难了。

基于协程的异步网络编程

再来看看用协程是怎么写同样的逻辑 (伪代码)： 
auto endpoint = co_await async_query({host, port});
auto error_code = co_await async_connect(endpoint);
error_code = co_await async_handle_shake();
send_data = build_request();
error_code = co_await async_write(send_data);
while(true) {
    co_await async_read(response);
    if(finished()) {
        std::cout<<"finished ok\n";
        break;
    }
 
    append_response(recieve_data_);
}
同样是异步 client，相比回调模式的异步 client，整个代码非常清爽，简单易懂，同时保持了异步的高性能，这就是 C++20 协程的威力！

C++ 20 协程提案之争

协程分为无栈协程和有栈协程两种
  • 无栈指可挂起/恢复的函数
  • 有栈协程则相当于用户态线程
有栈协程切换的成本是用户态线程切换的成本，而无栈协程切换的成本则相当于函数调用的成本。
 
有栈（stackful）协程通常的实现手段是在堆上提前分配一块较大的内存空间（比如 64K），也就是协程所谓的“栈”，参数、return address 等都可以存放在这个“栈”空间上。如果需要协程切换，那么通过 swapcontext 一类的形式来让系统认为这个堆上空间就是普通的栈，这就实现了上下文的切换。
 
有栈协程最大的优势就是侵入性小，使用起来非常简便，已有的业务代码几乎不需要做什么修改，但是 C++20 最终还是选择了使用无栈协程，主要出于下面这几个方面的考虑：

栈空间的限制

有栈协程的“栈”空间普遍是比较小的，在使用中有栈溢出的风险；而如果让“栈”空间变得很大，对内存空间又是很大的浪费。无栈协程则没有这些限制，既没有溢出的风险，也无需担心内存利用率的问题。

性能

有栈协程在切换时确实比系统线程要轻量，但是和无栈协程相比仍然是偏重的，这一点虽然在我们目前的实际使用中影响没有那么大，但也决定了无栈协程可以用在一些更有意思的场景上。举个例子，C++20 coroutines 提案的作者Gor Nishanov 在 CppCon 2018 上演示了无栈协程能做到纳秒级的切换，并基于这个特点实现了减少 Cache Miss 的特性。
 

无栈协程是普通函数的泛化

无栈协程是一个可以暂停和恢复的函数，是函数调用的泛化。
 
我们知道一个函数的函数体 (function body) 是顺序执行的，执行完之后将结果返回给调用者，我们没办法挂起它并稍后恢复它，只能等待它结束。而无栈协程则允许我们把函数挂起，然后在任意需要的时刻去恢复并执行函数体，相比普通函数，协程的函数体可以挂起并在任意时刻恢复执行。从这个角度来说，无栈协程是普通函数的泛化。
 
 

无栈协程原理

有栈协程：每个协程创建的时候都会获得一块固定大小 (如 128k) 的堆内存，协程运行的时候就是使用这块堆内存当作运行栈使用，切换时候保存/恢复运行栈和相应寄存器
无栈协程：实现原理并不是通过切换时保存/恢复运行栈和寄存器实现的，它的实现见下，由于协程的每个中断点都是确定，那其实只需要将函数的代码再进行细分，保存好局部变量，做好调用过程的状态变化。例如： 
void fn(){
	int a, b, c;
	a = b + c;
	yield();
	b = c + a;
	yield();
	c = a + b;
}
将上面的代码自动转换为以下形式：
Struct fn{
    int a, b, c;
    int __state = 0;
    
    void resume(){
        switch(__state) {
        case 0:
             return fn1();
        case 1:
             return fn2();
        case 2:
             return fn3();
        }
    }
    
    void fn1(){
        a = b + c;
    }
    
    void fn2(){
        b = c + a;
    }
    
    void fn3(){
        c = a + b;
    }
};

上面就将一个协程函数 fn 进行切分后变成一个Struct，这样的实现相对于有栈协程而言使用的内存更少。当然上面只是一种演示，对应早期的 reenter 用法，这个宏底层通过 switch-case 将函数拆分成多个可重入点，一般也称为 duff device。

C++20 协程缺点

难于理解、过于灵活、动态分配导致的性能问题等等。
 
C++20 协程关键概念繁多：
  • 协程帧 (coroutine frame)
    • 协程参数
    • 局部变量
    • promise 对象
  • promise_type
  • coroutine return object
  • std::coroutine_handle
  • co_await、awaiter、awaitable
C++20 是通过 Compiler 代码生成与语法糖配合的模式来实现的相关机制，与其它语言对比之下 C++20 协程使用的直观度，便利性都会存在一些折扣。
 
C++ 20 协程概览图：
C++20 协程运行流程图：
 
 
另一个视角：
 
await 流程：
目前只适合给库作者使用，因为它只提供了一些底层的协程原语和一些协程暂停和恢复的机制，普通用户如果希望使用协程只能依赖协程库，由协程库来屏蔽这些底层细节，提供简单易用的 API，以便业务侧使用负担尽可能低。

协程库

选取一个合适的协程库有助于屏蔽 C++20 底层的实现细节，对用户更加友好，目前市面上有以下几种选择：
  • boost::asio
    • coroutine / reenter / yield / fork
    • spawn / strand / yield_context
    • (C++20) io_context / executor / co_spawn / co_await / co_return / use_awaitable / executor
  • boost::coroutine2 [有栈协程]
    • coroutine<>::pull_type / coroutine<>::push_type / coro_back / sink
  • boost::fiber [coroutine2 + 协程调度器 + 协程同步工具]
    • fiber / buffered_channel<> / barrier / mutex / channel / promise / future / condition_variable / sleep / yield
  • cppcoro [C++20]
  • async_simple [阿里]
  • libco [腾讯，有栈协程]
  • libcopp [有栈协程]
 

接入

编译参数：
  • -std=c++2a
  • -fcoroutines-ts
  • -DASIO_STA_ALONE
 
编译器厂商支持情况：
  • gcc 10
  • msvc
    • 1900 (VS2015 14.0 部分支持)
    • 1910 (VS2017 15.0 ts 支持)
    • 1928 (VS2019 16.8)
  • clang 8 (部分支持)
 
C++20 四大新增特性
  • 概念 (concept)
  • 范围 (ranges)
  • 协程 (coroutine)
  • 模块 (modules)

实例

基于 boost::asio C++20 协程实现的 echo 服务： 
#include <asio/co_spawn.hpp>
#include <asio/detached.hpp>
#include <asio/io_context.hpp>
#include <asio/ip/tcp.hpp>
#include <asio/signal_set.hpp>
#include <asio/write.hpp>
#include <cstdio>
#include <iostream>

using asio::ip::tcp;
using asio::awaitable;
using asio::co_spawn;
using asio::detached;
using asio::use_awaitable;
namespace this_coro = asio::this_coro;

#if defined(ASIO_ENABLE_HANDLER_TRACKING)
# define use_awaitable \
  asio::use_awaitable_t(__FILE__, __LINE__, __PRETTY_FUNCTION__)
#endif

awaitable<void> echo(tcp::socket socket)
{
  try
  {
    char data[1024];
    for (;;)
    {
      std::size_t n = co_await socket.async_read_some(asio::buffer(data), use_awaitable);
      co_await async_write(socket, asio::buffer(data, n), use_awaitable);
    }
  }
  catch (std::exception& e)
  {
    std::printf("echo Exception: %s\n", e.what());
  }
}
void fn2(){
    std::cout<<"hhh\n";
}

void fn(){
    fn2();
}

awaitable<void> listener()
{
  auto executor = co_await this_coro::executor;
  fn(); 
  tcp::acceptor acceptor(executor, {tcp::v4(), 8988});
  for (;;)
  {
    tcp::socket socket = co_await acceptor.async_accept(use_awaitable); //调用协程，体现同步性
    co_spawn(executor, echo(std::move(socket)), detached);// 创建连接处理线程
  }
}

int main()
{
  try
  {
    asio::io_context io_context(1);

    asio::signal_set signals(io_context, SIGINT, SIGTERM);
    signals.async_wait([&](auto, auto){ io_context.stop(); });

    co_spawn(io_context, listener(), detached); // 创建纤程，体现并发性

    io_context.run();							// 开始调度
  }
  catch (std::exception& e)
  {
    std::printf("Exception: %s\n", e.what());
  }
}

 

参考

[1]. 在 Boost.Asio 中使用协程

[2]. C++20协程原理和应用

[3]. C++网络编程之asio(五)——在asio中使用协程

[4]. C++20协程不完全指南

[5]. 深入浅出c++协程

[6]. 协程的原理（Coroutine Theory）

[7]. 聊聊协程的发展历程

[8]. asio服务器模式：协程

[9]. C++中的yield和reenter和fork

[10]. Boost中的协程—Boost.Asio中的coroutine类

[11]. 如何在C++17中实现stackless coroutine以及相关的任务调度器

[12]. C++20 Coroutine实例教学

[13]. 译：你的第一个协程程序（Your first coroutine）

[14]. ASIO 与协程

[15]. C++ compiler support

From:https://www.cnblogs.com/goodcitizen/p/18887511/reduce_the_complexity_of_network_programming_asynchronously_with_cpp20_coroutines
goodcitizen
100+评论
captcha
    相关文章
    1. Web前端入门第 56 问：JavaScript 变量声明 var、let、const 区别
      曾经 var 如帝王一般统治过 JS 的变量声明，直到后来大佬们实在是忍不了 var 那稀烂的声明规则，便引入了 let 和 const 这两大刀斧手，var 被轻轻松松的斩落马下，如今，再难看见 var 的身影。 变量声明 在 JS 中，所有变量都可以用 var、let 和 const 这三个关键
      前端路引
      4 天前
    3. 来个好玩的，用手机随时随地指挥你的 Cursor！
      ✨\u0026#160;告别束缚，用手机随时随地指挥你的 Cursor！ ✨ 嘿，各位 Cursor 的忠实用户和效率达人们！ 你是否曾经遇到过这样的场景：人不在Mac旁边，却突然灵感迸发，想要让 Cursor 帮你写点代码、整理思路，或者进行一次快速的 AI 对话？又或者，你正在悠闲地喝着咖啡，不想起身，就想在手机上
      四眼蒙面侠
      4 天前
    4. manim变换效果总结
      在ManimCE中，除了上一篇介绍的丰富的动画效果外，变换效果也是制作精彩视觉内容的重要工具。 变换效果主要用于改变对象的形状、大小、颜色或位置，让对象在动画中呈现出动态的变化。 本文详细总结了 ManimCE 中常见的变换效果，并分析它们的应用场景和带来的视觉效果，最后还会给出一些选择变换效果的建
      wang_yb
      4 天前
    5. 反转链表（花式反转）
      题目描述 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 示例 1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] 示例 2： 输入：head = [1,2] 输出：[2,1] 示例 3： 输入：head = [] 输出：[] 提示： 链表中节点的数目
      程序员Seven
      4 天前
    6. C#实现自己的MCP Client
      市面上，有很多免费Client客户端。 虽然说，这些Client客户端可以满足我们大部分的需求，但是在实际企业业务场景中，免费的Client无法全部满足我们的需求。 下面我们用C# 实现MCP Client。 一、新建控制台项目 新建项目 框架选择.Net 8 二、添加MCP SDK 添加依赖库：M
      chingho
      4 天前
    8. .NET外挂系列：4. harmony 中补丁参数的有趣玩法（上）
      一：背景 1. 讲故事 前面几篇我们说完了 harmony 的几个注入点，这篇我们聚焦注入点可接收的几类参数的解读，非常有意思，在.NET高级调试 视角下也是非常重要的，到底是哪些参数，用一张表格整理如下： 参数名 说明 __instance 访问非静态方法的实例（类似 this）。 __resul
      一线码农
      4 天前
    9. 100% 自主可控，Java Solon v3.3.1 发布（国产优秀应用开发基座）
      Solon 框架！ Solon 是新一代，Java 企业级应用开发框架。从零开始构建（No Java-EE），有灵活的接口规范与开放生态。采用商用友好的 Apache 2.0 开源协议，是“杭州无耳科技有限公司”开源的根级项目，是 Java 应用开发的生态基座（可替换美国博通公司的 Spring 生
      带刺的坐椅
      4 天前
    10. 重磅消息，微软宣布 VS Code Copilot 开源，剑指 Cursor！
      前言 微软宣布重磅消息将把 GitHub Copilot Chat 扩展的代码以 MIT 许可证协议开源，然后将扩展中的 AI 功能重构到 VS Code 核心中，这一举措是为了将 VS Code 成为一个开源 AI 编辑器做准备！ VS Code GitHub Copilot拓展地址：https:
      追逐时光者
      4 天前