协程这个概念，最近这几年可是相当地流行了。尤其 go 语言问世之后，内置的协程特性，完全屏蔽了操作系统线程的复杂细节。甚至使 go 开发者“只知有协程，不知有线程”了。当然 C++也有高性能的协程库，比如我了解到的微信的libco、魅族的libgo、以及libcopp，开源libaco、boost的 coroutine，cppcoro，阿里的雅兰亭库(基于c++20特性封装好用的库)。

协程简介

协程不是进程或线程，其执行过程更类似于子例程。一个程序可以包含多个协程，我们来比较下协程和线程，加深下对协程的理解。我们知道多个线程相对独立，有自己的上下文，切换受操作系统控制；而协程也相对独立，有自己的上下文，但是其切换由自己控制，由当前协程切换到其他协程由当前协程来控制。

协程的上下文切换相较线程有哪些提升？

协程上下文切换只涉及CPU上下文切换，而所谓的CPU上下文切换是指少量寄存器（PC / SP / DX）的值修改，协程切换非常简单，就是把当前协程的 CPU 寄存器状态保存起来，然后将需要切换进来的协程的 CPU 寄存器状态加载的 CPU 寄存器上就 ok 了。而对比线程的上下文切换则需要涉及模式切换（从用户态切换到内核态）、以及 16 个寄存器、PC、SP…等寄存器的刷新。线程栈空间通常是 2M，协程栈空间最小 2K。

CPU 调度切换的是进程和线程。尽管线程看起来很美好，但实际上多线程开发设计会变得更加复杂，要考虑很多同步竞争等问题，如锁、竞争冲突等。

多进程、多线程已经提高了系统的并发能力，但是在当今互联网高并发场景下，为每个任务都创建一个线程是不现实的，因为会消耗大量的内存 (进程虚拟内存会占用 4GB [32 位操作系统]，而线程也要大约 4MB)。大量的进程 / 线程出现了新的问题：系统线程会占用非常多的内存空间，过多的线程切换会占用大量的系统时间。

协程刚好可以解决上述2个问题。协程运行在线程之上，当一个协程执行完成后，可以选择主动让出，让另一个协程运行在当前线程之上。并且，协程并没有增加线程数量，只是在线程的基础之上通过分时复用的方式运行多个协程，而且协程的切换在用户态完成，切换的代价比线程从用户态到内核态的代价小很多。

c++20是把协程这一特性加入到语法中了。只是过于灵活，使用上不太友好。如果是c++20以上推荐阿里的雅兰亭库(yalantinglibs)。雅兰亭库这名字起的够优雅，只是百度一搜，还以为是酒店或乡村名居呢，但这并不代表这库不行或不出名。为了更好使用c++20的协程，咨询c++大佬祁宇，《深入应用c++11》作者，推荐c++20以上可使用雅兰亭库，里面不但有封装好用的协程库，还有高性能的coro_rpc 远程过程调用库，方便分布式和解耦应用的开发。

libgo介绍

libgo 是一个使用 C++ 编写的协作式调度的stackful有栈协程库, 同时也是一个强大的并行编程库。支持linux平台，MacOS和windows平台，在c++11以上的环境中都能用。

之前用过go，喜欢它的协程使用方式既简单又方便。而在c++中libgo，不但性能高，使用也简单，比其它几个更好用一些，使用起来比较顺手。这里着重介绍下libgo及其使用。

libgo库的github地址：GitHub - yyzybb537/libgo: Go-style concurrency in C++11

目前也收获了2.8k的星，也算是挺火了。使用libgo编写并行程序，即可以像golang一样开发迅速且逻辑简洁，又有C++原生的性能优势。它的特点有：

1.提供golang一般功能强大协程，基于corontine编写代码，可以以同步的方式编写简单的代码，同时获得异步的性能。

2.支持海量协程, 创建100万个协程只需使用2GB内存。

3.允许用户自由控制协程调度点，随时随地变更调度线程数。

4.支持多线程调度协程，极易编写并行代码，高效的并行调度算法，可以有效利用多个CPU核心。

5.可以让链接进程序的同步的第三方库变为异步调用，大大提升其性能。再也不用担心某些DB官方不提供异步driver了，比如hiredis、mysqlclient这种客户端驱动可以直接使用，并且可以得到不输于异步driver的性能。

6.动态链接和静态链接全都支持，便于使用C++11的用户静态链接生成可执行文件并部署至低版本的linux系统上。

7.提供协程锁(co_mutex), 定时器, channel等特性, 帮助用户更加容易地编写程序。

8.网络性能强劲，在Linux系统上超越ASIO异步模型，尤其在处理小包和多线程并行方面非常强大。

在源码的samples目录下有很多示例代码，内含详细的使用说明，让用户可以很轻易地学会使用libgo。与golang的性能对比：

与腾讯开源的ligco相比，不说性能高低，在易用性方面libgo完胜。在这里插入图片描述

它的使用有多简单呢，可以看一个简单的例子。有种golang的感觉，难怪名字都叫libgo，像极了对golang协程的模仿。

#include <stdio.h>
#include <libgo/coroutine.h>
  
int main(int argc, char **argv)
{
    go []{
        printf("1\n");
        co_yield;
        printf("2\n");
    };
      
    go []{
        printf("3\n");
        co_yield;
        printf("4\n");
    };
      
    return 0;
}

libgo安装配置

引入和使用libgo也是很简单的，如果有vcpkg的话，可直接使用vcpkg安装。如:

$vcpkg.exe install libgo

在linux平台下，可以使用cmake编译和安装libgo。

$ mkdir build
$ cd build
$ cmake ..

在cmake下的libgo使用，CMakeLists.txt中增加以下配置就可以了。

find_package(libgo CONFIG REQUIRED)
target_link_libraries(main PRIVATE libgo::libgo)

libgo简单使用

#include <libgo/coroutine.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;
}

libgo定时器使用

有时候需要定时执行一些任务，libgo的定时器使用真清爽，有一种使用高级语言的感觉。

/************************************************
 * libgo库原生提供了一个线程安全的定时器
 * 还提供了休眠当前协程的方法co_sleep，类似于系统调用sleep, 不过时间单
 * 位是毫秒.
 * 同时HOOK了系统调用sleep、usleep、nanosleep, 在协程中使用这几个系统
 * 调用, 会在等待期间让出cpu控制权, 执行其他协程, 不会阻塞调度线程.
************************************************/
#include <libgo/coroutine.h>

int main()
{
    // 创建一个定时器
    // 第一个参数: 精度
    // 第二个参数: 绑定到一个调度器(Scheduler)
    // 两个参数都有默认值, 可以简便地创建一个定时器: co_timer timer; 
    co_timer timer(std::chrono::milliseconds(1), &co_sched);

    // 使用timer.ExpireAt接口设置一个定时任务
    // 第一个参数可以是std::chrono中的时间长度，也可以是时间点。
    // 第二个参数是定时器回调函数
    // 返回一个co_timer_id类型的ID, 通过这个ID可以撤销还未执行的定时函数
    co_timer_id id1 = timer.ExpireAt(std::chrono::seconds(1), []{
            printf("Timer Callback.\n");
            });

    // co_timer_id::StopTimer接口可以撤销还未开始执行的定时函数
    // 它返回bool类型的结果，如果撤销成功，返回true；
    //     如果未来得及撤销，返回false, 此时不保证回调函数已执行完毕。
    bool cancelled = id1.StopTimer();
    printf("cancelled:%s\n", cancelled ? "true" : "false");

    timer.ExpireAt(std::chrono::seconds(2), [&]{
            printf("Timer Callback.\n");
            co_sched.Stop();
            });

    for (int i = 0; i < 100; ++i)
        go []{
            // 休眠当前协程 1000 milliseconds.
            // 不会阻塞线程, 因此100个并发的休眠, 总共只需要1秒.
            co_sleep(1000);
        };

#if !defined(_WIN32)
    // 系统调用提供的sleep usleep nanosleep都使用HOOK技术,
    // 使其在协程中运行时, 能达到和co_sleep相同的效果.
    go []{
        // 休眠当前协程 1 second
        sleep(1);
    };

    go []{
        // 休眠当前协程 100 milliseconds
        usleep(100 * 1000);
    };
#endif

    co_sched.Start();
    return 0;
}

需要注意的一点是协程的调度是协作式调度，需要协程主动让出执行权，推荐在耗时很长的循环中插入一些yield。除网络IO、sleep等这些是已经被libgo封装hook过的系统调用不会产生阻塞，其它耗时操作会阻塞调度线程的运行，这时请使用co_await, 并启动几个线程去Run内置的线程池中。

编译报错问题

需要注意的一个坑是编译报错问题，这并非是作者的原因。由UTF8和UTF8-BOM编码引起的vc工具链编译报错问题，这真是个巨坑，如果没想到的话，会让人百思不得姐。

VC++ 编译器默认对源文件要求是使用UTF8 BOM模式的。微软vs套件vc++为什么使用GBK和UTF8BOM模式? vs不能识别无BOM头的unicode文件编码，所以如果使用utf-8记得要加上BOM（Byte Order Mark 字节流标记 utf-8 的BOM是 0xEFBBBF）.vs新建工程默认的编码也是这个。如果你的源代码想在多个平台上编译，mac, unix等，那么在windows平台上需要在命令行中加入这个参数 /utf-8。

很多人经常需要把代码分别在linux、windows上编译。在linux中gcc编译的时候，文件格式为utf-8无bom格式，可是如果将文件拿到windows上，用vs编译的时候，发现各种报错，且都是不知道原因的错。这个时候就要考虑代码中注释部分含有中文汉字，导致的。

\libgo\common\util.h: warning C4819: The file contains a character that cannot be represented in the current code page (936)
libgo\common\util.h(28): error C2061: syntax error: identifier 'RefObject'

解决方式
在cmake编译命令指定UTF-8，参考如下：

-D CMAKE_CXX_FLAGS="/utf-8"

CLion 默认使用 UTF-8 编码，MSVC 继承了 MS 家族的一贯传统，除非明确指定否则要么 UTF-8 with BOM 要么当前代码页。解决办法也简单，加上命令行开关就行了： \utf-8

或者CMakeLists.txt增加以下内容：

if(MSVC)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /utf-8")
endif()

还有个可能出现的编译报错问题是，从git拉取下来的代码直接编译可能出现的。需要配置下：

git config --global core.autocrlf true

未做git config --global core.autocrlf true 设置时，checkout出来的代码行尾是LR，而在windows下，有效的换行符是CRLF。

还有个编译报错：

libgo.lib(processer.cpp.obj) : error LNK2019: unresolved external symbol __imp__WSASetLastError@4

原因是需要链接 ws2_32.lib。代码中加入 #pragma comment(lib, "ws2_32.lib")

或者CMakeLists.txt文件中增加 link_libraries(ws2_32),需要注意的是，必须在add_executable之前添加才行。如：

link_libraries(ws2_32)
add_executable(${PROJECT_NAME} ${SRC_FILES} )

最后附上我的CMakeLists.txt配置：

cmake_minimum_required(VERSION 3.12)
project(untitled VERSION 0.0.1)

set(CMAKE_CXX_STANDARD 11)

set(BUILD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/build)
set(STATIC_LIB_DIR ${CMAKE_CURRENT_SOURCE_DIR}/lib)

set(SRC_PATH
        ${CMAKE_CURRENT_SOURCE_DIR}/src
        )

include_directories(
        ${SRC_PATH}
        ${CMAKE_CURRENT_SOURCE_DIR}/include
)

add_definitions(

)
if(MSVC)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /utf-8")
endif()

####################  scan source files ####################
foreach (path ${SRC_PATH})
    aux_source_directory(${path} SRC_FILES)
endforeach ()

link_libraries(ws2_32)

add_executable(${PROJECT_NAME} ${SRC_FILES} )

set(LIBGO_LIB ${STATIC_LIB_DIR}/libgo.lib)

target_link_libraries(${PROJECT_NAME} PRIVATE ${LIBGO_LIB} )

#find_package(libgo CONFIG REQUIRED)
#target_link_libraries(${PROJECT_NAME} PRIVATE libgo::libgo)