协程 与 greenlet

1. 协程

子程序，或者称为函数，在所有语言中都是层级调用，比如A调用B，B在执行过程中又调用了C，C执行完毕返回，B执行完毕返回，最后是A执行完毕。所以子程序调用是通过栈实现的，一个线程就是执行一个子程序。子程序调用总是一个入口，一次返回，调用顺序是明确的。而协程的调用和子程序不同。

协程看上去也是子程序，但执行过程中，在子程序内部可中断，然后转而执行别的子程序，在适当的时候再返回来接着执行。协程的这个过程是时机可控的。

注意，在一个子程序中中断，去执行其他子程序，不是函数调用，有点类似CPU的中断。

协程的特点在于是一个线程执行，那和多线程比，协程有何优势？

• 最大的优势就是协程极高的执行效率。因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。

• 第二大优势就是不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。

• 因为协程是一个线程执行，那怎么利用多核CPU呢？最简单的方法是多进程+协程，既充分利用多核，又充分发挥协程的高效率，可获得极高的性能。

Python对协程的支持是通过generator实现的。

在generator中，我们不但可以通过for循环来迭代，还可以不断调用next() 函数获取由 yield 语句返回的下一个值。 但是Python的yield不但可以返回一个值，它还可以接收调用者发出的参数。

传统的生产者-消费者模型是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，但一不小心就可能死锁。

如果改用协程，生产者生产消息后，直接通过yield跳转到消费者开始执行，待消费者执行完毕后，切换回生产者继续生产，效率极高：

def consumer():

    r = ''
    while True:
        n = yield r
        if not n:
            return
        print('[CONSUMER] Consuming %s...' % n)
        r = '200 OK'

def produce(c):
    c.send(None)
    n = 0
    while n < 5:
        n = n + 1
        print('[PRODUCER] Producing %s...' % n)
        r = c.send(n)
        print('[PRODUCER] Consumer return: %s' % r)
    c.close()

c = consumer()
produce(c)

执行结果：

[PRODUCER] Producing 1...

[CONSUMER] Consuming 1...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 2...
[CONSUMER] Consuming 2...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 3...
[CONSUMER] Consuming 3...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 4...
[CONSUMER] Consuming 4...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 5...
[CONSUMER] Consuming 5...
[PRODUCER] Consumer return: 200 OK

注意到consumer函数是一个generator，把一个consumer传入produce后：

• 首先调用c.send(None)启动生成器；

• 然后，一旦生产了东西，通过c.send(n)切换到consumer执行；

• consumer通过yield拿到消息，处理，又通过yield把结果传回；

• produce拿到consumer处理的结果，继续生产下一条消息；

• produce决定不生产了，通过c.close()关闭consumer，整个过程结束。

整个流程无锁，由一个线程执行，produce和consumer协作完成任务，所以称为“协程”，而非线程的抢占式多任务。

2. greenlet

generator 实现的协程在 yield value 时只能将 value 返回给调用者(caller)。 而在greenlet中，target.switch（value）可以切换到指定的协程（target）， 然后yield value。greenlet用switch来表示协程的切换，从一个协程切换到另一个协程需要显式指定。

from greenlet import greenlet
def test1():
    print 12
    gr2.switch()
    print 34

def test2():
    print 56
    gr1.switch()
    print 78

gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()

输出为：

12 56 34

当创建一个greenlet时，首先初始化一个空的栈， switch到这个栈的时候，会运行在greenlet构造时传入的函数（首先在test1中打印 12）， 如果在这个函数（test1）中switch到其他协程（到了test2 打印34），那么该协程会被挂起，等到切换回来（在test2中切换回来 打印34）。当这个协程对应函数执行完毕，那么这个协程就变成dead状态。

greenlet module与class

我们首先看一下greenlet这个module里面的属性

　　>>> dir(greenlet)
　　['GREENLET_USE_GC', 'GREENLET_USE_TRACING', 'GreenletExit', '_C_API', '__doc__', '__file__', '__name__', '__package__', '__version__', 'error', 'getcurrent', 'gettrace', 'greenlet', 'settrace']
　　>>>

其中，比较重要的是getcurrent()， 类greenlet、异常类GreenletExit。

getcurrent()返回当前的greenlet实例；

GreenletExit：是一个特殊的异常，当触发了这个异常的时候，即使不处理，也不会抛到其parent（后面会提到协程中对返回值或者异常的处理）

然后我们再来看看greenlet.greenlet这个类：

　　>>> dir(greenlet.greenlet)

　　['GreenletExit', '__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__getstate__', '__hash__', '__init__', '__new__', '__nonzero__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', 　　'__sizeof__', '__str__', '__subclasshook__', '_stack_saved', 'dead', 'error', 'getcurrent', 'gettrace', 'gr_frame', 'parent', 'run', 'settrace','switch', 'throw']
　　>>> 

比较重要的几个属性：

run：当greenlet switch 的时候会调用到这个callable，如果我们需要继承greenlet.greenlet时，可重写该方法。该方法等价于上面例子中的 test1

switch：在greenlet之间切换

parent：可读写属性。当前协程的父协程，如果是主协程，其父协程为 None。

dead：如果greenlet执行结束，那么该属性为true

throw：切换到指定greenlet后立即跑出异常

Switch not call

对于greenlet，最常用的写法是 x = gr.switch(y)。 这句话的意思是切换到gr，传入参数y。当从其他协程（不一定是这个gr）切换回来的时候，将值付给x。

import greenlet
def test1(x, y):
    z = gr2.switch(x+y)
    print('test1 ', z)

def test2(u):
    print('test2 ', u)
    gr1.switch(10)

gr1 = greenlet.greenlet(test1)
gr2 = greenlet.greenlet(test2)
print gr1.switch("hello", " world")

输出：

　　　　('test2 ', 'hello world')
　　　　('test1 ', 10)
　　　　None

每一个Greenlet都有一个parent，一个新的greenlet在哪里创建，默认当前环境的greenlet就是这个新greenlet的parent。所有的greenlet构成一棵树，其根节点就是还没有手动创建greenlet时候的”main” greenlet（事实上，在首次import greenlet的时候实例化）。
当一个协程正常结束，执行流程回到其对应的 parent ；或者在一个协程中抛出未被捕获的异常，该异常也是传递到其parent。学习python的时候，有一句话会被无数次重复”everything is oblect”, 在学习greenlet的调用中，同样有一句话应该深刻理解， “switch not call”。

import greenlet
def test1(x, y):
    print id(greenlet.getcurrent()), id(greenlet.getcurrent().parent) # 40240272 40239952
    z = gr2.switch(x+y)
    print 'back z', z

def test2(u):
    print id(greenlet.getcurrent()), id(greenlet.getcurrent().parent) # 40240352 40239952
    return 'hehe'

gr1 = greenlet.greenlet(test1)
gr2 = greenlet.greenlet(test2)
print id(greenlet.getcurrent()), id(gr1), id(gr2) # 40239952, 40240272, 40240352
print gr1.switch("hello", " world"), 'back to main' # hehe back to main

上述例子可以看到，尽量是从test1所在的协程gr1 切换到了gr2，但gr2的parent还是’main’ greenlet，因为默认的parent取决于greenlet的创建环境。另外 在 test2 中 return 之后返回到了其parent，而不是switch到该协程的地方（即不是test1），这个跟我们平时的函数调用不一样，也就是 “switch not call”。对于异常也是展开至 parent

greenlet 生命周期

上面例子中的gr1其实并没有正常结束，我们可以借用greenlet.dead这个属性来查看

import greenlet
def test1():
    z = gr2.switch() 

def test2():
    return 'hehe'

gr1 = greenlet.greenlet(test1)
gr2 = greenlet.greenlet(test2)
print 'gr1 is dead?: %s, gr2 is dead?: %s' % (gr1.dead, gr2.dead)
gr1.switch()
print 'gr1 is dead?: %s, gr2 is dead?: %s' % (gr1.dead, gr2.dead)
gr1.switch()
print 'gr1 is dead?: %s, gr2 is dead?: %s' % (gr1.dead, gr2.dead)

输出：

gr1 is dead?: False, gr2 is dead?: False
gr1 is dead?: False, gr2 is dead?: True
gr1 is dead?: True, gr2 is dead?: True

上述例子中 test1 函数，在切到 gr2 协程后，gr1 将立即挂起，所以后续如果不再激活 gr1，gr1将一直处于挂起状态。

• 只有当协程对应的函数执行完毕，协程才会die
• 如果试图再次switch到一个已经是dead状态的greenlet会怎么样呢，事实上会切换到其parent greenlet。

参考:
[1]. https://www.liaoxuefeng.com/wiki/1016959663602400/1017968846697824
[2]. https://www.cnblogs.com/xybaby/p/6337944.html