C++协程库封装

操作系统：ubuntu20.04LTS

头文件：<ucontext.h>

什么是协程

协程可以看作轻量级线程，相比于线程，协程的调度完全由用户控制。可以理解为程序员可以暂停执行或恢复执行的函数。将每个线程看作是一个子程序，或者说一个函数，首先main函数启动后产生了main线程，在main函数中调用了function函数后会产生另一个线程执行function函数。在这个过程中，可以发现线程的执行并不受程序员的控制，从入口进入到执行完毕给出返回值，程序员无法控制。而协程则允许程序员在其执行到某个步骤时停止执行，去执行别的任务，当某个条件满足后继续执行被暂停的任务。在子程序内部中断，去执行别的子程序，在适合的时候返回继续执行。例如下面的例子，假设有两个函数func1和func2：func1: 打印123；func2打印456

假设在func1最后调用func2，这是利用线程来完成的，那么最终的结果是打印123456；

而在使用协程情况下，允许程序员中断func1，执行func2，然后返回继续执行func1，可以实现先打印12，然后执行func2，打印456，然后返回继续执行func1，打印3，最终的结果是：124563。

协程的优点和缺点

协程具有极高的执行效率，这是由于没有线程切换的开销以及没有线程同步的开销。子程序切换不设计到线程切换没有线程切换的开销，同时由于多个协程在同一线程下，不涉及到写资源冲突，协程中控制共享资源不加锁，因此执行效率比线程高。线程数目越多，协程的优势越明显。

优点

  1. 轻量级: 协程通常比线程更轻量级，因为它们在同一线程中运行，并且可以在不同的时间点暂停和恢复执行。这意味着在同一系统上可以运行更多的协程而不会产生过多的资源消耗。

  2. 低开销: 创建和销毁协程的开销通常比线程低，因为它们不涉及操作系统级别的上下文切换。

  3. 高效的并发: 由于协程可以在同一线程中进行切换，因此在某些情况下，协程可以比使用多线程的程序更高效地利用多核处理器。

  4. 简化同步: 在协程中，共享状态的同步通常更容易，因为协程可以通过消息传递等方式来进行通信，而不需要使用诸如锁之类的同步原语。

  5. 简化代码: 使用协程可以编写更具表达力和清晰度的异步代码。它们通常使用异步/await语法，使得编写异步代码更类似于编写同步代码。

缺点

  1. 不适用于CPU密集型任务: 协程通常适用于IO密集型任务，而不适用于CPU密集型任务。因为协程在同一线程中执行，如果一个协程执行了一个长时间的CPU密集型操作，它会阻塞其他协程的执行。

  2. 需要显式地调用异步操作: 在使用协程时，必须确保在适当的地方使用异步操作。如果忘记在长时间运行的操作中使用异步调用，可能会阻塞整个程序的执行。

  3. 难以调试: 由于协程通常是在同一线程中运行的，因此调试时可能会更加复杂。在调试过程中，难以查看多个协程之间的状态和执行顺序。

  4. 可能会出现死锁: 如果在协程中错误地使用了同步原语，例如锁，可能会导致死锁的发生。这种情况下，由于协程在同一线程中执行，死锁可能会导致整个程序无法继续执行。

  5. 需要特定的语言和库支持: 并非所有编程语言都原生支持协程，需要特定的语言和库支持。此外，不同的库和框架对于协程的实现方式和性能特点也可能不同，需要开发者进行选择和权衡。

协程类的设计

本文章中协程在切换时，需要程序员指定协程有哪些状态，根据状态进行操作。同时在协程中提供一个主协程作为中转协程，主协程没有栈空间，只负责中转。例如协程1要获得执行权，需要将协程1和主协程的上下文进行切换，将协程1切入执行，将主协程切出；当协程1要让出执行权时，需要将主协程和协程1上下文进行切换，将协程1切出，将执行权还给主协程。

协程状态

  • INITIALIZED：初始化状态，刚刚创建协程；
  • PAUSED：暂停状态，等待资源或某件事发生；
  • RUNNING：运行状态，协程已经开始执行任务；
  • FINISHED：结束状态，协程已经执行完任务，不需要执行其他操作。
  • EXECUTABLE：可执行状态，等待分配CPU或事件触发；
  • EXCEPTIONAL：异常状态，协程执行过程中遇到问题。

成员

首先效仿线程，我们给予协程一个id，用来标识某个协程；然后是协程的上下文结构体还有栈指针和栈空间大小，其次是协程的状态，最后给出协程的一个回调函数。

  • coroutine_id_：协程id
  • coroutine_ucontext_：协程上下文
  • coroutine_stack_ptr_：协程栈指针
  • coroutine_stack_size_：协程栈大小
  • coroutine_state_：协程状态
  • coroutine_callback_func_：协程回调函数

方法

除了必要的私有数据成员访问方法，还需要提供两种构造函数，一种负责主协程，也就是中转协程，另一种构造常用协程。此外当协程执行过程中出现错误或其他原因允许切换协程的回调函数。还需要将当前协程切入执行和将当前协程切出让出执行权的函数。

此外还需要一些静态函数来服务类，如设置和返回当前正在执行协程，将当前正在执行协程切换到其他状态。

  • getCoroutineID：返回协程id
  • getCoroutineState：返回协程状态
  • acquireExecution：获得执行权
  • yieldExecution：让出执行权
  • Coroutine：构造函数，包含两种
  • ~Coroutine：析构函数，释放栈空间
  • setCallbackFunction：设置协程的回调函数
  • SetExecutingCoroutine：设置正在执行的协程
  • GetExecutingCoroutine：返回正在执行的协程
  • GetExecutingCoroutineState：返回正在执行的协程的状态
  • GetExecutingCoroutineID：返回正在执行的协程的id
  • GetTotalCoroutineCount：返回协程总数
  • MainFunction：协程绑定的函数
  • ConvertToPaused：将正在执行的协程切换到暂停状态
  • ConvertToExecutable：将正在执行的协程切换到可执行状态

源代码

#pragma once

#include <iostream>
#include <ucontext.h>
#include <memory>
#include <assert.h>
#include <functional>
#include "uncopyable.h"

class Coroutine : public std::enable_shared_from_this<Coroutine> {
private:
    enum STATE {
        INITIALIZED,
        PAUSED,
        RUNNING,
        FINISHED,
        EXECUTABLE,
        EXCEPTIONAL
    };
private:
    Coroutine();
public:
    typedef std::shared_ptr<Coroutine> ptr;
    Coroutine(std::function<void()> func, size_t stack_size = 0);
    ~Coroutine();
    const size_t getCoroutineID() const { return coroutine_id_; }
    STATE getCoroutineState() const { return coroutine_state_; }
    void setCallbackFunction(std::function<void()> func);
    void acquireExecution();
    void yieldExecution();
public:
    static void SetExecutingCoroutine(Coroutine* coroutine);
    static Coroutine::ptr GetExecutingCoroutine();
    static void ConvertToPaused();
    static void ConvertToExecutable();
    static size_t GetTotalCoroutineCount();
    static size_t GetExecutingCoroutineID();
    static STATE GetExecutingCoroutineState();
private:
    static void MainFunction();
private:    
    size_t coroutine_id_ = 0;
    ucontext_t coroutine_ucontext_;
    void* coroutine_stack_ptr_;
    size_t coroutine_stack_size_ = 0;
    std::function<void()> coroutine_callback_func_;
    STATE coroutine_state_ = INITIALIZED;
};
#include "coroutine.h"

// 用来初始化协程id
static thread_local size_t COROUTINE_ID = {0};
// 用来跟踪协程个数
static thread_local size_t COROUTINE_COUNTS = {0};
// 当前线程正在执行的协程
static thread_local Coroutine* EXECUTING_COROUTINE = nullptr;
// 用于协程切换的调度协程
static thread_local Coroutine::ptr SCHEDULER_COROUTINE = nullptr;
// 默认协程栈大小
static size_t COROUTINE_STACK_DEFAULT_SIZE = 128 * 1024;

// 提供更方便的开辟和释放空间方法
class CoroutineStackAllocator {
public:
    static void* Alloc(size_t stack_size) {
        return malloc(stack_size);
    }

    static void Dealloc(void* stack_ptr, size_t stack_size) {
        return free(stack_ptr);
    }
};

Coroutine::Coroutine() {
    coroutine_state_ = RUNNING;
    SetExecutingCoroutine(this);
    assert(!getcontext(&coroutine_ucontext_));
    ++COROUTINE_COUNTS;
    std::cout << "scheduler coroutine constructed id = " << coroutine_id_ << std::endl;
}

Coroutine::Coroutine(std::function<void()> func, size_t stack_size):
    coroutine_id_(++COROUTINE_ID),
    coroutine_callback_func_(func) {
    ++COROUTINE_COUNTS;
    coroutine_stack_size_ = stack_size ?stack_size : COROUTINE_STACK_DEFAULT_SIZE;
    coroutine_stack_ptr_ = CoroutineStackAllocator::Alloc(coroutine_stack_size_);
    assert(!getcontext(&coroutine_ucontext_));
    coroutine_ucontext_.uc_link = nullptr;
    coroutine_ucontext_.uc_stack.ss_sp = coroutine_stack_ptr_;
    coroutine_ucontext_.uc_stack.ss_size = coroutine_stack_size_;
    makecontext(&coroutine_ucontext_, &MainFunction, 0);
    std::cout << "coroutine " << coroutine_id_ << " constructed" << std::endl;
}

Coroutine::~Coroutine() {
    --COROUTINE_COUNTS;
    if(coroutine_stack_ptr_) {
        assert(coroutine_state_ == INITIALIZED || coroutine_state_ == FINISHED || coroutine_state_ == EXCEPTIONAL);
        CoroutineStackAllocator::Dealloc(coroutine_stack_ptr_, coroutine_stack_size_);
    } else {
        assert(!coroutine_callback_func_);
        assert(coroutine_state_ == RUNNING);
        Coroutine* cur = SCHEDULER_COROUTINE.get();
        if(cur == this) {
            SetExecutingCoroutine(nullptr);
        }
    }
    std::cout << "coroutine " << coroutine_id_ << " descructed" << std::endl;
}

void Coroutine::setCallbackFunction(std::function<void()> func) {
    assert(coroutine_stack_ptr_);
    assert(coroutine_state_ == INITIALIZED || coroutine_state_ == EXCEPTIONAL || coroutine_state_ == FINISHED);
    coroutine_callback_func_ = func;
    assert(!getcontext(&coroutine_ucontext_));
    coroutine_ucontext_.uc_link = nullptr;
    coroutine_ucontext_.uc_stack.ss_sp = coroutine_stack_ptr_;
    coroutine_ucontext_.uc_stack.ss_size = coroutine_stack_size_;
    makecontext(&coroutine_ucontext_, &MainFunction, 0);
    coroutine_state_ = INITIALIZED;
}

void Coroutine::acquireExecution() {
    SetExecutingCoroutine(this);
    coroutine_state_ = RUNNING;
    std::cout << "coroutine " << coroutine_id_ << " acquireExecution" << std::endl;
    assert(!swapcontext(&SCHEDULER_COROUTINE->coroutine_ucontext_, &coroutine_ucontext_));
}

void Coroutine::yieldExecution() {
    SetExecutingCoroutine(SCHEDULER_COROUTINE.get());
    assert(!swapcontext(&coroutine_ucontext_, &SCHEDULER_COROUTINE->coroutine_ucontext_));
}

void Coroutine::SetExecutingCoroutine(Coroutine* coroutine) {
    EXECUTING_COROUTINE = coroutine;
}

Coroutine::ptr Coroutine::GetExecutingCoroutine() {
    if(EXECUTING_COROUTINE) {
        return EXECUTING_COROUTINE->shared_from_this();
    }
    Coroutine::ptr scheduler_coroutine(new Coroutine);
    assert(EXECUTING_COROUTINE == scheduler_coroutine.get());
    SCHEDULER_COROUTINE = scheduler_coroutine;
    return EXECUTING_COROUTINE->shared_from_this();
}

void Coroutine::ConvertToPaused() {
    Coroutine::ptr cur = GetExecutingCoroutine();
    assert(cur->coroutine_state_ == RUNNING);
    cur->coroutine_state_ = PAUSED;
    cur->yieldExecution();
}

void Coroutine::ConvertToExecutable() {
    Coroutine::ptr cur = GetExecutingCoroutine();
    assert(cur->coroutine_state_ == RUNNING);
    cur->coroutine_state_ = EXECUTABLE;
    cur->yieldExecution();
}

size_t Coroutine::GetTotalCoroutineCount() {
    return COROUTINE_COUNTS;
}

size_t Coroutine::GetExecutingCoroutineID() {
    if(EXECUTING_COROUTINE) {
        return EXECUTING_COROUTINE->coroutine_id_;
    }
    return 0;
}

Coroutine::STATE Coroutine::GetExecutingCoroutineState() {
    if(EXECUTING_COROUTINE) {
        return EXECUTING_COROUTINE->coroutine_state_;
    }
    return EXCEPTIONAL;
}

void Coroutine::MainFunction() {
    Coroutine::ptr cur = GetExecutingCoroutine();
    assert(cur);
    try
    {
        cur->coroutine_callback_func_();
        cur->coroutine_callback_func_ = nullptr;
        cur->coroutine_state_ = FINISHED;
    } catch(const std::exception& e) {
        cur->coroutine_state_ = EXCEPTIONAL;
        std::cerr << e.what() << '\n';
    } catch(...) {
        cur->coroutine_state_ = EXCEPTIONAL;
        std::cout << "something else happened" << std::endl;
    }
    std::cout << "coroutine " << cur->coroutine_id_ << " finished" << std::endl;
    auto raw_ptr = cur.get();
    cur.reset();
    raw_ptr->yieldExecution();
}

测试

#include "coroutine.h"
#include <thread>
#include <chrono>

void test() {
    std::cout << "function test begin" << std::endl;
    std::cout << "yieldExecution" << std::endl;
    Coroutine::GetExecutingCoroutine()->yieldExecution();
    std::cout << "ConvertToPaused " << std::endl;
    Coroutine::ConvertToPaused();
    std::cout << "ConvertToExecutable" << std::endl;
    Coroutine::ConvertToExecutable();
    std::cout << "function test end" << std::endl;
}

int main() {
    std::cout << "begin test" << std::endl;
    Coroutine::GetExecutingCoroutine();
    Coroutine::ptr coroutine(new Coroutine(test));
    std::cout << "coroutine acquireExecution for first time" << std::endl;
    coroutine->acquireExecution();
    std::cout << "coroutine acquireExecution for second time" << std::endl;
    coroutine->acquireExecution();
    std::cout << "coroutine acquireExecution for third time" << std::endl;
    coroutine->acquireExecution();
    std::cout << "coroutine acquireExecution for four time" << std::endl;
    coroutine->acquireExecution();
    std::cout << "end test" << std::endl;
    return 0;
}

测试结果：

总结

本文实现了基于C++的协程的封装，介绍了协程及其优点和缺点，并给出了源代码和测试代码。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/586992.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

java同步大量数据到本地数据库方法总结

java同步大量数据到本地数据库方法总结

最近在做一个需求&#xff0c;就是我需要对三方接口调用的数据存放到本地的数据库里的数据表里面。那么一开始我就是直接一条一条save&#xff0c;结果发现耗时非常严重&#xff0c;后面我就进行了改进。就是分批次去同步或者分批次去异步。 现在我直接贴出我写的代码&#xf…
阅读更多...
《MySQL对数据库中表的结构的操作》

《MySQL对数据库中表的结构的操作》

文章目录 一、建表二、查看表结构所有能查看到数据库&#xff0c;表的操作痕迹的本质都是服务器保存下来了这些操作记录。 三、修改表1.改表名字2.添加表记录3.添加表的更多字段4.修改表的字段5. 删除表的字段 总结 以下的数据库表的操作全是基于user_db这个数据库操作的&#…
阅读更多...
maven聚合，继承等方式

maven聚合，继承等方式

需要install安装到本地仓库&#xff0c;或者私服&#xff0c;方可使用自己封装项目 编译&#xff0c;测试&#xff0c;打包&#xff0c;安装&#xff0c;发布 parent: <?xml version"1.0" encoding"UTF-8"?> <project xmlns"http://mav…
阅读更多...
Golang图片验证码的使用

Golang图片验证码的使用

一、背景 最近在使用到Golang进行原生开发&#xff0c;注册和登录页面都涉及到图片验证码的功能。找了下第三方库的一些实现&#xff0c;发现了这个库用得还是蛮多的。并且支持很多类型的验证方式&#xff0c;例如支持数字类型、字母类型、音频验证码、中文验证码等等。 项目地…
阅读更多...
《MySQL是怎样运行的》读书笔记(二) 从一条记录说起-InnoDB记录结构

《MySQL是怎样运行的》读书笔记(二) 从一条记录说起-InnoDB记录结构

前言 到现在为止&#xff0c; MySQL 还是一个黑盒&#xff0c;只知道使用客户端发送请求并等待服务器返回结果 那么表中的数据到底存到了哪里?以什么格式存放的? MySQL 是以什么方式来访问的这些数据? 相应的知识储备我只知道MySQL 服务器上负责对表中数据的读取和写入工…
阅读更多...
C语言：文件操作（下）

C语言：文件操作（下）

片头 嗨&#xff01;小伙伴们&#xff0c;在前2篇中&#xff0c;我们分别讲述了C语言&#xff1a;文件操作&#xff08;上&#xff09;和 C语言&#xff1a;文件操作&#xff08;中&#xff09;&#xff0c;今天我们将会学习文件操作&#xff08;下&#xff09;&#xff0c;准…
阅读更多...
C语言异步编程

C语言异步编程

回调函数在异步编程中有着重要的作用&#xff0c;在接口编程应用广泛&#xff0c;实战中经常会注册一个回调函数来接收其他程序返回的数据&#xff0c;这样做的好处是调用者无需主动去获取被调用者的数据&#xff0c;仅仅需要回调&#xff0c;让被调用者去传送数据&#xff0c;…
阅读更多...
VS code 同步odata服务

VS code 同步odata服务

在做UI5得开发过程中&#xff0c;经常会出现odata需要更新 那么已经加载过得项目如何去跟新odata服务呢 可以通过如下步骤 1.右键打开应用信息 2.找到manage service models 3.点击编辑 4.选中 刷新并保存
阅读更多...
C++ | Leetcode C++题解之第60题排列序列

C++ | Leetcode C++题解之第60题排列序列

题目&#xff1a; 题解&#xff1a; class Solution { public:string getPermutation(int n, int k) {vector<int> factorial(n);factorial[0] 1;for (int i 1; i < n; i) {factorial[i] factorial[i - 1] * i;}--k;string ans;vector<int> valid(n 1, 1);…
阅读更多...
mysql主库delete一个没主键的表导致从库延迟很久问题处理

mysql主库delete一个没主键的表导致从库延迟很久问题处理

一 问题描述 发现线上环境一个从库出现延迟&#xff0c;延迟了2天了&#xff0c;还没追上主库。 查看当前运行的sql及事务&#xff0c;发现这个sql语句是在delete一个没主键的表。 二 问题模拟 这里在测试环境复现下这个问题。 2.1 在主库造数据 use baidd; CREATE TABL…
阅读更多...
arthas watch怎么监控指定参数值？

arthas watch怎么监控指定参数值？

watch com.codex.terry.controller.HelloWorldController getUserInJson2 "{params,returnObj}" params[0] "world" -v 要分析的代码&#xff1a; 浏览器请求http://localhost:8080/say/tt&#xff0c;arthas控制台打印的信息如下&#xff1a; 浏览器请…
阅读更多...
LeetCode45：跳跃游戏Ⅱ

LeetCode45：跳跃游戏Ⅱ

题目描述 给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。 每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说&#xff0c;如果你在 nums[i] 处&#xff0c;你可以跳转到任意 nums[i j] 处: 0 < j < nums[i] i j < n 返回到达 nums[n …
阅读更多...
C++成员初始化列表

C++成员初始化列表

我们在类的构造函数中使用成员初始化列表可以带来效率上的提升&#xff0c;那么成员初始化列表在编译后会发生什么就是这篇文章要探究的问题 文章目录 引入成员初始化列表用成员初始化列表优化上面的代码成员初始化列表展开成员初始化列表的潜在危险 参考资料 引入 考虑下面这…
阅读更多...
TDengine写入2000万数据查询体验

TDengine写入2000万数据查询体验

最近在寻找时序数据库&#xff0c;想应用在公司的项目上。 上一篇文章实验了InfluxDB:windows上使用influx2.7学习,还学习了flux语言&#xff0c;最后发现宽表查询比较困难&#xff0c;就放弃了&#xff0c;于是决定试试国产时序数据库TDengine 参考 官方文档&#xff1a;htt…
阅读更多...
有货源和分销单品爆款玩法课

有货源和分销单品爆款玩法课

该课程专注于教授如何利用有货源和分销渠道&#xff0c;打造单品爆款销售策略。学员将学习货源获取、产品定位、市场推广等关键技巧&#xff0c;通过实战案例和实操训练&#xff0c;掌握成功销售单品爆款的方法&#xff0c;提升销售业绩和市场竞争力。 课程大小&#xff1a;6.…
阅读更多...
RabbitMq基础概念知识复习

RabbitMq基础概念知识复习

消息拥有消息头和消息体&#xff0c;消息具有rounting key&#xff0c;主题交换机和扇形交换机都是发布与订阅的实现方式&#xff0c;主题交换机用于匹配接收的消息的rount key 动态匹配模式匹配到多个符合的队列&#xff0c;扇形fanout交换机则不会使用消息的路由key&#xff…
阅读更多...
【AIGC调研系列】InternVL开源多模态模型与GPT-4V的性能对比

【AIGC调研系列】InternVL开源多模态模型与GPT-4V的性能对比

InternVL和GPT-4V都是多模态模型&#xff0c;但它们在性能、参数量以及应用领域上有所不同。 InternVL是一个开源的多模态模型&#xff0c;其参数量为60亿&#xff0c;覆盖了图像/视频分类、检索等关键任务&#xff0c;并在32个视觉-语言基准测试中展现了卓越性能[2]。InternV…
阅读更多...
CYP76AKs的功能分化塑造了鼠尾草属中松香烷型二萜化合物的化学多样性-比较转录组-文献精读12

CYP76AKs的功能分化塑造了鼠尾草属中松香烷型二萜化合物的化学多样性-比较转录组-文献精读12

Functional divergence of CYP76AKs shapes the chemodiversity of abietane-type diterpenoids in genus Salvia "CYP76AKs的功能分化塑造了鼠尾草属中松香烷型二萜化合物的化学多样性"&#xff0c;一片比较转录组的文献&#xff0c;类似比较转录组分析揭示了116种…
阅读更多...
数据仓库Data Warehouse

数据仓库Data Warehouse

数据仓库Data Warehouse 数仓是一种思想，数仓是一种规范，数仓是一种解决方案 1. 数据处理方式 数据处理大致可以分成两大类： 联机事务处理OLTP（on-line transaction processing）联机分析处理OLAP（On-Line Analytical Processing）1.1. OLTP OLTP的全称是On-line Transa…
阅读更多...
O2OA开发平台前端源码级二次开发（Vue3,React）

O2OA开发平台前端源码级二次开发（Vue3,React）

在使用O2OA进行项目定制化开发时&#xff0c;我们可以开发新的前端组件&#xff08;x_component&#xff09;以扩展O2OA来实现更多的业务。这种新增前端组件或者前端业务的开发通常会配合后端自定义应用实现的服务来完成系统内数据的交互。在当系统默认的界面不符合系统UI/UE设…
阅读更多...
最新文章

Copyright @ 2022~2023