玩转python协程的使用gevent,greenlet,yield等

蔚落 2021-12-15 06:47 151阅读 0赞

### 1.进程，线程，协程的关系 ###

**1.1一个浅显的例子，说明三者的逻辑关系**

*  有一个老板想要开个工厂进行生产某件商品（例如剪子）
 *  他需要花一些财力物力制作一条生产线，这个生产线上有很多的器件以及材料这些所有的 为了能够生产剪子而准备的资源称之为：**进程**
 *  只有生产线是不能够进行生产的，所以老板的找个工人来进行生产，这个工人能够利用这些材料最终一步步的将剪子做出来，这个来做事情的工人称之为：**线程**
 *  这个老板为了提高生产率，想到3种办法：
    
    1.  在这条生产线上多招些工人，一起来做剪子，这样效率是成倍増长，即单进程 多线程方式
    2.  老板发现这条生产线上的工人不是越多越好，因为一条生产线的资源以及材料毕竟有限，所以老板又花了些财力物力购置了另外一条生产线，然后再招些工人这样效率又再一步提高了，即多进程 多线程方式
    3.  老板发现，现在已经有了很多条生产线，并且每条生产线上已经有很多工人了（即程序是多进程的，每个进程中又有多个线程），为了再次提高效率，老板想了个损招，规定：如果某个员工在上班时临时没事或者再等待某些条件（比如等待另一个工人生产完谋道工序 之后他才能再次工作） ，那么这个员工就利用这个时间去做其它的事情，那么也就是说：如果一个线程等待某些条件，可以充分利用这个时间去做其它事情，**其实这就是：协程方式**

**1.2.核心的关系：进程，线程，协程都可以实现多任务模式**

1.  进程是资源分配的单位
2.  线程是操作系统调度的单位
3.  进程切换需要的资源很最大，效率很低
4.  线程切换需要的资源一般，效率一般（当然了在不考虑GIL的情况下）
5.  协程切换任务资源很小，效率高
6.  多进程、多线程根据cpu核数不一样可能是并行的，但是协程是在一个线程中 所以是并发

### 2.协程的实现与演示 ###

**协程，又称微线程，英文名Coroutine，协同程序(同一个线程里任务切换协同执行）。**如下，在同在一个线程中的某个函数，可以在任何地方保存当前函数的一些临时变量等信息，然后切换到另外一个函数中执行，注意不是通过调用函数的方式做到的，并且切换的次数以及什么时候再切换到原来的函数都由开发者自己确定。

### 2.1.使用yield实现协程。 ###

import time
    
    def work1():
        while True:
            print("----work1---")
            yield
            time.sleep(0.5)
    
    def work2():
        while True:
            print("----work2---")
            yield
            time.sleep(0.5)
    
    def main():
        w1 = work1()
        w2 = work2()
        while True:
            next(w1)
            next(w2)
    
    if __name__ == "__main__":
        main()
    '''
    ----work1---
    ----work2---
    ----work1---
    ----work2---
    ----work1---
    ....省略....
    '''

### **2.使用greenlet实现协程** ###

可以使用python中的greenlet模块中greenlet实现协程工作，如果没安装先安装 库，这里是基于pycharm执行的

pip3 install greenlet  #如果使用pycharm,则现在环境里安装该模块

from greenlet import greenlet
    import time
    
    def test1():
        while True:
            print "---A--"
            gr2.switch()
            time.sleep(0.5)
    
    def test2():
        while True:
            print "---B--"
            gr1.switch()
            time.sleep(0.5)
    
    gr1 = greenlet(test1)
    gr2 = greenlet(test2)
    
    #切换到gr1中运行
    gr1.switch()
    
    '''
    ---A--
    ---B--
    ---A--
    ---B--
    ---A--
    ---B--
    ---A--
    ---B--
    '''

### ** 3.使用终极模块gevent实现协程** ###

Gevent是一种基于协程的Python网络库，它用到Greenlet提供的，封装了libevent事件循环的高层同步API。它让开发者在不改变编程习惯的同时，用同步的方式写异步I/O的代码。

**        greenlet已经实现了协程，但是这个还的使用switch切换，python还有一个比greenlet更强大的并且能够自动切换任务的模块那就是gevent**.其原理是当一个greenlet遇到IO(指的是input output 输入输出，比如网络、文件操作等)操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。 由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO

import gevent
    
    def f1(n):
        for i in range(n):
            print(gevent.getcurrent(), i)
    def f2(n):
        for i in range(n):
            print(gevent.getcurrent(), i)
    def f3(n):
        for i in range(n):
            print(gevent.getcurrent(), i)
    print("开始执行 ------")
    print("------f1 ------")
    g1 = gevent.spawn(f1, 5) #创建一个协程任务，其实创建的是一个greenlet对象
    print("------f2 ------")
    g2 = gevent.spawn(f2, 5)
    print("------f3 ------")
    g3 = gevent.spawn(f3, 5)
    g1.join()  #join()启动等待g1执行完成
    g2.join()
    g3.join()
    
    '''开始执行 ------
    ------f1 ------
    ------f2 ------
    ------f3 ------
    <Greenlet at 0x23a40197a48: f1(5)> 0
    <Greenlet at 0x23a40197a48: f1(5)> 1
    <Greenlet at 0x23a40197a48: f1(5)> 2
    <Greenlet at 0x23a40197a48: f1(5)> 3
    <Greenlet at 0x23a40197a48: f1(5)> 4
    <Greenlet at 0x23a40197e48: f2(5)> 0
    <Greenlet at 0x23a40197e48: f2(5)> 1
    <Greenlet at 0x23a40197e48: f2(5)> 2
    <Greenlet at 0x23a40197e48: f2(5)> 3
    <Greenlet at 0x23a40197e48: f2(5)> 4
    <Greenlet at 0x23a40373048: f3(5)> 0
    <Greenlet at 0x23a40373048: f3(5)> 1
    <Greenlet at 0x23a40373048: f3(5)> 2
    <Greenlet at 0x23a40373048: f3(5)> 3
    <Greenlet at 0x23a40373048: f3(5)> 4'''

总结分析：上面3个greenlet是依次运行而不是交替运行，前面一个执行完，后面才开始执行的。

**1.下面通过gevent.sleep()实现交替执行，当个g1处于sleep时，切换到g2或者g3执行。**

import gevent ,time
    
    def f1(n):
        for i in range(n):
            print(gevent.getcurrent(), i)
            gevent.sleep(0.5)
    
    def f2(n):
        for i in range(n):
            print(gevent.getcurrent(), i)
            gevent.sleep(0.5)
    def f3(n):
        for i in range(n):
            print(gevent.getcurrent(), i)
            gevent.sleep(0.5)  #用来模拟一个耗时操作，注意不是time模块中的sleep
    print("开始执行 ------")
    print("------f1 ------")
    g1 = gevent.spawn(f1, 5) #创建一个协程任务，其实创建的是一个greenlet对象
    print("------f2 ------")
    g2 = gevent.spawn(f2, 5)
    print("------f3 ------")
    g3 = gevent.spawn(f3, 5)
    g1.join()  #join()等待g1执行完成
    g2.join()
    g3.join() #可以使用joinall([])替代
    
    '''
    开始执行 ------
    ------f1 ------
    ------f2 ------
    ------f3 ------
    <Greenlet at 0x2226aa27a48: f1(5)> 0
    <Greenlet at 0x2226aa27e48: f2(5)> 0
    <Greenlet at 0x2226abf3048: f3(5)> 0
    <Greenlet at 0x2226aa27a48: f1(5)> 1
    <Greenlet at 0x2226aa27e48: f2(5)> 1
    <Greenlet at 0x2226abf3048: f3(5)> 1
    <Greenlet at 0x2226aa27a48: f1(5)> 2
    <Greenlet at 0x2226aa27e48: f2(5)> 2
    <Greenlet at 0x2226abf3048: f3(5)> 2
    <Greenlet at 0x2226aa27a48: f1(5)> 3
    <Greenlet at 0x2226aa27e48: f2(5)> 3
    <Greenlet at 0x2226abf3048: f3(5)> 3
    <Greenlet at 0x2226aa27a48: f1(5)> 4
    <Greenlet at 0x2226aa27e48: f2(5)> 4
    <Greenlet at 0x2226abf3048: f3(5)> 4
    '''

**2.当然，实际代码里，我们不会用`gevent.sleep()`去切换协程，而是在执行到IO操作时，gevent自动切换，比如：**

from gevent import monkey
    import gevent
    import random
    import time
    
    # 有耗时操作时需要,这里patch_all()相当于在gevent.sleep()
    monkey.patch_all()  # 将程序中用到的耗时操作的代码，换为gevent中自己实现的模块，实现协程切换
    
    def ct_work(args):
        for i in range(4):
            print(args, i)
            time.sleep(random.random())
    
    gevent.joinall([ #替换了逐个join()操作。
            gevent.spawn(ct_work, "work1"),
            gevent.spawn(ct_work, "work2")
    ])
    ''''注意，如果不加patch_all()耗时操作，这里是顺序输出的。
    work1 0
    work2 0
    work2 1
    work1 1
    work1 2
    work2 2
    work2 3
    work1 3
    '''

**尖叫提示：**

使用Gevent的性能确实要比用传统的线程高，甚至高很多。但这里不得不说它的一个坑：

1.  Monkey-patching，我们都叫猴子补丁，因为如果使用了这个补丁，Gevent直接修改标准库里面大部分的阻塞式系统调用，包括socket、ssl、threading和 select等模块，而变为协作式运行。但是我们无法保证你在复杂的生产环境中有哪些地方使用这些标准库会由于打了补丁而出现奇怪的问题
2.  第三方库支持。得确保项目中用到其他用到的网络库也必须使用纯Python或者明确说明支持Gevent

统一声明：关于原创博客内容，可能会有部分内容参考自互联网，如有原创链接会声明引用；如找不到原创链接，在此声明如有侵权请联系删除哈。关于转载博客，如有原创链接会声明；如找不到原创链接，在此声明如有侵权请联系删除哈。