Coroutine

python 的 yield 是一个 generator.

def get_next():
    i = 0;
    while (true):
        yield i
        i++

for i in get_next():
    print(i)
    # 输出 012345...

实际上 get_next() 返回了一个 generator, 上面的代码类似于:

gen = get_next();
while a = gen.resume():
    print(a)

generator yield 会把控制交回给调用都, 并通过一定方式保存了当前的上下文 (局部变量, 指令记数), 下一次 resume 时, 会恢复保存的上下文并直接从上次 yield 的地方开始执行

在实现上, 根据保存上下文的方式, 有两种方式来实现 generator:

1. stackful

   每次 yield 时直接保存了当前的栈, resume 时恢复保存的栈. 这种方式比较简单直观, 但代价较大, 常用的手段有 setjump/longjump 和 makecontext/swapcontext

2. stackless

   使用一个单独的对象来维护相关局部变量和状态, 例如:

   class GetNext(object):
       def __init__(self):
           self.i = 0
   
       def resume():
           while (true):
               if self.yield_point == YIELD1:
                   ...
                   self.yield_point = YIELD2;
                   return ...
               if self.yield_point == YIELD2:
                   ...
                   self.yield_point = ...
                   return ...
               ...
   

   stackless 的 generator 需要根据 generator 的代码生成相应的对象和代码, 但开销较小.

不考虑实现细节, generator 在用法上和 iterator 类似, 例如 Rust Iterator

generator 通常只有被调用者是 generator, 需要有 resume 的能力. 对于 coroutine 来说, 任何一方都可以 resume, 例如:

__coroutine__ def ping():
    yield_to pong

__coroutine__ def pong():
    yield_to ping

实现上, 可以通过 generator 加 dispatcher 的方式来实现 coroutine

def dispatcher(entry):
    while (true):
      entry = entry.resume();

def ping():
    yield_to pong

def pong():
    yield_to ping

dispatcher(ping)

与 generator 类似, async/await 也可以看作是 coroutine 的特殊形式.

async fn hello() -> () {
    world().await;
}

async fn world() -> () {
    println!("world");
}

fn main() -> () {
    block_on(hello());
}

await 把控制交给 async, async 返回时会把控制交还给 await: await 处相当于一个隐式的 callback

coroutine 的用途等同于如下的问题:

Q: 单核系统上使用多线程有什么用处?

A: 实现并发, 由 kernel 安排多个任务并发执行, 但并非并行执行.

coroutine 与单核上的多线程类似, 可以用来实现单线程的并发, 因为各个函数可以随意的转移控制并 resume.

单核多线程与 coroutine 有类似的对应关系: