当前位置： 首页 > article >正文

【C++高级开发应用篇】探索C++20中的协程：异步编程的强大工具

article 2024/12/5 10:31:20

目录

 

引言

什么是协程？

协程的基本特性

协程的关键概念

协程的使用场景

示例1：协程生成器

代码解析

示例2：异步网络请求

代码解析

示例3：简单的协程任务调度器

代码解析

协程的优缺点

优点

缺点

使用协程的注意事项

结论

 

引言

        随着C++20的发布，协程（Coroutines）成为了一种强大的语言特性，为开发者提供了处理异步编程的全新视角。协程凭借其可暂停和恢复的能力，简化了复杂控制流的实现，是现代异步编程的利器。本文将深入探讨协程的概念、优势、使用场景、可能遇到的挑战，并提供代码示例以展示协程的应用。

什么是协程？

协程是一种特殊的函数，它的执行可以在中途暂停，并在之后从暂停的地方继续。与传统函数不同，协程在中断时会保持其执行状态，包括局部变量和执行位置，这使其在处理需要等待的长时间操作（如文件I/O、网络请求）时特别有用。

协程的基本特性

  • 可暂停和恢复：协程能够在执行过程中暂停并将控制权返回给调用者。这种能力通过关键字如co_await、co_yield实现。

  • 状态保持：在暂停时，协程会保存其状态，允许其在之后恢复并继续执行，保持数据的一致性。

  • 轻量级：协程不依赖操作系统的线程调度，减少线程切换的开销，更高效地管理异步操作。

协程的关键概念

协程的实现涉及一些关键的组件和机制：

  • co_await：用于等待某个可等待对象，挂起协程直到该对象准备好。

  • co_yield：为生成器模式设计，允许协程返回一个值给调用者并暂停执行。

  • co_return：结束协程并返回一个结果或完成状态。

  • Promise Type：每个协程都有一个关联的promise_type，定义协程的生命周期行为，如启动、暂停、恢复和结束。

  • Coroutine Handle：std::coroutine_handle用于控制协程的执行状态（如恢复或销毁）。

  • Awaitable Objects：这些对象实现了三种操作：await_ready（准备就绪）、await_suspend（挂起动作）、await_resume（恢复动作）。

协程的使用场景

协程在以下场景中尤为适用：

  1. 异步I/O操作：在需要大量I/O操作的程序中，协程能够在等待期间不阻塞线程，使代码更加简洁和可读。

  2. 高并发需求：协程比线程更轻量，可以更高效地处理高并发任务，尤其是在网络编程中。

  3. 复杂控制流：协程自然地支持状态机和事件驱动模型，使代码逻辑更加直观。

  4. 生成器模式：协程可以逐步产生数据序列，特别适合处理流式数据和大数据集合。

  5. 游戏开发：用于管理动画和AI逻辑，使得游戏逻辑的实现更加自然。

示例1：协程生成器

以下是一个使用协程实现简单生成器的示例代码。这个生成器会逐步生成从0到给定最大值的整数。

#include <coroutine>
#include <iostream>

// Generator 模板类，用于创建生成器。
template<typename T>
struct Generator {
    // 内部类 promise_type，用于定义协程的行为。
    struct promise_type {
        // 当前生成的值，存储在 promise_type 中。
        T current_value;

        // 当协程开始时，返回一个 Generator 对象。
        auto get_return_object() { 
            return Generator{ std::coroutine_handle<promise_type>::from_promise(*this) }; 
        }

        // 协程启动时立即挂起。
        auto initial_suspend() { return std::suspend_always{}; }

        // 协程结束时挂起。
        auto final_suspend() noexcept { return std::suspend_always{}; }

        // 协程正常结束返回，无需返回任何值。
        void return_void() {}

        // 处理 co_yield 语句，保存当前值并挂起协程。
        auto yield_value(T value) {
            current_value = value;
            return std::suspend_always{};
        }

        // 处理未捕获的异常，终止程序。
        void unhandled_exception() { std::terminate(); }
    };

    // 协程句柄，用于管理和控制协程。
    std::coroutine_handle<promise_type> coro;

    // 构造函数，初始化协程句柄。
    explicit Generator(std::coroutine_handle<promise_type> h) : coro(h) {}

    // 析构函数，销毁协程句柄，释放资源。
    ~Generator() { if (coro) coro.destroy(); }

    // 移动到生成的下一个值。
    bool move_next() {
        if (!coro.done()) coro.resume(); // 恢复协程执行。
        return !coro.done(); // 检查协程是否已完成。
    }

    // 获取当前生成的值。
    T current_value() {
        return coro.promise().current_value;
    }
};

// 一个简单的协程函数，生成从 0 到 max 的整数。
Generator<int> generateNumbers(int max) {
    for (int i = 0; i <= max; ++i) {
        co_yield i; // 暂停并返回当前整数。
    }
}

int main() {
    auto gen = generateNumbers(5); // 创建生成器，生成 0 到 5 的整数。
    while (gen.move_next()) { // 遍历生成的值。
        std::cout << gen.current_value() << " "; // 输出当前值。
    }
    return 0;
}

代码解析

  • Promise Type：定义了协程的行为，包括如何挂起和恢复执行，以及如何处理生成的数据。

  • 协程句柄：std::coroutine_handle用于控制协程的执行状态，允许恢复或销毁协程。

  • 生成器函数：generateNumbers使用co_yield逐步生成整数，每次调用co_yield都会将当前值返回并挂起协程。

  • 使用示例：main函数中，通过move_next逐步获取生成器产生的值并输出。

 

示例2：异步网络请求

        在现代应用中，网络请求是一个很常见的异步操作。假设我们有一个简单的异步网络请求功能，它可以模拟网络请求并在“请求完成”后恢复执行。

#include <iostream>
#include <coroutine>
#include <thread>
#include <chrono>

// 定义一个简单的 awaitable 对象，模拟异步操作
struct AsyncRequest {
    // 判断请求是否已经准备好，直接返回 false 表示需要挂起
    bool await_ready() const noexcept { 
        return false; // 始终需要挂起以模拟异步行为
    }

    // 挂起协程并启动异步请求
    void await_suspend(std::coroutine_handle<> handle) const {
        // 使用线程模拟异步操作
        std::thread([handle]() {
            std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟网络延迟
            handle.resume(); // 恢复协程的执行
        }).detach(); // 分离线程，确保它独立运行
    }

    // 请求完成后不返回任何值
    void await_resume() const noexcept {}
};

// 定义 Task 协程返回类型
struct Task {
    // 定义与 Task 关联的 promise_type
    struct promise_type {
        // 返回 Task 对象
        Task get_return_object() { 
            return Task{}; 
        }

        // 协程开始时不挂起
        std::suspend_never initial_suspend() { 
            return {}; 
        }

        // 协程结束时不挂起
        std::suspend_never final_suspend() noexcept { 
            return {}; 
        }

        // 协程正常结束时调用
        void return_void() {}

        // 处理未捕获的异常
        void unhandled_exception() { 
            std::terminate(); // 出现异常时终止程序
        }
    };
};

// 定义一个异步网络请求的协程函数
Task asyncNetworkRequest() {
    std::cout << "Starting network request..." << std::endl;
    co_await AsyncRequest{}; // 挂起协程，等待异步请求完成
    std::cout << "Network request completed!" << std::endl;
}

int main() {
    asyncNetworkRequest(); // 启动异步任务
    std::this_thread::sleep_for(std::chrono::seconds(3)); // 主线程等待，以确保异步任务有时间完成
    return 0;
}

 

代码解析

  1. AsyncRequest 类：

    • await_ready：永远返回false，表示协程需要挂起等待异步操作。
    • await_suspend：接收一个协程句柄，启动一个新线程模拟异步操作，在模拟的网络延迟结束后恢复协程。
    • await_resume：表示异步操作完成后恢复时无需返回任何值。

  2. Task 结构：

    • promise_type：定义协程的生命周期行为，包括初始化和结束时的挂起状态。
    • get_return_object：创建并返回一个Task对象。
    • initial_suspend 和 final_suspend：在协程开始和结束时选择不挂起。
    • unhandled_exception：如果协程中出现未捕获的异常，程序将终止。

  3. asyncNetworkRequest 函数：

    • 模拟异步网络请求，使用co_await等待AsyncRequest完成。
    • 输出表示请求开始和结束的消息。

  4. main 函数：

    • 调用asyncNetworkRequest启动异步任务。
    • 主线程通过std::this_thread::sleep_for等待3秒以确保异步任务可以完成，这是因为asyncNetworkRequest是异步的，立即返回，主线程需要保持活跃以等待异步任务完成。

这个示例中，协程被用来模拟一个异步网络请求操作，展示了如何通过协程处理异步行为，使得代码结构更接近同步逻辑。这不仅提升了代码的可读性，还展示了协程在异步任务中的实际应用。

 

示例3：简单的协程任务调度器

下面的示例演示了如何使用协程来实现一个简单的任务调度器，它可以调度和执行一组协程任务。

#include <iostream>
#include <coroutine>
#include <vector>
#include <memory>

// 定义 Task 类，表示一个协程任务
struct Task {
    // 前向声明 promise_type 的定义
    struct promise_type;
    // 定义协程句柄类型
    using handle_type = std::coroutine_handle<promise_type>;

    // 任务的协程句柄
    handle_type coro;

    // 构造函数，接受一个协程句柄
    Task(handle_type h) : coro(h) {}

    // 移动构造函数
    Task(Task&& t) noexcept : coro(t.coro) {
        t.coro = nullptr; // 确保移动后源对象不再持有协程句柄
    }

    // 析构函数
    ~Task() {
        if (coro) coro.destroy(); // 确保协程被正确销毁释放资源
    }

    // 定义 promise_type 结构，管理协程的生命周期和行为
    struct promise_type {
        // 获取协程的返回对象
        auto get_return_object() {
            return Task{handle_type::from_promise(*this)};
        }
        
        // 初始挂起，协程开始时挂起
        std::suspend_always initial_suspend() { return {}; }
        
        // 最终挂起，协程结束时挂起
        std::suspend_always final_suspend() noexcept { return {}; }

        // 协程正常结束时调用，无需返回值
        void return_void() {}

        // 未处理异常的处理
        void unhandled_exception() {
            std::terminate(); // 终止程序
        }
    };
};

// 定义 TaskScheduler 类，用于调度和执行任务
struct TaskScheduler {
    // 存储任务的向量
    std::vector<Task> tasks;

    // 将任务添加到调度器
    void schedule(Task task) {
        tasks.push_back(std::move(task));
    }

    // 运行调度器，执行所有任务
    void run() {
        while (!tasks.empty()) { // 当仍有未完成任务时
            for (auto it = tasks.begin(); it != tasks.end();) {
                if (!it->coro.done()) {
                    it->coro.resume(); // 恢复协程执行
                }
                if (it->coro.done()) {
                    it = tasks.erase(it); // 移除已完成的任务
                } else {
                    ++it; // 继续到下一个任务
                }
            }
        }
    }
};

// 定义一个简单的协程任务
Task simpleTask(int id) {
    std::cout << "Task " << id << " started." << std::endl;
    co_await std::suspend_always{}; // 挂起协程
    std::cout << "Task " << id << " resumed." << std::endl;
}

int main() {
    TaskScheduler scheduler; // 创建任务调度器
    scheduler.schedule(simpleTask(1)); // 安排任务1
    scheduler.schedule(simpleTask(2)); // 安排任务2
    scheduler.run(); // 运行调度器，执行任务
    return 0;
}

代码解析

  1. Task 类：

    • promise_type：定义了协程的行为，包括如何挂起、恢复和处理异常。
    • handle_type：使用std::coroutine_handle管理协程的生命周期。
    • 移动构造：支持移动语义以避免不必要的资源复制。
    • 析构函数：负责销毁协程以释放资源。

  2. TaskScheduler 类：

    • 调度和执行任务：维护一个任务列表，执行任务并在完成后移除它们，确保任务能够正确恢复和完成。

  3. simpleTask 函数：

    • 使用co_await std::suspend_always{}挂起协程，模拟简单的任务开始和恢复过程。

  4. main 函数：

    • 创建调度器并安排两个简单任务，然后运行调度器以执行这些任务。

通过这种方式，协程和调度器的组合为管理和调度异步任务提供了一个优雅的解决方案。

 

协程的优缺点

优点

  • 简化异步编程：让异步代码更像同步代码，提高可读性和可维护性。

  • 灵活控制流：协程的暂停和恢复能力简化了复杂的控制流实现。

  • 更好的资源利用：协程可以在等待操作时不阻塞CPU，从而提升性能。

缺点

  • 调试复杂性：由于协程的非线性执行，调试和错误跟踪变得更复杂。

  • 资源管理：需要仔细管理协程的生命周期，否则可能出现资源泄漏。

  • 异常处理复杂性：异常的处理和传播比传统函数更复杂，需要特别注意。

  • 学习曲线：对于新手来说，理解协程的原理和机制需要时间。

使用协程的注意事项

在使用协程时，需要注意以下几点：

  • 资源泄漏：确保协程在结束时正确释放资源。

  • 异常处理：为协程中的所有可能异常提供足够的处理机制。

  • 线程安全：如果协程与其他线程共享数据，确保对数据访问是线程安全的。

  • 性能监控：大量协程可能导致性能问题，需监控协程的创建和销毁。

  • 库兼容性：确保使用的库对协程有良好的支持，避免兼容性问题。

结论

        协程为C++的异步编程提供了强大的支持，使得代码更加简洁、可读，同时高效地管理复杂的控制流。然而，协程的使用也带来了新的挑战，需要开发者在设计和实现时谨慎考虑。通过理解协程的原理和使用技巧，可以充分发挥其在现代软件开发中的潜力。无论是处理异步I/O操作、管理高并发任务，还是实现复杂的生成器模式，协程都是开发者手中一把强大的工具。

 

 


http://www.kler.cn/a/420967.html

相关文章：

  • 主持人婚礼司仪知识点题库300道；大型免费题库；大风车题库
  • 活着就好20411205
  • elasticsearch-如何给文档新增/更新的字段
  • Day4：生信新手笔记 — R语言简单命令与Rstudio配置
  • 机器学习周志华学习笔记-第13章＜半监督学习＞
  • flask的第一个应用
  • GDPU Android移动应用 使用多媒体
  • 使用 Vite 快速搭建 Vue 2开发环境
  • 001-SpringBoot整合日志
  • 神经网络入门实战：（十一）池化层搭建，以及填充层的说明
  • 解读 77页2024 集团企业IT技术架构规划方案
  • k8s使用的nfs作为sc。
  • 传统客服中心和呼叫中心客服系统的区别
  • 时间序列模型在LSTM中的特征输入
  • AlmaLinux8.10安装samba实现与Windows文件共享
  • 获取联通光猫的管理员密码
  • 【AI日记】24.12.03 kaggle 比赛 Titanic-6
  • SVN客户端及语言包免费下载 无需积分
  • 计算机网络八股整理（四）
  • 【SpringBoot】SpringBoot优雅停机机制
  • Springboot（五十）SpringBoot3集成sentinel并连接sentinel-dashboard
  • 【大数据学习 | 面经】Spark3.x对比2.x有哪些优点
  • 通过搭建安消一体化管理体系，高校实现应急中心数字化转型升级新动能
  • 树和二叉树（概念 结构）
  • 手机租赁系统开发全攻略 创新服务助力企业智能转型
  • 库存管理如何做到“先进先出”?