Python 实现协程

协程的概念

　　协程，又称微线程，纤程。英文名Coroutine。一句话说明什么是线程：协程是一种用户态的轻量级线程。（其实并没有说明白~）

我觉得单说协程，比较抽象，如果对线程有一定了解的话，应该就比较好理解了。

那么这么来理解协程比较容易：

　　线程是系统级别的，它们是由操作系统调度；协程是程序级别的，由程序员根据需要自己调度。我们把一个线程中的一个个函数叫做子程序，那么子程序在执行过程中可以中断去执行别的子程序；别的子程序也可以中断回来继续执行之前的子程序，这就是协程。也就是说同一线程下的一段代码<1>执行着执行着就可以中断，然后跳去执行另一段代码，当再次回来执行代码块<1>的时候，接着从之前中断的地方开始执行。

比较专业的理解是：

　　协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态，换种说法：进入上一次离开时所处逻辑流的位置。

---

yield实现协程

子程序（函数）在执行过程中可以中断去执行别的子程序；别的子程序也可以中断回来继续执行之前的子程序”，那么很容易想到Python的yield，显然yield是可以实现这种切换的。

使用yield实现协程操作例子：

#coding=utf-
#! /usr/bin/env python
# -*- coding:utf- -*-
# Author: "Zing-p"
# Date: //

def consumer(name):
    print("[%s] 要开始啃骨头了..." % (name))
    while True:
        bone = yield
        print("[%s] 正在啃骨头 %s" % (name, bone))

def producer(obj1, obj2):
    obj1.send(None)    # 启动obj1这个生成器,第一次必须用None  <==> obj1.__next__()
    obj2.send(None)    # 启动obj2这个生成器,第一次必须用None  <==> obj2.__next__()
    n =
    while n < :
        n +=
        print("[producer] 正在生产骨头 %s" % n)
        obj1.send(n)
        obj2.send(n)

if __name__ == '__main__':
    con1 = consumer("消费者A")
    con2 = consumer("消费者B")
    producer(con1, con2)

输出：

[消费者A] 要开始啃骨头了...
[消费者B] 要开始啃骨头了...
[producer] 正在生产骨头
[消费者A] 正在啃骨头
[消费者B] 正在啃骨头
[producer] 正在生产骨头
[消费者A] 正在啃骨头
[消费者B] 正在啃骨头
[producer] 正在生产骨头
[消费者A] 正在啃骨头
[消费者B] 正在啃骨头
[producer] 正在生产骨头
[消费者A] 正在啃骨头
[消费者B] 正在啃骨头
[producer] 正在生产骨头
[消费者A] 正在啃骨头
[消费者B] 正在啃骨头 

greenlet实现协程

Python的 greenlet就相当于手动切换，去执行别的子程序，在“别的子程序”中又主动切换回来。。。

#! /usr/bin/env python
# -*- coding:utf- -*-

from greenlet import greenlet
# greenlet 其实就是手动切换；gevent是对greenlet的封装，可以实现自动切换

def test1():
    print("")
    gr2.switch()   # 切换去执行test2
    print("")
    gr2.switch()   # 切换回test2之前执行到的位置，接着执行

def test2():
    print("")
    gr1.switch()   # 切换回test1之前执行到的位置，接着执行
    print("")

gr1 = greenlet(test1)   # 启动一个协程 注意test1不要加()
gr2 = greenlet(test2)   #
gr1.switch()

输出

gevent 实现协程

Gevent 是一个第三方库，可以轻松通过gevent实现协程程，在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。

gevent会主动识别程序内部的IO操作，当子程序遇到IO后，切换到别的子程序。如果所有的子程序都进入IO，则阻塞。

#! /usr/bin/env python3
# -*- coding:utf- -*-

import gevent

def func1():
    print("func1 running")
    gevent.sleep()             # 内部函数实现io操作
    print("switch func1")

def func2():
    print("func2 running")
    gevent.sleep()
    print("switch func2")

def func3():
    print("func3  running")
    gevent.sleep()
    print("func3 done..")

gevent.joinall([gevent.spawn(func1),
                gevent.spawn(func2),
                gevent.spawn(func3),
                ])

输出

func1 running
func2 running
func3  running
func3 done..
switch func2
switch func1