C++ 语言特性29 - 协程介绍

一:什么是协程

C++20 引入了协程(coroutine),这是 C++ 标准库中一个强大的新特性。协程是一种可以在执行中暂停并随后恢复的函数,允许程序在异步或并行场景下高效管理任务,而不需要传统的线程或复杂的回调机制。

协程是可以暂停其执行并保存其当前状态,稍后可以从该位置恢复执行的特殊函数。在某种程度上,协程类似于普通函数,但它们的执行流可以通过 co_awaitco_yieldco_return 来暂停和恢复。这与传统函数的行为不同,传统函数一旦开始执行,就会一直运行到返回或退出为止。

协程与线程的不同在于,协程不会引入新的线程,它们是在现有线程上执行的。协程的切换开销通常非常低,远小于线程切换,因此在处理高并发场景下具有很大的优势。

二:协程的语法

C++20 协程的语法引入了三种关键字:

  1. co_return:从协程中返回值。
  2. co_yield:暂停协程,并返回一个值给调用者,稍后可以恢复协程。
  3. co_await:暂停协程,等待某个异步操作完成后再继续执行。

为了使用协程,C++ 中的一个普通函数必须返回某种特殊的类型,而不是像 void 或普通类型那样。这个特殊的返回类型需要符合协程的约定,它定义了如何控制协程的生命周期。下面举一个例子,演示下协程的使用:

cpp 复制代码
#include <iostream>
#include <coroutine>
#include <thread>
#include <chrono>

// 一个简单的协程返回对象类型
struct Task {
    struct promise_type {
        Task get_return_object() {
            return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_never initial_suspend() { return {}; }  // 协程立即开始执行
        std::suspend_always final_suspend() noexcept { return {}; } // 协程结束时暂停
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };

    std::coroutine_handle<promise_type> handle;

    Task(std::coroutine_handle<promise_type> h) : handle(h) {}
    ~Task() { handle.destroy(); }

    void resume() { handle.resume(); }
};

// 一个自定义的 awaitable 类型,用于模拟异步任务
struct Awaiter {
    bool await_ready() { return false; } // 表示协程需要挂起
    void await_suspend(std::coroutine_handle<>) {
        // 模拟异步任务的延迟,例如 I/O 操作
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    void await_resume() {}
};

// 协程函数,模拟异步任务
Task async_task() {
    std::cout << "Task started, waiting for 1 second...\n";
    co_await Awaiter{};  // 挂起协程并等待模拟异步任务
    std::cout << "Task resumed after 1 second!\n";
}

int main() {
    Task task = async_task();
    task.resume();  // 启动协程
    std::cout << "Main function continues execution...\n";
}

上面代码中主要变量和函数如下;

  • 协程句柄 (std::coroutine_handle)

    std::coroutine_handle 是一个可以用来控制协程生命周期的类型。它可以暂停、恢复协程以及销毁协程。std::coroutine_handle 提供了一些常用的成员函数,例如 resume()destroy() 等,用于管理协程的执行。

  • Promise 对象

    每个协程都有一个与之关联的 promise 对象(promise_type )。它负责管理协程的状态和返回值。promise_type 需要实现一些特定的函数,比如 get_return_object()(返回协程的返回对象)、initial_suspend()(定义协程开始时的行为)和 final_suspend()(定义协程结束时的行为)。

  • 挂起点 (co_await)

    co_await 是协程的核心,它允许协程暂停执行,等待某个条件满足时恢复。co_await 的行为依赖于其后跟随的对象或表达式,它可以是等待一个异步操作完成,也可以是一个延迟或其他触发条件。

    协程的暂停和恢复类似于保存函数的状态,并在以后恢复它的执行,这样可以避免使用回调或复杂的状态机来处理异步操作

  • 协程函数 async_task

    • 使用 co_await 关键字等待 Awaiter 类型,这会暂停协程,并在一秒钟后恢复。
    • 恢复后,协程继续执行并打印消息。
  • 自定义的 Awaiter

    • await_ready 返回 false,表明协程需要挂起。
    • await_suspend 中使用 std::this_thread::sleep_for 来模拟一个异步任务(实际情况中可以是 I/O 操作或其他异步任务)。
    • await_resume 恢复协程。
  • main 函数

    • 调用 async_task 来创建协程对象 task,并使用 resume 来启动协程。

这个例子运行过程如下:

  • 协程开始执行,打印 Task started, waiting for 1 second...,然后协程挂起 1 秒钟。
  • 主函数继续执行并打印 Main function continues execution...
  • 1 秒钟后,协程恢复执行并打印 Task resumed after 1 second!

三:协程的使用场景

1. 异步 I/O 操作

在传统的同步代码中,I/O 操作(如网络或磁盘操作)通常会阻塞线程,导致线程空闲等待。在 C++ 中使用协程,可以使得这些 I/O 操作异步化,协程可以在 I/O 操作完成时继续执行,而不阻塞整个线程。在这个例子中,协程 sleep_one_second 会暂停执行 1 秒,然后恢复。

cpp 复制代码
#include <iostream>
#include <chrono>
#include <thread>
#include <coroutine>

struct Sleeper {
    struct promise_type {
        Sleeper get_return_object() { return {}; }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };

    bool await_ready() { return false; }
    void await_suspend(std::coroutine_handle<>) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    void await_resume() {}
};

Sleeper sleep_one_second() {
    std::cout << "Sleeping..." << std::endl;
    co_await Sleeper{};
    std::cout << "Awake!" << std::endl;
}
2. 生成器

协程可以用来实现生成器模式,允许在迭代过程中动态生成值,而不需要一次性返回整个集合。这个例子中的 range 协程会生成一个从 0 到 4 的整数序列,类似于 Python 的生成器。

cpp 复制代码
#include <iostream>
#include <coroutine>
#include <vector>

struct Generator {
    struct promise_type {
        int current_value;

        Generator get_return_object() { return Generator{std::coroutine_handle<promise_type>::from_promise(*this)}; }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        std::suspend_always yield_value(int value) {
            current_value = value;
            return {};
        }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };

    std::coroutine_handle<promise_type> handle;

    Generator(std::coroutine_handle<promise_type> h) : handle(h) {}
    ~Generator() { if (handle) handle.destroy(); }

    bool move_next() {
        handle.resume();
        return !handle.done();
    }

    int current_value() { return handle.promise().current_value; }
};

Generator range(int start, int end) {
    for (int i = start; i < end; ++i) {
        co_yield i;
    }
}

int main() {
    auto gen = range(0, 5);
    while (gen.move_next()) {
        std::cout << gen.current_value() << " ";
    }
}

四:协程的优势

  1. 简化异步代码:协程可以以同步风格编写异步代码,简化了复杂的异步操作,如异步 I/O、网络通信、文件读写等。
  2. 高性能:协程切换的开销通常比线程上下文切换低,因此在高并发场景下协程更为高效。
  3. 提高代码可读性:协程使得代码更加线性和易读,避免了大量嵌套的回调或状态机逻辑。
相关推荐
blammmp5 分钟前
Java:数据结构-枚举
java·开发语言·数据结构
何曾参静谧18 分钟前
「C/C++」C/C++ 指针篇 之 指针运算
c语言·开发语言·c++
暗黑起源喵23 分钟前
设计模式-工厂设计模式
java·开发语言·设计模式
WaaTong28 分钟前
Java反射
java·开发语言·反射
Troc_wangpeng29 分钟前
R language 关于二维平面直角坐标系的制作
开发语言·机器学习
努力的家伙是不讨厌的31 分钟前
解析json导出csv或者直接入库
开发语言·python·json
Envyᥫᩣ1 小时前
C#语言:从入门到精通
开发语言·c#
童先生1 小时前
Go 项目中实现类似 Java Shiro 的权限控制中间件?
开发语言·go
lulu_gh_yu1 小时前
数据结构之排序补充
c语言·开发语言·数据结构·c++·学习·算法·排序算法
Re.不晚2 小时前
Java入门15——抽象类
java·开发语言·学习·算法·intellij-idea