Python并发之协程基础(4)

 

1, 基本概念

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

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

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

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

比较专业的理解是：

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

协程的优点：

　　（1）无需线程上下文切换的开销，协程避免了无意义的调度，由此可以提高性能（但也因此，程序员必须自己承担调度的责任，同时，协程也失去了标准线程使用多CPU的能力。线程数量越多，协程的性能优势就越明显。

　　（2）无需原子操作锁定及同步的开销。协程不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。

　　（3）方便切换控制流，简化编程模型

　　（4）高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。

协程的缺点：

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

　　（2）进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序

2 , 协程实现

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

以下协程方式实现，利于我们循序渐进的理解协程。

通过yield实现协程

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

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

def consumer(name):
    print("准备开始消费数据")
    while True:
        print("\033[31;1m[consumer] {}\033[0m ".format(name))
        data = yield
        print("{} 正在处理数据: {}".format(name, data))

def producer(obj1, obj2):
    obj1.send(None)   # 启动obj1这个生成器,第一次必须用None  <==> obj1.__next__()
    obj2.send(None)   # 启动obj2这个生成器,第一次必须用None  <==> obj2.__next__()
    n = 0
    while n < 2:
        n += 1
        print("\033[32;1m[producer]\033[0m 正在生产数据 {}".format(n))
        obj1.send(n)
        obj2.send(n)

if __name__ == "__main__":
    print("main process begin")
    con1 = consumer("消费者1") #代码执行到此处时调用consumer函数，遇到yield这一行时跳出函数；继续执行主函数【con2 = consumer("消费者2")】
    con2 = consumer("消费者2") #在这一行同样调用consumer函数，遇到yield这一行跳出函数，继续执行主函数下一行【producer(con1, con2)】
    
    producer(con1, con2) 
    '''进入producer函数，【obj1.send(None)】【和obj2.send(None)】分别启动两个生成器，
    代码执行到【obj1.send(n)】这一行时回到consumer函数的yield位置，并将send过来的数据n赋值给data变量，
    然后继续执行consumer函数的余下代码【print("{} 正在处理数据: {}".format(name, data))】。
    
    执行完print以后，循环还没有退出，继续执行【print("\033[31;1m[consumer] {}\033[0m ".format(name))】之后，
    再次遇到yield跳转到之前的位置执行【obj2.send(n)】，这一行又是跳转到consumer函数，
    send过来的数据n给到data后继续执行consumer函数的余下代码【print("{} 正在处理数据: {}".format(name, data))】。
    
    执行完print以后，循环还没有退出，继续余下的代码。直到整个循环结束
    
    '''

输出如下：

main process begin
准备开始消费数据
[consumer] 消费者1 
准备开始消费数据
[consumer] 消费者2 
[producer] 正在生产数据 1
消费者1 正在处理数据: 1
[consumer] 消费者1 
消费者2 正在处理数据: 1
[consumer] 消费者2 
[producer] 正在生产数据 2
消费者1 正在处理数据: 2
[consumer] 消费者1 
消费者2 正在处理数据: 2
[consumer] 消费者2 

greenlet实现协程

yield能实现协程，不过实现过程不易于理解，greenlet是在这方面做了改进。

Python的 greenlet就相当于手动切换，去执行别的子程序，在“别的子程序”中又主动切换回来。greenlets之间切换通过调用greenlet的switch()方法，在这种情况下，执行点跳转到调用switch()的greenlet，当一个greenlet挂点时，执行点会跳到其父greenlet。在切换的时候，一个对象或者异常可以传到目标greenlet，这可以很方便的用来在greenlet之间传递信息

代码如下：

from greenlet import greenlet
import time
def productor():
    n = 0
    while n < 2:
        n += 1
        print("\033[32;1m[producer]\033[0m 正在生产数据 {}".format(n))
        c.switch(n)  # 切换到c 并传了一个参数item
        time.sleep(1)

def consumer():
    while True:
        data = p.switch() # 切换到p 在恢复的时候接收数据
        print("\033[31;1m[consumer] {}\033[0m ".format(data))

if __name__ == '__main__':
    c = greenlet(consumer) #将一个普通函数变成协程
    p = greenlet(productor)
    c.switch() #进入消费者函数执行，到yield后进入暂停状态，只有恢复时才能接收数据

输出如下：

[producer] 正在生产数据 1
[consumer] 1 
[producer] 正在生产数据 2
[consumer] 2 

gevent实现协程

gevent的基本原理来自于libevent&libev。熟悉c语言的同学对这么一个lib应该不陌生。本质上libevent或者说libev都是一种事件驱动模型。这种模型对于提高cpu的运行效率，增强用户的并发访问非常有效。但是因为它本身是一种事件机制，所以写起来有点绕，不是很直观。所以，为了修正这个问题，有心人引入了用户侧上下文切换的机制。这就是说，如果代码中引入了带io阻塞的代码时，lib本身会自动完成上下文的切换，全程用户都是没有觉察的。这就是gevent的由来。

gevent模块：

• gevent是在greenlet的基础上进行封装使得gevent变得更加的易用。

• gevent采用了隐式启动事件循环，即在需要阻塞的时候开启一个专门的协程来启动事件循环；

• 如果一个任务没有io操作，那么他会一直执行直到完成；其他协程没有执行的机会；

• 自动识别io事件，放弃CPU控制时间；

gevent 的价值：
价值一： 使用基于 epoll 的 libev 来避开阻塞
价值二： 使用基于 gevent 的 高效协程 来切换执行
价值三： 只在遇到阻塞的时候切换，没有轮需的开销，也没有线程的开销

示例代码：

import gevent

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

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

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

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

输出：

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

生产者/消费者模型示例：

import gevent
from gevent import monkey
monkey.patch_all()
from gevent.queue import Queue

queue = Queue()

def productor(queue):
    n = 0
    while n < 2:
        n += 1
        print("\033[32;1m[producer]\033[0m 正在生产数据 {}".format(n))
        queue.put(n)
        gevent.sleep(2)

def consumer(queue):
    while True:
        if not queue.empty():
            data = queue.get()
            print("\033[31;1m[consumer] {}\033[0m ".format(data))
        gevent.sleep(1)

if __name__ == '__main__':
    p = gevent.spawn(productor, queue)
    c = gevent.spawn(consumer, queue)
    p.join()
    c.join()

输出：

[producer] 正在生产数据 1
[consumer] 1 
[producer] 正在生产数据 2
[consumer] 2 

参考文献：

https://softlns.github.io/2015/11/28/python-gevent/

https://www.cnblogs.com/zingp/p/5911537.html

https://www.cnblogs.com/woaixuexi9999/p/9356677.html

https://www.cnblogs.com/piperck/p/5650167.html