c++协程库libfiber之5：协程池

最新推荐文章于 2024-05-18 09:37:34 发布
最新推荐文章于 2024-05-18 09:37:34 发布
阅读量1.1k 收藏 5
点赞数 1
分类专栏： C/C++ 文章标签： 协程 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuanlulu/article/details/111825820
版权

目的

我想在ibfiber的基础上实现一个简单的协程池类。我希望它是单例模式的，并且是线程安全的。
执行的任务由std::function加入到任务队列里。

协程池类的实现

可以看到，下面的协程池类主要是三个接口：getInstance()、AddTask()和Clear()

//协成池，负责管理和调度协程
class FiberPool {
    //使用单例模式来实现
    private:
    static acl::fiber_event FiberLock;
    static FiberPool *local_instance;
    FiberPool(){};
    FiberPool(const FiberPool&);
    FiberPool& operator=(const FiberPool&);

    public:

    //单例模式，获取指针
    static FiberPool *getInstance()
    {
        FiberLock.wait();
        if (local_instance == nullptr)
        {
            local_instance = new FiberPool();
            //启动一个线程，创建协程池开始调度
            std::thread t(FiberThread);
            t.detach();
        }
        FiberLock.notify();
        return local_instance;
    }

    //返回：-1-失败，大于等于零, 成功
    int AddTask(const TaskFuncType &Func) {
        TaskFuncType *ptr = new TaskFuncType(Func);
        m_TaskTBox.push(ptr);
        return 0;
    }

    //清空任务队列
    int Clear() {
        m_TaskTBox.clear(true);
        return 0;
    }

    private:
    //创建调度线程
    static void FiberThread() {
        std::cout << "FiberThread, started!" << std::endl;
        local_instance->CreateFibers(3);//协程池里有三个协程
        std::cout << "after create fibers!" << std::endl;
        acl::fiber::schedule_with(acl::FIBER_EVENT_T_KERNEL); //调度协程
        std::cout << "FiberThread, exit!" << std::endl;
    }

    //用于存放入库的任务函数
    TaskBoxType m_TaskTBox;

    //用于存放协程
    std::vector<std::shared_ptr<TaskFiber>> FiberVector;
    void CreateFibers(unsigned int Num) {
        std::cout << "create [" << Num << "]" << " fibers for pool>>" << std::endl;
        for (unsigned int i = 0; i < Num; i++) {
            auto task = std::make_shared<TaskFiber>(&m_TaskTBox);
            task->start();
            FiberVector.push_back(task);
        }
        return;
    }

};

其中getInstance()用于获取单例的指针。为了能够线程安全，使用静态的acl::fiber_event进行互斥。在第一次调用getInstance()时，除了申请内存，还会创建单独的协程池调度线程。协程池线程的函数FiberThread()也是静态的，创建的协程数可以改变。

协程池的任务使用std::function封装，这样接口的调用方完全可以用std::bind来把参数和函数绑定好传进来。任务队列用acl::fiber_tbox<>,这个类型类似一个动态数组，但是可以确保线程数据的安全，不需要额外的同步方式。当然也可以用alc::channel<>来作为任务队列，只是alc::channel<>默认容量是100，不能动态递增。

//任务类型
using TaskFuncType = std::function<int (void)>;
//任务队列类型
using TaskBoxType = acl::fiber_tbox<TaskFuncType>;

AddTask()和Clear()分别用于提交任务和清空任务。

注意，上述所有的接口都是线程安全的，也是“协程-线程”安全的，这都得益于libfiber精巧的互斥变量设计。

协程类的实现

协程类的实现很简单，继承acl::fiber，实现run()函数即可。在run()函数里，只要不停的从任务队列读任务即可。

//协程类，作用就是从tbox获取任务然后执行
class TaskFiber : public acl::fiber {
    public:
    //实例化的时候必须传入TaskBoxType的指针
    TaskFiber(TaskBoxType *PtrTaskBox):m_PtrTaskBox(PtrTaskBox){};

    private:
    //保存指向任务队列的指针
    TaskBoxType *m_PtrTaskBox = NULL;
    
    protected:
	// @override
	void run(void) {
        
        std::cout << "fiber-id=[" << get_id() << "], started!" << std::endl;
        //循环检测是否有任务
        while(!self_killed()) {
            //获取任务，超时时间1000ms
            TaskFuncType* PtrFunc =  m_PtrTaskBox->pop(1000);
            if (NULL != PtrFunc) {
                std::cout << "fiber-id=[" << get_id() << "]" << ", get a task>>" << std::endl;
                (*PtrFunc)();
                delete PtrFunc;
                std::cout << "fiber-id=[" << get_id() << "]" << ", task done<<" << std::endl;
                yield(); //把本协程调度出去
            }
        }

        std::cout << "fiber-id=[" << get_id() << "]" << ", fiber EXIT>>" << std::endl;
    }

};

因为我是用acl::fiber_tbox<>做任务队列，这个结构只能存指针，所以加入任务时申请内存，执行完要释放内存，这里可以加一个缓存池，避免频繁的申请释放内存。或者使用固定容量的alc::channel<>来作为任务队列，是alc::channel<>保存的是拷贝而不是指针，但是默认容量是100，不能动态递增。

调用协程池

为一个函数绑定两个不同的参数作为任务提交给协程池，等待协程执行完毕。

#include <iostream>
#include <functional>
#include <thread>
#include <chrono>

#include "fiberPool.h"

int do_nothing(int num)
{
    std::cout<< "I'm worker [" << num << "]" << std::endl;
    return 0;
}


int main()
{
    FiberPool* ptrPool = FiberPool::getInstance();

    //为函数绑定两个不同的参数进行测试
    TaskFuncType func1 = std::bind(do_nothing, 1);
    TaskFuncType func2 = std::bind(do_nothing, 2);

    std::cout << "add 2 task now!" << std::endl;
    ptrPool->AddTask(func1);
    ptrPool->AddTask(func2);

    using namespace std::chrono_literals;
    std::this_thread::sleep_for(5s);
}

输出内容是：

$ ./fiberPool
FiberThread, started!add 2 task now!
create [3] fibers for pool>>

after create fibers!
fiber-id=[1], started!
fiber-id=[1], get a task>>
I'm worker [1]
fiber-id=[1], task done<<
fiber-id=[2], started!
fiber-id=[2], get a task>>
I'm worker [2]
fiber-id=[2], task done<<
fiber-id=[3], started!

完整的代码

总共一个头文件，一个CPP文件就可以编译成一个协程池的动态库

协程池头文件 fiberPool.h
#include <functional>
#include <memory>
#include <vector>
#include <iostream>
#include <thread>
#include <mutex>

#include "fiber/libfiber.hpp"

//任务类型
using TaskFuncType = std::function<int (void)>;
//任务队列类型
using TaskBoxType = acl::fiber_tbox<TaskFuncType>;


//协程类，作用就是从tbox获取任务然后执行
class TaskFiber : public acl::fiber {
    public:
    //实例化的时候必须传入TaskBoxType的指针
    TaskFiber(TaskBoxType *PtrTaskBox):m_PtrTaskBox(PtrTaskBox){};

    private:
    //保存指向任务队列的指针
    TaskBoxType *m_PtrTaskBox = NULL;
    
    protected:
	// @override
	void run(void) {
        
        std::cout << "fiber-id=[" << get_id() << "], started!" << std::endl;
        //循环检测是否有任务
        while(!self_killed()) {
            //获取任务，超时时间1000ms
            TaskFuncType* PtrFunc =  m_PtrTaskBox->pop(1000);
            if (NULL != PtrFunc) {
                std::cout << "fiber-id=[" << get_id() << "]" << ", get a task>>" << std::endl;
                (*PtrFunc)();
                delete PtrFunc;
                std::cout << "fiber-id=[" << get_id() << "]" << ", task done<<" << std::endl;
                yield(); //把本协程调度出去
            }
        }

        std::cout << "fiber-id=[" << get_id() << "]" << ", fiber EXIT>>" << std::endl;
    }

};


//协成池，负责管理和调度协程
class FiberPool {
    //使用单例模式来实现
    private:
    static acl::fiber_event FiberLock;
    static FiberPool *local_instance;
    FiberPool(){};
    FiberPool(const FiberPool&);
    FiberPool& operator=(const FiberPool&);

    public:

    static FiberPool *getInstance()
    {
        FiberLock.wait();
        if (local_instance == nullptr)
        {
            local_instance = new FiberPool();
            //启动一个线程，创建协程池开始调度
            std::thread t(FiberThread);
            t.detach();
        }
        FiberLock.notify();
        return local_instance;
    }

    //返回：-1-失败，大于等于零, 成功
    int AddTask(const TaskFuncType &Func) {
        TaskFuncType *ptr = new TaskFuncType(Func);
        m_TaskTBox.push(ptr);
        return 0;
    }

    //清空任务队列
    int Clear() {
        m_TaskTBox.clear(true);
        return 0;
    }

    //目前协会池设计不会终止

    private:
    //创建调度线程
    static void FiberThread() {
        std::cout << "FiberThread, started!" << std::endl;
        local_instance->CreateFibers(3);//协程池里有三个协程
        std::cout << "after create fibers!" << std::endl;
        acl::fiber::schedule_with(acl::FIBER_EVENT_T_KERNEL); //调度协程
        std::cout << "FiberThread, exit!" << std::endl;
    }

    //用于存放入库的任务函数
    TaskBoxType m_TaskTBox;

    //用于存放协程
    std::vector<std::shared_ptr<TaskFiber>> FiberVector;
    void CreateFibers(unsigned int Num) {
        std::cout << "create [" << Num << "]" << " fibers for pool>>" << std::endl;
        for (unsigned int i = 0; i < Num; i++) {
            auto task = std::make_shared<TaskFiber>(&m_TaskTBox);
            task->start();
            FiberVector.push_back(task);
        }
        return;
    }

};
协程池源文件 fiberPool.cpp

大部分逻辑都写在头文件里了，源文件只要定义静态变量即可。

#include "fiberPool.h"

acl::fiber_event FiberPool::FiberLock;
FiberPool *FiberPool::local_instance = nullptr;
测试源码 main.cpp
#include <iostream>
#include <functional>
#include <thread>
#include <chrono>

#include "fiberPool.h"

int do_nothing(int num)
{
    std::cout<< "I'm worker [" << num << "]" << std::endl;
    return 0;
}


int main()
{
    FiberPool* ptrPool = FiberPool::getInstance();

    //为函数绑定两个不同的参数进行测试
    TaskFuncType func1 = std::bind(do_nothing, 1);
    TaskFuncType func2 = std::bind(do_nothing, 2);

    std::cout << "add 2 task now!" << std::endl;
    ptrPool->AddTask(func1);
    ptrPool->AddTask(func2);

    using namespace std::chrono_literals;
    std::this_thread::sleep_for(5s);
}

参考资料

c++协程库libfiber之4：定时和延时

c++协程库libfiber之3：调度协程的三种方式

c++协程库libfiber之2：编译及例子

c++协程库libfiber之1：简单介绍

libfiber的源码工程主页

libfiber的贡献者爱奇艺的技术分享：爱奇艺网络协程编写高并发应用实践

ACL作者介绍libfiber的博客：acl开发–协程篇

yuanlulu
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c/c++ windows ble 蓝牙操作
06-20
c/c++ windows 通过winrt操作ble 蓝牙 #include <windows.h> #include <iostream> #include <winrt/Windows.Foundation.h> #include <winrt/Windows.Foundation.Collections.h> #include <winrt/Windows.Devices.Bluetooth.h> #include <winrt/Windows.Devices.Enumeration.h> #include <winrt/Windows.Devices.Bluetooth.Advertisement.h> #include <winrt/Windows.Devices.Bluetooth.GenericAttributeProfile.h> #include <winrt/Windows.Storage.Streams.h>
并发高级之详解volatile——你看到了多少假象
Ethan_199402的博客
06-04 474
1.引读 我们先从一个demo看起```java public class Data { public int a = 1; public static void main(String[] args) { Data data = new Data(); new Thread(() ->{ try { //休眠一秒后修改data.a的值为0 Thread.sleep(1000); data.a =
探索高性能协程库：libfiber
最新发布
gitblog_00002的博客
05-18 248
探索高性能协程库：libfiber 项目地址:https://gitcode.com/iqiyi/libfiber 在这个日益追求效率和并发性能的编程时代，libfiber提供了一个跨平台的解决方案，让开发者能够轻松实现高并发的网络应用程序服务，无需陷入复杂的异步事件驱动模型。libfiber支持多种操作系统，包括Linux、FreeBSD、MacOS以及Windows，并且在这些平台上实现了se...
c++协程库实现-day2
jiewaikexue的博客
04-19 323
代码部分指路:xfiber.cppxfiber.h 指路: B站:毛毛and西西 视频 : c++携程库,第2部分 协程框架已开源到github和gitee上 gitee地址:https://gitee.com/meiqizhang/xfiber github地址：https://github.com/meiqizhang/xfiber.git xfiber.cpp #include "xfiber.h" //先扫描当前路径下寻找,然后再到系统库下面 #include <iostream> XF
C/C++ 协程库boost.coroutine2、魅族libgo、腾讯libco、开源libaco详解
qq_23350817的博客
05-06 2874
最近研究高性能C++协程，网上了解到了魅族libgo、腾讯libco、开源libaco、boost coroutine，这里记录一下。 1 什么是协程 协程可以很轻量的在子例程中进行切换，它由程序员进行子例程的调度（即切换）而不像线程那样需要内核参与，同时也省去了内核线程切换的开销，因为一个协程切换保留的就是函数调用栈和当前指令的寄存器，而线程切换需要陷入内核态，改变线程对象状态。 go语言就已经把协程作为基础设施提供语言级的支持，cpp这种出了名的给程序员自由的语言肯定不会提供语言级的支持。
C/C++编程：libfiber例子学习
OceanStar的博客
07-09 274
channel_cpp #include <acl-lib/acl_cpp/lib_acl.hpp> #include <acl-lib/fiber/libfiber.hpp> #include <zconf.h> struct A{ char buf[256]; }; class fiber_consumer : public acl::fiber{ public: explicit fiber_consumer(int n,
好用的协程库libfiber-master
11-28
该协程库为开源库，是https://blog.csdn.net/DefiniteGoal/article/details/122268927这篇文章的博主所提供的的，libfiber提供了C和C++两种API，但实际C++调用的还是C的代码，故只需要看懂C的协程实现即可。...
C++ 开源协程库 libco——原理及应用1
08-03
【C++ 开源协程库 libco——原理及应用】 协程，作为一种轻量级的并发机制，近年来在编程领域中越来越受到重视。不同于传统的线程模型，协程不涉及昂贵的上下文切换，而是通过用户空间的协作来实现并发执行。C++ ...
coroutinecc:基于ucontext实现的C++协程库
04-28
Coroutinecc 协程库 基于*nix的实现 参考云风的实现 支持linux、unix、Mac OS X 协程库实现相关文章可以参考 未来改进： 提供对等协程实现 hook进一些systemcall，将所有fd设为非阻塞，并在epoll中切换协程，实现...
基于ucontext实现的C++协程库.zip
04-30
本项目“基于ucontext实现的C++协程库”是针对C++编程语言设计的，其主要目标是利用ucontext库来实现轻量级的协程机制。 ucontext是Unix-like系统中的一个API，用于保存和恢复进程上下文，这使得程序可以在不同的...
C/C++协程库libco：微信怎样漂亮地完成异步化改造
02-25
如今，微信拥有月活跃用户8亿。不可否认，当今的微信后台拥有着强大的并发能力。不过，正如罗马并非一日建成；微信的技术也曾经略显稚嫩。微信诞生于2011年1月，当年...自2013年起稳定运行于微信的数万台机器之上。早期
C++ 协程的近况、设计与实现中的细节和决策
Linuxhus的博客
05-27 417
时至2018年的今天，C++ 在互联网服务端开发方向依然占据着相当大的份额；百度，腾讯，甚至以java为主流开发语言的阿里都在大规模使用C++做互联网服务端开发，而这恰恰是本文想要讨论的范畴。 C++协程实现及原理分析视频讲解： C/C++ Linux服务器开发高级架构学习视频点击：C/C++Linux服务器开发高级架构/Linux后台架构师-学习视频 协程的实现与原理剖析丨掌握协程的运用丨实例讲解（上） 协程的实现与原理剖析丨掌握协程的运用丨实例讲解（下） 第1章 C++协程近况简介 协程分
C++协程线程池
个人进步之路
03-28 2929
#协程线程池 如何等待协程完成 协程表示懒任务,完成任务时恢复协程,从而获取任务返回值. 以线程中执行任务为例,来看如何定制协程机器的"零件"来实现等待并获取任务返回值: 任务<大小型>读文件(){ 常 动 结果=协待 异步读文件{"../主.c++"}; 协中 结果.大小(); } 整个流程大概这样: 创建协程后,执行协待承诺.初始挂起,由于返回从不挂起,不会挂起协程,执行协程函数体(函数体),然后执行协待异步读文件{"../主.c++"},协待式会产生3个结果: 1,挂起当前协程
纤程(Fiber)基本原理
xuejianxinokok的专栏
11-30 280
与协程相比，纤程是一个鲜为人知的概念，但它是协作多任务处理的一个非常强大的补充。作为游戏行业的图形程序员，我非常欣赏纤程带来的巨大灵活性。事实上，我觉得由于缺乏足够的公开材料来谈论纤程，这项技术有点被低估了。在这篇博文中，我将写下我对纤程基础知识的一些了解。这篇文章中提到的所有内容都将专门针对 C++，尽管其他语言中也存在类似的概念。对纤程零知识的读者将了解它是什么以及我们如何在图形渲染中利用它。
读爱奇艺开源协程项目—libfiber
DefiniteGoal的博客
01-01 616
1、libfiber介绍 首先说下为什么要写这个博客，一是记录自己学习，二是防止学习后遗忘，这样即使忘了还可以通过博客来回忆起一个大概 开源项目位置：https://github.com/iqiyi/libfiber libfiber中文介绍:https://github.com/iqiyi/libfiber/blob/master/README_cn.md 开源团队：爱奇艺 相关协程的开源项目不少，boost，libco，libfiber等等 协程的概念在此就不说了，不过协程的实现可以简单说下，我只看过l
深入浅出c++协程丨C++协程实现
Linuxhus的博客
05-12 1702
1|0一些实现的c++协程 C++协程实现相关视频讲解：（视频代码资料点击 正在跳转 获取） 协程的实现与原理剖析（上） 协程的实现与原理剖析（下） 协程是一种函数对象，可以设置锚点做暂停，然后再该锚点恢复继续运行，我觉得这是最合适的定义，用户态线程，轻量级线程，可中断恢复的函数，这些都不够精确，先来认识一个boost 1.75的一个例子 #include <iostream> #include <boost/coroutine2/all.hpp> void cor
线程池与协程池的原理与实现【c++与gloang】【万字分析】
weixin_44545838的博客
06-02 1875
C++ 线程池是一种多线程编程实现方式，它可以将多个任务并发执行，提高程序的运行效率。具体而言，线程池维护一个线程集合，在程序运行时创建一定数量的线程，并将任务插入到队列中，等待空闲线程来执行。Go语言中的线程池通常指的是协程池，它是一种通过重复利用大量轻量级协程来节省系统开销和提高并发性能的技术。协程轻量、创建和销毁成本低。但是，如果简单地在程序中创建大量的协程，会导致系统开销较大，降低性能。因此，使用协程池管理和控制协程数量是一种有效的解决方案。
C++进阶（二）线程池、异常处理、协程
芸兮的博客
12-31 434
title: C++进阶（二）C++新特性：智能指针、右值引用、lambda、多线程操作、function和bind、可变模板参数description: C++进阶（二）C++新特性：智能指针、右值引用、lambda、多线程操作、function和bind、可变模板参数tag: C++
C++libco协程
NINE_world的博客
03-19 1021
什么是协程？ 协程：协同运行的子程序（函数）； 协程：协同运行的进程（shell中的概念） 协程是能暂停执行以在之后恢复的函数。协程是无栈的：它们通过返回到调用方暂停执行，并且从栈分离存储恢复所要求的数据。这允许编写异步执行的顺序代码（例如不使用显式的回调来处理非阻塞 I/O），还支持对惰性计算的无限序列上的算法及其他用途。 协程可以被视为提供特殊控制流的语言级构造。 与抢占式线程相比，协程开关是协作的（程序员控制开关何时发生）。协程开关中不涉及内核。 单核情况下，线程和协程都是不能并行的，但是谁快？是协程
C++ 20 协程示例
04-01
很抱歉，我无法提供代码示例，因为作为AI语言模型，我无法编写代码。但我可以为您解释一下协程的概念和用法。 协程（Coroutine）是一种用户级的轻量级线程，也称为协作式多任务。它不同于操作系统内核级的线程，协程不会被操作系统内核调度，而是由用户代码控制。在协程中，一个线程可以有多个执行流，这些执行流在适当的时候可以相互切换，从而实现多任务并发。 协程是一种非常有用的编程技术，用于编写高效、可读性强、可维护的代码。协程通常用于异步编程，因为它可以在不阻塞主线程的情况下执行耗时的操作。 以下是一个可能的协程示例： ```python import asyncio async def coroutine_1(): print('Coroutine 1 started') await asyncio.sleep(1) print('Coroutine 1 finished') async def coroutine_2(): print('Coroutine 2 started') await asyncio.sleep(2) print('Coroutine 2 finished') async def main(): task1 = asyncio.create_task(coroutine_1()) task2 = asyncio.create_task(coroutine_2()) print('Main started') await asyncio.gather(task1, task2) print('Main finished') asyncio.run(main()) ``` 在上面的示例中，我们定义了两个协程函数 coroutine_1 和 coroutine_2，这些函数用于执行一些异步任务。然后我们定义了一个主函数 main，它创建了两个任务 task1 和 task2，这些任务会在协程函数中执行。最后，我们使用 asyncio.run() 函数来运行主函数，从而启动协程并等待它们完成。 在上面的示例中，我们使用了 asyncio 库来实现协程。asyncio 是 Python 3 中的一个标准库，它提供了一些工具和函数来编写协程代码。asyncio 库的主要组件是事件循环（Event Loop），它负责调度协程的执行。我们使用 asyncio.run() 函数来创建一个新的事件循环并运行协程。然后我们使用 asyncio.create_task() 函数来创建任务，这些任务会在协程函数中执行。最后，我们使用 asyncio.gather() 函数来等待所有任务完成。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值