翻译自官方文档greenlet。

什么是greenlet

greenlet是从Stackless中分离的项目。greenlet也叫微线程、协程，它的调度是由程序明确控制的，所以执行流程是固定的、明确的。而线程的调度完全交由操作系统，执行顺序无法预料。同时，协程之间切换的代价远比线程小。

greenlet是通过C扩展实现的。

示例

有这么一个系统，它根据用户在终端输入命令的不同而执行不同的操作，假设输入是逐字符的。部分代码可能是这样的：

def process_commands(*args):
    while True:
        line = ''
        while not line.endswith('\n'):
            line += read_next_char()
        if line == 'quit\n':
            print "are you sure?"
            if read_next_char() != 'y':
                continue    # 忽略当前的quit命令
        process_command(line)

现在我们想把这个程序在GUI中实现。然而大多数GUI库都是事件驱动的，每当用户输入都会调用一个回调函数去处理。在这种情况下，如果还想用上面的代码逻辑，可能是这样的：

def event_keydown(key):
    ??

def read_next_char():
    ?? # 必须等待下一个event_keydown调用

read_next_char要阻塞等待event_keydown调用，然后就会和事件循环相冲突。这种需要并发的情况是可以用多线程来处理，但是我们有更好的方法，就是greenlet。

def event_keydown(key):
         # 跳到g_processor，将key发送过去
    g_processor.switch(key)

def read_next_char():
        # 在这个例子中，g_self就是g_processor
    g_self = greenlet.getcurrent()
        # 跳到父greenlet，等待下一个Key
    next_char = g_self.parent.switch()
    return next_char

g_processor = greenlet(process_commands)
g_processor.switch(*args)

gui.mainloop()

我们先用process_commands创建一个协程，然后调用switch切换到process_commands中去执行，并输入参数args。在process_commands中运行到read_next_char，又切换到主协程，执行gui.mainloop()，在事件循环中等待键盘按下的动作。当按下某个键之后，调用event_keydown，切换到g_processor，并将key传过去。read_next_char恢复运行，接收到key，然后返回给process_commands，处理完之后又暂停在read_next_char等待下一次按键。

下面我们来详细讲解greenlet的用法。

用法

简介

一个协程是一个独立的“假线程”。可以把它想成一个小的帧栈，栈底是你调用的初始函数，栈顶是greenlet当前暂停的地方。我们使用协程，实际上就是创建了一系列这样帧栈，然后在它们之间跳转执行。而跳转必须是明确的，跳转也称为'switching'。

当你创建一个协程时，产生一个空的栈，在第一次切换到这个协程时，它调用一个特殊的函数，这个函数中可以调用其他函数，可以切换到其他协程等等。当最终栈底函数执行完后，协程的栈变为空，这时候，协程是死的(dead)。协程也可能由于异常而死亡。

下面是个非常简单的例子：

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()

最后一行切换到test1，打印12，切换到test2，打印56，又切回到test1打印34。然后test1结束，gr1死亡。这时候执行回到了gr1.switch()调用。注意到，78并没有被打印出。

父协程

每个协程都有一个父协程。协程在哪个协程中被创建，那么这个协程就是父协程，当然后面可以更改。当某个协程死亡后，会在父协程中继续执行。举个例子，在g1中创建了g2，那么g1就是g2的父协程，g2死亡后，会在g1中继续执行。这么说的话，协程是树结构的。最上层的代码不是运行在用户定义的协程中，而是在一个隐式的主协程中，它是协程树的根(root)。

在上面的例子中，gr1和gr2的父协程都是主协程。不管哪一个死亡，执行都会回到主协程。

异常也会被传到父协程。比如说，test2中若包含了一个'typo'，就会引发NameError异常，然后杀死gr2，执行会直接回到主协程。Traceback会显示test2而不是test1。注意，协程的切换不是调用，而是在平行的"栈容器"中传递执行。

协程类

greenlet.greenlet就是协程类，它支持下面一些操作：

greenlet(run=None, parent=None)

创建一个新的协程对象。run是一个可调用对象，parent是父协程，默认是当前协程。

greenlet.getcurrent()

返回当前协程，也就是调用这个函数的协程。

greenlet.GreenletExit

这个特殊的异常不会传给父协程，常用来杀死协程。

greenlet是可以被继承的。协程通过执行run属性来运行。在子类中，可以自由地去定义run，而不是一定要传递run参数给构造器。

切换

有两种情况会发生协程之间的切换。一是某个协程主动调用switch方法，这种情况下会切换到被调用的协程中。二是协程死亡，这时协程会切换到父协程。在切换时，一个对象或异常被传递到目标协程。这用来在协程之间传递信息。如下面这个例子：

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

def test2(u):
    print u
    gr1.switch(42)

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

这个代码会打印"hello world"和42。注意到，test1和test2在协程创建时并没有提供参数，而是在第一次切换的地方。

g.switch(*args, **kwargs)

切换到协程g执行，传递提供的参数。如果g还没运行，那么传递参数给g的run属性，并开始执行run()。

如果协程的run()执行结束，return的值会返回给主协程。如果run()以异常方式结束，异常会传递给主协程(除非是greenlet.GreenletExit，这种情况下会直接返回到主协程)。

如果切换到一个已死亡的的协程，那么实际上是切换到它的父协程，依次类推。

协程的方法和属性

g.switch(*args, **kwargs)

切换到协程g执行，见上面。

g.run

一个可调用对象，当g开始执行时，调用它。但是一旦开始执行后，这个属性就不存在了。

g.parent

父协程，这个值是可以改变的，但是不允许创建循环的父进程。

g.gr_frame

当前最顶层的帧，或者是None。

g.dead

如果协程已死亡，那么值是True。

bool(g)

如果协程处于活跃状态，则为True。如果已死亡或者未开始执行则为False。

g.throw([typ, [val, [tb]]])

切换到g执行，但是立刻引发异常。如果没有参数，则默认引发greenlet.GreenletExit异常。这个方法的执行类似于：

def raiser():
    raise typ, val, tb
g_raiser = greenlet(raiser, parent=g)
g_raiser.switch()

当然greenlet.GreenletExit除外。

协程和Python线程

协程可以和线程组合使用。每个线程包含一个独立的主协程和协程树。当然不同线程的协程之间是无法切换执行的。

垃圾收集

如果对一个协程的引用计数为0，那么就没办法再次切换到这个协程。这种情况下，协程会产生一个GreenletExit异常。这是协程唯一一种异步接收到GreenletExit异常的情况。可以用try...finally...来清除协程的资源。这个特性允许我们用无限循环的方式来等待数据并处理，因为当协程的引用计数变成0时，循环会自动中断。

在无限循环中，如果想要协程死亡就捕获GreenletExit异常。如果想拥有一个新的引用就忽略GreenletExit。

greenlet不参与垃圾收集，目前协程帧的循环引用数据不会被检测到。循环地将引用存到其他协程会导致内存泄漏。

追踪支持

当我们使用协程的时候，标准的Python追踪和性能分析无能为力，因为协程的切换时在单个线程中。很难通过简单的方法来侦测到协程的切换，所以为了提高对调试的支持，增加了下面几个新的函数：

greenlet.gettrace()

返回之前的追踪函数设置，或者None。

greenlet.settrace(callback)

设置一个新的追踪函数，返回之前的，或者None。这个函数类似于sys.settrace()各种事件发生的时候都会调用callback，并且callback是下面这样的：

def callback(event, args):
    if event == 'switch':
        origin, target = args
        # 处理从origin到target的切换
        # 注意callback在target的上下文中执行
        return
    if event == 'throw':
        origin, target = args
        # 处理从origin到target的抛出
        # 注意callback在target的上下文中执行
        return

那么下次编写并发程序的时候，是不是该考虑一下协程呢？