并发之协程（微线程）

协程是一种程序的组件，它更加的一般与灵活。

扩展：

子例程：一般的认为，子例程是某个主程序的一部分代码，改代码执行特定的任务并且和主程序中的其他代码相对独立。

              子例程又被成为子程序，过程，方法，函数等。在主程序中可以调用子例程来执行。

               函数，是一种子程序，利用函数名称，可以接受回传值。

协程不是进程或线程，协程又叫做微线程，纤程，英文名Coroutine

协程的概念在很早就被提出来了，但是在最近几年才在某些语言中得到广泛的应用。

子程序，或者称为函数，在所有的语言中都是层次调用，比如A调用B，B在执行过程中又调用了C，C执行完毕返回，B执行完毕返回，最后是A执行完毕。所以子程序调用是通过栈来实现的，一个线程就是在执行一个子程序。

子程序调用总是一个入口，一次返回，调用顺序是明确的，而协程的调用和子程序不同。

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

注意：

在一个子程序中终端，去执行其他的子程序，不是函数调用，有点类似于CPU的中断：

def A():
   print('1')
   print('2')
   print('3')
def B():
   print('x')
   print('y')
   print('z')

1
2
x
y
z
3

假设由协程执行，在执行A的过程中，可以随时中断，去执行B，B也可能在执行过程中中断去执行A结果就如上面可见;

但是在A中是没有调用B的，所以协程的调用比函数的调用理解起来要难一些;

看起来A、B的执行有点像多线程，但协程的特点在于是一个线程的执行，和多线程相比协程有什么优势呢？

协程的优势：

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

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

以为协程是一个线程在执行，那么怎么利用多核CPU呢？

最简单的方法是多进程+协程，既充分利用多核，又充分发挥协程的高效率，可获得极高的性能。

python对于协程的支持还非常的有限，用generator中的yield可以一定程度上实现协程，虽然支持不完全，但已经可以发挥相当大的威力了。

来看看例子：

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

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

import time

def consumer():
    r=''
    while True:
       n=yield r
       if not n:
           return
       print('[CONSUMR] Consuming %s'%n)
       time.sleep(1)
       r='200 OK'
def produce(c):
   c.next()
   n=0
   while n<5:
      n=n+1
      print('[PRODUCE] Producing %s'%n)
      r=c.send(n)
      print('[PRODUCE] Producing %s'%r)
   c.close()

if __name__='__main__':
    c=consumer()
    produce(c)


执行结果： 

[PRODUCE] Producing 1
[CONSUMR] Consuming 1
[PRODUCE] Producing 200 OK
[PRODUCE] Producing 2
[CONSUMR] Consuming 2
[PRODUCE] Producing 200 OK
[PRODUCE] Producing 3
[CONSUMR] Consuming 3
[PRODUCE] Producing 200 OK
[PRODUCE] Producing 4
[CONSUMR] Consuming 4
[PRODUCE] Producing 200 OK
[PRODUCE] Producing 5
[CONSUMR] Consuming 5
[PRODUCE] Producing 200 OK

注意到consumer函数是一个generator（生成器），把一个consumer传入produce后：

1.首先调用c.next()启动生成器;

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

3.consumer通过yield拿到消息，处理，又通过yield把消息传回;

4.produce拿到consumer处理的结果，继续生产下一条消息;

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

整个过程无锁，有一个线程执行，produce和consumer协作完成任务，所以成为"协程"，而非线程的抢占式多任务。

最后一句话：

    ‘子程序就是协程的一种特例’