C++20 终于加入了协程（Coroutines ）。协程是一种轻量级的用户态线程，线程的创建、切换、销毁等都不需要进出内核态，从而带来巨大的性能提升，特别是当线程数量巨大的时候。

下面从传统的C语言的 pthread 开始，到 C++11 的 thread 类，到 C++20 的协程，通过一个简单的加法的例子，比较一下协程和普通线程之间的异同。

Pthread 线程的例子

Pthread 线程的使用，通过 pthread_create() 来进行创建，通过 pthread_join() 来等待线程结束。线程之间可以通过创建线程的参数来共享一些变量，通过 mutex 和 condition value 来进行互斥和通知。

下面通过一个例子来说明Pthread线程的使用，四个整数，先通过两个线程进行两两求和，然后再由第三个线程对求和的结果再求和，最终得到四个整数之和。

#include <iostream>
#include <pthread.h>
#include <chrono>
using std::cout, std::endl;

// <1> 用来计算当前时间和指定开始时间的时间差，浮点数，单位秒
double time_diff( std::chrono::time_point< std::chrono::high_resolution_clock > * start )
{
    return static_cast< std::chrono::duration<double> >( std::chrono::high_resolution_clock::now() - *start ).count();
}

// <2> 线程参数，包括求和相关信息，线程通信用的条件变量，以及起始时间
struct add_args
{
    volatile int * p1;
    volatile int * p2;
    volatile int * ret;
    pthread_mutex_t * mutex;
    pthread_cond_t * cond;
    std::chrono::time_point< std::chrono::high_resolution_clock > * start;
};

// <3> 线程函数，首先等待被加数准备好（简单以非0为准备好），然后执行加法，通知结果就绪
void * th_add( void * args )
{
    struct add_args * aa = static_cast<struct add_args *>( args );
    pthread_mutex_lock( aa->mutex );
    while( *aa->p1 == 0 || *aa->p2 == 0 ) {
        pthread_cond_wait( aa->cond, aa->mutex );
    }
    *aa->ret = *aa->p1 + *aa->p2;
    cout << time_diff( aa->start ) << " sum is " << *aa->ret << endl;
    pthread_mutex_unlock( aa->mutex );
    pthread_cond_broadcast( aa->cond );
    return static_cast<void *>( 0 );
}

int main( int argc, char * argv[] )
{
    int sum[7] = { 0 };
    auto start = std::chrono::high_resolution_clock::now();
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
    struct add_args aa1, aa2, aa3;
    aa1 = { sum + 0, sum + 1, sum + 4, &mutex, &cond, &start };
    aa2 = { sum + 2, sum + 3, sum + 5, &mutex, &cond, &start };
    aa3 = { sum + 4, sum + 5, sum + 6, &mutex, &cond, &start };
    
    // <4> 启动线程，此时被加数还未准备好，线程都在等待
    pthread_t t1, t2, t3;
    pthread_create( &t1, NULL, th_add, &aa1 );
    pthread_create( &t2, NULL, th_add, &aa2 );
    pthread_create( &t3, NULL, th_add, &aa3 );
  
    // <5> 准备被加数，通知线程工作
    pthread_mutex_lock( &mutex );
    sum[0] = 1, sum[1] = 2; sum[2] = 3;
    pthread_cond_broadcast( &cond );
    pthread_mutex_unlock( &mutex );
    cout << time_diff( &start ) << " broadcast (1) " << endl;
    pthread_yield();
    pthread_mutex_lock( &mutex );
    sum[3] = 4;
    pthread_cond_broadcast( &cond );
    pthread_mutex_unlock( &mutex );
    cout << time_diff( &start ) << " broadcast (2) " << endl;

    // <6> 等待线程结束，获取线程执行结果，
    void * ret = NULL;
    pthread_join( t1, &ret );
    pthread_join( t2, &ret );
    pthread_join( t3, &ret );
    cout << time_diff( &start ) << " final " << sum[4] << " " << sum[5] << " " << sum[6] << endl;
    pthread_mutex_destroy( &mutex );
    pthread_cond_destroy( &cond );
    return 0;
}

编译和运行结果为：

[smlc@test code]$ g++ -std=c++20 a15.cpp -lpthread
[smlc@test code]$ ./a.out
0.000127409 broadcast (1) 
0.000454453 sum is 3
0.000562961 broadcast (2) 
0.000610694 sum is 7
0.000679388 sum is 10
0.000708396 final 3 7 10

C++11 的 thread 类的线程例子

C++11 的 thread 类，除了可以使用 mutex 和 condition value 进行线程通信外，也封装了 promise 类和 future 类，进行更简单的线程间通信。

#include <iostream>
#include <thread>
#include <future>
#include <utility>
#include <chrono>
using std::cout, std::endl;

// <1> 用来计算当前时间和指定开始时间的时间差，浮点数，单位秒
double time_diff( std::chrono::time_point< std::chrono::high_resolution_clock > * start )
{
    return static_cast< std::chrono::duration<double> >( std::chrono::high_resolution_clock::now() - *start ).count();
}

// <2> 线程函数，可以是任意参数类型
void th_add( std::promise<int> && sum, std::future<int> p1, std::future<int> p2,
        std::chrono::time_point< std::chrono::high_resolution_clock > * start )
{
    int ret = p1.get() + p2.get();
    sum.set_value( ret );
    cout << time_diff( start ) << " sum is " << ret << endl;
    return;
}

// <3> 函数对象也可以作为线程函数，重载 operator () 运算符，同样支持任意参数类型
struct th_add_2
{
    std::chrono::time_point< std::chrono::high_resolution_clock > * m_start;
  
    void operator () ( std::promise<int> && sum, std::future<int> p1, std::future<int> p2 )
    {
        int ret = p1.get() + p2.get();
        sum.set_value( ret );
        cout << time_diff( m_start ) << " sum is " << ret << endl;
        return;
    }
};

int main( int argc, char * argv[] )
{
    auto start = std::chrono::high_resolution_clock::now();
    std::promise<int> sum[7];
    std::future<int> ret6 = sum[6].get_future();
  
    // <4> 启动线程，此时被加数还未准备好，线程都在等待
    std::thread t1( th_add, std::move( sum[6] ), sum[5].get_future(), sum[4].get_future(), &start );
    std::thread t2( th_add_2 { &start }, std::move( sum[5] ), sum[3].get_future(), sum[2].get_future() );
    std::thread t3( th_add, std::move( sum[4] ), sum[1].get_future(), sum[0].get_future(), &start );

    // <5> 准备被加数，通知线程工作
    sum[0].set_value( 1 );
    sum[1].set_value( 2 );
    sum[2].set_value( 3 );
    cout << time_diff( &start ) << " broadcast (1) " << endl;
    std::this_thread::yield();
    sum[3].set_value( 4 );
    cout << time_diff( &start ) << " broadcast (2) " << endl;

    // <6> 等待线程结束，获取线程执行结果，
    t1.join();
    t2.join();
    t3.join();
    cout << time_diff( &start ) << " final " << ret6.get() << endl;
    return 0;
}

编译和运行结果为：

[smlc@test code]$ g++ -std=c++20 a15-2.cpp
[smlc@test code]$ ./a.out
0.000179768 broadcast (1) 
0.000511978 sum is 3
0.000619311 broadcast (2) 
0.000675313 sum is 7
0.000761572 sum is 10
0.000815648 final 10

协程（Coroutines）的基础

首先，协程是用户态的线程，没有对应的底层操作系统的线程，也就是说，连续启动的多个协程实际是在同一个底层操作系统的线程中运行，这些协程是串行执行的。当然了，可以在不同的底层操作系统线程中分别启动协程，甚至可以在协程暂停后，迁移到另一个底层操作系统线程中再恢复运行。

其次，底层操作系统的线程是由操作系统进行调度的，可以是进入内核态之后由内核进行调度切换，也可以是因为时间片到期后由操作系统通过中断技术强行进行调度切换。而协程则是在用户态进行切换，需要在用户态，由协程内部显式要求暂停，以及由外部显式将指定协程恢复运行。

因此 C++ 的协程的函数和普通的函数调用有差别：

• 协程的函数和普通函数调用的主要差别，是协程函数内部必须有 co_await 、 co_yield 、 co_return 等关键字的一个或多个。
• 一个函数因为上述关键字成为协程之后，就不能再 return 语句，也不能有可变参数。另外常量函数、构造函数、析构函数、 main 函数等也不能定义成协程。
• 普通函数调用一次只会返回一个结果，但协程调用一次，在执行过程中，可以多次暂停然后按需恢复执行，每次暂停都可以产生一个结果。所以生成器（generator）式协程可以源源不断的通过 co_yield 来产生数据。

协程为了实现在用户态控制的暂停和恢复执行，需要保存执行状态，同时还需要和外部交换是数据，因此定义了一系列的对象和接口，假设协程定义如下：

R coroutine_func( Args ... ) 
{
    // ... coroutine body ...
    co_await XXXX;  // or : co_yield xxxx;  // or : co_return xxxx;
    // ... other coroutine body ...
}

首先是 Promise 类型，负责和外界进行数据交换，定义为：coroutine_traits< R, Args ... >::promise_type，如果未进行模板特化，默认为：R::promise_type，因此在定义协程的返回值类型时，要么在返回值类型（例如 R）里面定义 promise_type 类型，要么给进行模板 coroutine_traits< R, Args ... > 的特化，里面定义相应的 promise_type 类型。

这个 promise_type 类型要提供下列函数：

• auto initial_suspend() ：初始化时的协程挂起
• auto final_suspend()：结束时的协程挂起
• R get_return_object()：获取返回结果对象，每次挂起时调用，返回结果给外部
• auto yield_value()：用于 co_yield 设置结果对象的值，供后续挂起时返回结果使用
• auto return_value()：用于 co_return 设置结果对象的值，供后续挂起时返回结果使用

然后是 awaitable 接口，用于 co_await 表达式， 用来控制是否挂起，以及在挂起和恢复时执行额外操作。这个 awaitable 接口类型，这个不是接口类，而是定义了一些接口函数的要求，需要提供下列函数：

• bool await_ready()：判断是否可以运行，返回false表示需要挂起
• auto await_suspend(coroutine_handle<> h)：需要挂起时执行此函数，其中 handle 是协程体的控制句柄，在后面描述
• void await_resume()：从挂起中恢复时执行此函数

标准系统库中定义了两个缺省的 awaitable 接口的实现供使用：

• struct suspend_never ：从不挂起，他的 await_ready() 返回 true
• struct suspend_always ：总是挂起，他的 await_ready() 返回 false

最后是协程的控制句柄类 coroutine_handle< promise_type >，用于获取协程信息和控制协程的运行，例如恢复执行等。当协程需要挂起时，在 await_suspend() 函数中的参数会提供当前协程的控制句柄，供后续进行控制。控制句柄类提供下列接口：

• resume() 或者 operator () () ：用于恢复协程运行
• Promise & promise() ：用于获取协程对应的 Promise 对象

上述这些类型之间以及和协程关系，大致如下图所示：

这些类型中， promise_type 一般是需要自行定义的，因为这个是和协程的返回值相关，如果不使用协程的返回值（例如通过协程函数的参数来返回信息），也可以考虑使用标准库中定义的 std::noop_coroutine_promise 类型，awaitable 接口在需要对协程的挂起和恢复进行额外控制时，可以自行定义，否则也可以直接使用标准库中定义的 std::suspend_never 和 std::suspend_always 类型。而 coroutine_handle< promise_type > 则是标准库中已有定义，不需要额外定义。

协程的例子

C++20 的协程功能很强大很灵活，提供了很多可以定制的地方，但从另一个角度来看，也使得 C++20 的使用过于复杂，而且选择太多，同时没有推荐的实现方式，也容易写出各种古怪的代码。

除了实现单个协程本身的功能外，还需要实现多个协程之间的调度，这个调度还需要和协程本身配合实现，这样进一步增加了协程的复杂度，因此一个简单的协程程序，也需要很多代码来实现。

这里的例子不使用协程的返回值以及promise类型，只使用协程的参数，通过awaitable接口来进行协程的调度。

#include <iostream>
#include <chrono>
#include <coroutine>
#include <unistd.h>
using std::cout, std::endl;
        
// <1> 用来计算当前时间和指定开始时间的时间差，浮点数，单位秒
double time_diff( std::chrono::time_point< std::chrono::high_resolution_clock > * start )
{       
    return static_cast< std::chrono::duration<double> >( std::chrono::high_resolution_clock::now() - *start ).count();
}   
 
// <2> 协程参数，包括求和相关信息，以及起始时间，以及协程句柄（进行调度使用），
//         同时也是 awaitable 接口对象，可以用于 co_await 调用
struct add_args
{       
    int * p1;
    int * p2;
    int * ret;
    std::chrono::time_point< std::chrono::high_resolution_clock > * start;
    std::coroutine_handle<> hc;

    // <3> 总是要求挂起
    bool await_ready() { return false; }
    // <4> 挂起时，保存协程句柄，供后续调度使用
    void await_suspend( std::coroutine_handle<> h ) { hc = h; return;  }   
    // <5> 协程恢复运行时，清理协程句柄，避免后续再次调度
    void await_resume() { hc = nullptr;  return;  }
};  
       
// <6> 协程返回参数，主要是定义 promise_type ，虽然业务逻辑不需要用到，但协程框架需要
struct add_coro
{   
    struct promise_type
    {
        struct add_coro get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };  
};      

// <7> 协程函数运行体，里面有 co_await 和 co_return 表明这是协程，因此不能有 return 语句
struct add_coro th_add( struct add_args * args )
{   
    // <8> co_await 需要直接访问变量，如果写成 co_await *args; 会产生临时变量
    struct add_args & args_ref = *args;
    while( *args->p1 == 0 || *args->p2 == 0 ) {
        co_await args_ref;
    }
    *args->ret = *args->p1 + *args->p2; 
    cout << time_diff( args->start ) << " sum is " << *args->ret << endl;
    co_return;
}

// <9> 简单的协程调度程序，全部协程如果处于挂起的，都重新调度一下。
void schedule_add( int n, struct add_args * aa )
{
    for( int i = 0; i < n; ++i ) {
        if( aa[i].hc ) {
            aa[i].hc.resume();
        }
    }
    return;
}

int main( int argc, char * argv[] )
{
    auto start = std::chrono::high_resolution_clock::now();
    int sum[7] = { 0 };
    struct add_args aa[] = {
        { sum + 0, sum + 1, sum + 4, &start },
        { sum + 2, sum + 3, sum + 5, &start },
        { sum + 4, sum + 5, sum + 6, &start } };
    
    // <10> 启动协程，此时被加数还未准备好，协程都在挂起
    th_add( &aa[0] );
    th_add( &aa[1] );
    th_add( &aa[2] );

     // <11> 准备被加数，尝试调度协程工作
    sum[0] = 1, sum[1] = 2; sum[2] = 3;
    cout << time_diff( &start ) << " broadcast (1) " << endl;
    schedule_add( 3, aa );
    sum[3] = 4;
    cout << time_diff( &start ) << " broadcast (2) " << endl;
    schedule_add( 3, aa );

     // <6> 等待协程结束，获取协程执行结果，
    while( sum[6] == 0 ) {
        schedule_add( 3, aa );
        sleep( 1 );
    }
    cout << time_diff( &start ) << " final " << sum[4] << " " << sum[5] << " " << sum[6] << endl;
    return 0;
}

编译和执行结果为：

[smlc@test code]$ g++ -std=c++20 a15-3.cpp -fcoroutines -lpthread
[smlc@test code]$ ./a.out
1.771e-06 broadcast (1) 
0.000179137 sum is 3
0.000194825 broadcast (2) 
0.000198804 sum is 7
0.000202648 sum is 10
0.000206225 final 3 7 10

从时间上也可以看到，由于不需要进入内核态，不需要创建底层操作系统线程，所以执行花费的时间少很多。

【往期回顾】

C++20 新特性（14）：lambda初始化捕捉支持参数包

C++20 新特性（13）：无状态lambda可以构建和赋值