C++20引入了对协程的支持，这是一项重要的编程语言特性，可以简化异步编程的实现而且提高代码的可读性和可维护性。协程可以在执行过程中暂停和恢复，能够更直观地表达异步操作的流程，让编程更加简洁和高效。

C++20的协程库提供了一组新的关键字、库函数和概念，能轻松地实现异步操作、事件驱动的编程模型和无阻塞式IO等。这些特性对于网络编程、并发编程和响应式编程都有很大的帮助。在C++20之前，一般都是使用第三方库或者自己实现协程功能，现在C++20的协程库为协程的使用提供了官方标准的支持，为C++编程带来了全新的可能性。

2.1、协程的基本概念和使用方法

协程是一种轻量级线程，它可以在不同的执行上下文中暂停和恢复。在协程中，程序可以通过显式的暂停和恢复操作来控制执行流程，能够更灵活地管理并发任务。

等关键字来实现暂停和恢复操作。通过使用

可以将执行权交还给调用者，同时将当前状态保存起来。而

用于向调用者返回一个值，同时也会暂停当前协程的执行。协程也需要一个可调用的函数作为入口点，称为协程函数。

#include <iostream>
#include <coroutine>
/*******************************************************************
* `promise_type`结构定义协程的状态和控制逻辑，
* `initial_suspend`和`final_suspend`用于定义协程的初始化和结束时的暂停行为。
* `get_return_object`方法返回一个`Generator`对象，
* `return_void`用于处理协程返回的结果，
* `yield_value`用于返回一个值并暂停协程的执行。
********************************************************************/
struct Generator {
  struct promise_type {
    int current_value;
    std::exception_ptr exception; // 用来存储异常指针

    // 初始挂起不做任何事情
    auto initial_suspend() { return std::suspend_always{}; }
    // 最终挂起销毁coroutine
    auto final_suspend() noexcept { return std::suspend_always{}; }
    Generator get_return_object() {
      return Generator{std::coroutine_handle<promise_type>::from_promise(*this)};
    }
    // 返回时不做任何事情
    void return_void() {}
    // 挂起并记下当前value
    auto yield_value(int value) {
      current_value = value;
      return std::suspend_always{};
    }
    // 存储异常
    void unhandled_exception() { exception = std::current_exception(); }
  };

  std::coroutine_handle<promise_type> coro;

  explicit Generator(std::coroutine_handle<promise_type> h) : coro(h) {}

  ~Generator() {
    // 解构时销毁coroutine
    if (coro)
      coro.destroy();
  }

  int getValue() {
    // 无异常时返回当前值，否则重新抛出异常
    if (coro.promise().exception)
      std::rethrow_exception(coro.promise().exception);
    return coro.promise().current_value;
  }

  bool next() { 
    if (!coro.done()) {
      coro.resume();
      return !coro.done();
    }
    return false;
  }
};

Generator counter() {
  for (int i = 0; i < 5; ++i)
    co_yield i;
}

int main() {
  Generator gen = counter();
  while (gen.next()) {
    std::cout << gen.getValue() << std::endl;
  }
  return 0;
}


将值返回给调用者，同时暂停协程的执行。在

方法来依次取出协程返回的值，并输出到控制台。

这就是一般情况下C++中协程的基本概念和使用方法。

C++20中引入了对协程的原生支持，可以直接利用协程来编写异步程序。协程支持是通过引入一组新的关键字和库来实现的，包括

等关键字以及相关的标准库函数和类型。

#include <iostream>
#include <coroutine>

// Define a struct named Task
struct Task {
  // Define a nested struct named promise_type for Task
  struct promise_type {
    // Return a default-constructed Task object
    Task get_return_object() {
      return {};
    }
    // Suspend the coroutine indefinitely during its initial execution
    std::suspend_never initial_suspend() {
      return {};
    }
    // Suspend the coroutine indefinitely at its final execution
    std::suspend_never final_suspend() noexcept{
      return {};
    }
    // Terminate the program for unhandled exceptions
    void unhandled_exception() {
      std::terminate();
    }
    // No action for coroutines returning void
    void return_void() {}
  };

  ~Task() { 
    std::cout << "Task destroyed" << std::endl;
  }

  // Suspend the coroutine associated with the provided coroutine handle
  void await_suspend(std::coroutine_handle<promise_type>) {}
};

// Create an asynchronous function named async
Task async() {
  std::cout << "Async start" << std::endl;
  // Suspend the coroutine until being resumed (in this case indefinitely)
  co_await std::suspend_always{};
  std::cout << "Async end" << std::endl;
}

int main() {
  // Call the async function and store the resulting task
  auto task = async();
  std::cout << "Main" << std::endl;
  return 0;
}


来暂停执行，并在适当的时机恢复执行。

表示在异步操作完成前暂停执行。

在底层实现中，编译器会将协程转换为状态机。每个协程包含了一组状态（比如挂起、运行、完成等），并且通过调度器进行相互切换。当协程暂停时，其状态会被保存下来，等待下一次被唤醒时恢复执行。这种状态机的设计是实现协程的核心。

编译器会生成一些额外的代码来管理协程的状态和上下文切换。协程需要进行频繁的挂起和恢复操作，因此涉及到堆栈和上下文的保存与恢复。编译器和标准库需要在底层处理这些操作，保证协程的状态能够正确地切换和保存。

协程调度器和协程对象的概念：

协程调度器和协程对象的关系：

在异步IO操作中使用协程简化异步操作的编写，提高代码的可读性、可维护性和性能。

示例：使用C++20协程库（搭配Boost.Asio）来进行异步网络通信。

#include <iostream>
#include <boost/asio.hpp>
#include <boost/asio/use_awaitable.hpp>
#include <coroutine>
#include <boost/asio/awaitable.hpp>

namespace net = boost::asio;
using tcp = boost::asio::ip::tcp;

class AsyncTCPClient {
public:
    AsyncTCPClient(net::io_context& io_context)
        : resolver_(io_context), socket_(io_context) {}

    // Asynchronous connection to the server
    net::awaitable<void> connect(const std::string& host, unsigned short port) {
        auto results = co_await resolver_.async_resolve(host, std::to_string(port), net::use_awaitable);
        co_await net::async_connect(socket_, results, net::use_awaitable);
    }

    // Asynchronous write operation
    net::awaitable<void> write(const std::string& data) {
        co_await net::async_write(socket_, net::buffer(data), net::use_awaitable);
    }

    // Asynchronous read operation
    net::awaitable<std::string> read(int max_length) {
        std::string data;
        data.resize(max_length);
        
        size_t read_length = co_await socket_.async_read_some(net::buffer(data), net::use_awaitable);
        co_return data.substr(0, read_length);
    }

private:
    tcp::resolver resolver_;
    tcp::socket socket_;
};

int main() {
    net::io_context io_context;

    AsyncTCPClient client(io_context);

    co_spawn(io_context, [&client]() -> net::awaitable<void> {
        try {
            co_await client.connect("www.baidu.com", 80);
            co_await client.write("GET / HTTP/1.1\r\nHost: www.baidu.com\r\nConnection: close\r\n\r\n");
            std::string response = co_await client.read(1024);
            std::cout << "Received: " << response << std::endl;
        } catch (std::exception& e) {
            std::cerr << "Exception: " << e.what() << std::endl;
        }
    }, net::detached);

    io_context.run();

    return 0;
}


g++ -std=c++20 -lboost_system -lboost_coroutine -lboost_context -pthread testp.cc -o testp

Received: HTTP/1.1 200 OK
Accept-Ranges: bytes
Cache-Control: no-cache
Content-Length: 9508
Content-Type: text/html
Date: Sun, 07 Jan 2024 06:15:56 GMT
P3p: CP=" OTI DSP COR IVA OUR IND COM "
P3p: CP=" OTI DSP COR IVA OUR IND COM "
Pragma: no-cache
Server: BWS/1.1
Set-Cookie: BAIDUID=84A68B6C381FF605A97D9FCB3889B2E7:FG=1; expires=Thu, 31-Dec-37 23:55:55 GMT; max-age=2147483647; path=/; domain=.baidu.com
Set-Cookie: BIDUPSID=84A68B6C381FF605A97D9FCB3889B2E7; expires=Thu, 31-Dec-37 23:55:55 GMT; max-age=2147483647; path=/; domain=.baidu.com
Set-Cookie: PSTM=1704608156; expires=Thu, 31-Dec-37 23:55:55 GMT; max-age=2147483647; path=/; domain=.baidu.com
Set-Cookie: BAIDUID=84A68B6C381FF6058825F825739832C9:FG=1; max-age=31536000; expires=Mon, 06-Jan-25 06:15:56 GMT; domain=.baidu.com; path=/; version=1; comment=bd
Traceid: 1704608156352853428210666740912840254115
Vary: Accept-Encoding
X-Ua-Compatible: IE=Edge,chrome=1
Connection: close

<!DOCTYPE html><html><head><meta http-equiv="Content-Type" content="te


未来的C++标准可能会继续完善和扩展协程库，包括新增更多的协程相关工具、函数和语法糖，来满足更广泛的并发编程需求。未来会有更好的编译器支持，包括优化协程性能、提供更丰富的调试信息等。

C++20协程库会推动标准化并发编程模式，包括并发任务调度、异步操作、协同执行等，未来会进一步整合协程库与其他标准库，比如网络库、文件系统库等，提供更完整的异步操作和并发编程支持。

除了简单的协程机制，未来也会有更丰富的并发编程模型，比如actor模型、数据流编程模型等。也会进一步优化协程的性能，包括降低协程的开销、提高协程的并发性能等，以提供更高效的并发编程支持。

C++20新特性解析：深入探讨协程库的实现原理与应用

C++20引入的协程简化了异步编程。本文深入解析C++20协程库的实现原理，并结合实际应用案例，探讨协程在提升程序性能和简化异步代码方面的优势与用法。

后端

编程语言

算法

C++20引入协程库，简化异步编程，提升代码可读性和性能。协程通过暂停和恢复实现异步操作，减少回调地狱和上下文切换开销。C++20提供co_await、co_yield等关键字和标准库支持，适用于网络编程和并发编程。

文件系统

数据流

编译器

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

C++20新特性解析：深入探讨协程库的实现原理与应用

C++20新特性解析：深入探讨协程库的实现原理与应用

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐