C++开源协程库libgo

最早接触协程的概念是几年前使用SRS（Simple-RTMP-Server）的时候，它使用State Threads做底层IO。State Threads虽然是网络架构库，但其中关于协程的实现令人映像深刻，不过它目前只支持linux。关于State Threads，详见：网络架构库：State Threads

一.libgo

libgo是一个使用 C++11 编写的协作式调度的stackful有栈协程库, 同时也是一个强大的并行编程库。支持linux平台，MacOS和windows平台。
libgo库的github地址：https://github.com/yyzybb537/libgo
使用libgo编写并行程序，即可以像golang一样开发迅速且逻辑简洁，又有C++原生的性能优势。它的特点有：
1.提供golang一般功能强大协程，基于corontine编写代码，可以以同步的方式编写简单的代码，同时获得异步的性能。
2.支持海量协程, 创建100万个协程只需使用2GB内存。
3.允许用户自由控制协程调度点，随时随地变更调度线程数。
4.支持多线程调度协程，极易编写并行代码，高效的并行调度算法，可以有效利用多个CPU核心。
5.可以让链接进程序的同步的第三方库变为异步调用，大大提升其性能。再也不用担心某些数据库官方不提供异步驱动了，比如hiredis、mysqlclient这种客户端驱动可以直接使用，并且可以得到不输于异步驱动的性能。
6.动态链接和静态链接全都支持，便于使用C++11的用户静态链接生成可执行文件并部署至低版本的linux系统上。
7.提供协程锁(co_mutex)、定时器、channel等特性，帮助用户更加容易地编写程序。
8.网络性能强劲，在Linux系统上超越ASIO异步模型，尤其在处理小包和多线程并行方面非常强大。

二.协程

1.高并发编程里多线程(进程)的弊端

其实从著名的 C10K 问题的时候， 就谈到了高并发编程时， 采用多线程(或进程)是一种不可取的解决方案， 核心原因是因为线程(或进程)本质上都是操作系统的资源， 每个线程需要额外占用1M或者2M的内存空间， 所以2G内存，能承受的线程数差不多只能到1k这个量级。而且线程的调度由操作系统调度， 当线程或者进程数到达一定量级的时候， 据有人试验的结果是并发的线程数到达1k以上后， 操作系统基本上就已经不堪重负，调度不过来了。

2.事件驱动

已知多线程已经无法解决高并发问题， 所以才有了异步IO，事件驱动等概念来解决高并发编程。 很典型的就是 Node.js ，传说中的事件驱动， 其实就是在底层使用了 libuv 然后通过各种回调函数来注册事件， 当事件触发的时候回调函数也被触发。 使用事件驱动的方式确实能解决高并发的问题， 但是因为事件驱动最费劲的就是各种丧心病狂不停的回调， 在回调里面再嵌套回调，容易陷入所谓的【回调地狱】。 这也是 Node.js 最受人诟病的地方。

3.高并发解决方案之协程

面向对象最典型的语言是 Java , 事件驱动最典型的语言是 Node.js , 协程最典型的语言就是 golang 。个人看来协程相对于事件驱动是一种更先进的高并发解决方案， 把复杂的逻辑和异步都封装在底层， 让程序员在编程时感觉不到异步的存在。协程也叫用户级线程， 很多人分不清楚协程和线程和进程的关系。 简单的说就是：线程和进程的调度是由操作系统来调控， 而协程的调度由用户自己调控。 所以协程调度器可以在协程A即将进入阻塞IO操作， 比如 socket 的 read （其实已经设置为异步IO ）之前， 将该协程挂起，把当前的栈信息 StackA 保存下来， 然后切换到协程B， 等到协程A的该 IO操作返回时， 再根据 StackA 切回到之前的协程A当时的状态。

三.编译和使用

linux：

$ mkdir build
$ cd build
$ cmake .

windows：
3.0版本兼容windows，直接用master分支就行
在windows上使用编译libgo最好用git去clone源码，不要下载压缩包然后解压，避免不必要的问题。

#For example vs2015(x64)：
$ cmake .. -G"Visual Studio 14 2015 Win64"

#For example vs2015(x86)：
$ cmake .. -G"Visual Studio 14 2015"

VS2017也是支持的，如果想执行test代码，需要链接boost库

#For example：
$ cmake .. -G"Visual Studio 14 2015 Win64" -DBOOST_ROOT="e:\\boost_1_69_0"

一个简单的例子

/************************************************
 * libgo sample1
*************************************************/
#include "coroutine.h"
#include "win_exit.h"
#include <stdio.h>
#include <thread>

void foo()
{
    printf("function pointer\n");
}

struct A {
    void fA() { printf("std::bind\n"); }
    void fB() { printf("std::function\n"); }
};

int main()
{
    //----------------------------------
    // 使用关键字go创建协程, go后面可以使用:
    //     1.void(*)()函数指针, 比如:foo.
    //     2.也可以使用无参数的lambda, std::bind对象, function对象, 
    //     3.以及一切可以无参调用的仿函数对象
    //   注意不要忘记句尾的分号";".
    go foo;

    go []{
        printf("lambda\n");
    };

    go std::bind(&A::fA, A());

    std::function<void()> fn(std::bind(&A::fB, A()));
    go fn;

    // 也可以使用go_stack创建指定栈大小的协程
    //   创建拥有10MB大栈的协程
    go co_stack(10 * 1024 * 1024) []{
        printf("large stack\n");
    };

    // 协程创建以后不会立即执行，而是暂存至可执行列表中，等待调度器调度。
    // co_sched是默认的协程调度器，用户也可以使用自创建的协程调度器。 
    // 当仅使用一个线程进行协程调度时, 协程地执行会严格地遵循其创建顺序.

    // 仅使用主线程调度协程.
    // co_sched.Start();

    // 以下代码可以使用等同于cpu核心数的线程调度协程.(包括主线程)
    // co_sched.Start(0);

    // 以下代码允许调度器自由扩展线程数，上限为1024.
    // 当有线程被协程阻塞时, 调度器会启动一个新的线程, 以此保障
    // 可用线程数总是等于Start的第一个参数(0表示cpu核心数).
    // co_sched.Start(0, 1024);

    // 如果不想让调度器卡住主线程, 可以使用以下方式:
    std::thread t([]{ co_sched.Start(); });
    t.detach();
    co_sleep(100);
    //----------------------------------

    //----------------------------------
    // 除了上述的使用默认的调度器外, 还可以自行创建额外的调度器,
    // 协程只会在所属的调度器中被调度, 创建额外的调度器可以实现业务间的隔离.

    // 创建一个调度器
    co::Scheduler* sched = co::Scheduler::Create();

    // 启动4个线程执行新创建的调度器
    std::thread t2([sched]{ sched->Start(4); });
    t2.detach();

    // 在新创建的调度器上创建一个协程
    go co_scheduler(sched) []{
        printf("run in my scheduler.\n");
    };

    co_sleep(100);
    return 0;
}

更多demo详见源码的tutorial目录

四.性能

原文链接：https://blog.csdn.net/caoshangpa/article/details/79509140