day10-协程介绍及基本示例

概述

协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：

协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态，换种说法：进入上一次离开时所处逻辑流的位置。

定义

协程，又称微线程，纤程。英文名Coroutine。一句话说明什么是协程：协程是一种用户态的轻量级线程。

协程的好处：

• 无需线程上下文切换的开销
• 无需原子操作锁定及同步的开销
  • "原子操作(atomic operation)是不需要synchronized"，所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）。原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序是不可以被打乱，或者切割掉只执行部分。视作整体是原子性的核心。
• 方便切换控制流，简化编程模型
• 高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。

缺点：

• 无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
• 进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序

实现协程方式

yield

def consumer(name):
    print("--->starting eating baozi...")
    while True:
        new_baozi = yield #设置生成器
        print("[%s] is eating baozi %s" % (name, new_baozi))
        # time.sleep(1)


def producer():
    r = con.__next__()  #唤醒yield生成器，获得生成器返回值
    r = con2.__next__()
    n = 0
    while n < 5:
        n += 1
        con.send(n)
        con2.send(n) #调用yield并且给其传值n
        print("\033[32;1m[producer]\033[0m is making baozi %s" % n)


if __name__ == '__main__':
    con = consumer("c1")  #创建一个生成器c1
    con2 = consumer("c2") #创建一个生成器c2
    p = producer()

#运行输出
--->starting eating baozi...
--->starting eating baozi...
[c1] is eating baozi 1
[c2] is eating baozi 1
[producer] is making baozi 1
[c1] is eating baozi 2
[c2] is eating baozi 2
[producer] is making baozi 2
[c1] is eating baozi 3
[c2] is eating baozi 3
[producer] is making baozi 3
[c1] is eating baozi 4
[c2] is eating baozi 4
[producer] is making baozi 4
[c1] is eating baozi 5
[c2] is eating baozi 5
[producer] is making baozi 5

Process finished with exit code 0

解析：上面我们通过yield被唤醒时接收生成器c1和c2发送的数据，通过使用yield实现了简单的协程，在单进程的情况下实现并发的效果。

import time

def home():
    print("in func 1")
    time.sleep(5) #get data from db
    print("home page done")
    
def bbs():
    print("in func 2")
    time.sleep(2)
    
def sns():
    print("in func 3")

那么问题来了，它为什么在单进程下可以实现多并发的效果？遇到I/O操作就切换，因为I/O耗时，协程之所以能够处理大并发，其实就是把I/O操作给挤掉了，最后整个程序就变成了只有CPU的运算，由于CPU的速度很快，所以就感觉实现并发的效果。

基于以上对协程的简单实现，即符合什么条件才能称之为协程：

1、必须在只有一个单线程里实现并发

2、修改共享数据不需加锁

3、用户程序里自己保存多个控制流的上下文栈

4、一个协程遇到I/O操作自动切换到其他协程

但是当协程切换到sns执行完后如何切换回来呢？如果home和bbs的I/O操作一完成，协程自动就切换回去了，也就是说把I/O所花的时间挤出去了，那么按照这个思路，程序如何监测知道I/O的操作已经完成了？

Greenlet

功能：greenlet是一个用C实现的协程模块，相比与python自带的yield，它可以使你在任意函数之间随意手动切换，而不需把这个函数先声明为生成器(generator)

from greenlet import greenlet


def test1():
    print(12) #2
    gr2.switch()  #3 切换到test2
    print(34) #6
    gr2.switch()  #7 切换到test2


def test2():
    print(56) #4
    gr1.switch()  #5 切换到test1
    print(78) #8


gr1 = greenlet(test1) #启动一个协程
gr2 = greenlet(test2) #启动另一个协程
gr1.switch() #1 切换到test1

#运行输出

12
56
34
78

执行过程解析：1=>2=>3=>4=>5=>6=>7=>8，使用switch()函数进行I/O切换。

产生的问题：感觉确实用着比generator还简单了呢，但好像还没有解决一个问题，就是遇到IO操作，自动切换，对不对？