Python使用gevent实现协程

Python使用gevent实现协程

Python中多任务的实现可以使用进程和线程，也可以使用协程。

一、协程介绍

协程，又称微线程。英文名Coroutine。协程是Python语言中所特有的，在其他语言中没有。

协程是python中另外一种实现多任务的方式，比线程更小、占用更小执行单元（理解为需要的资源）。

在一个线程中的某个函数，可以在任何地方保存当前函数的一些临时变量等信息，然后切换到另外一个函数中执行。

注意不是通过调用函数的方式做到的，并且切换的次数以及什么时候再切换到原来的函数都由开发者自己决定。

在实现多任务时, 线程切换从系统层面来说，远不止保存和恢复CPU上下文那么简单。 操作系统为了程序运行的高效性，每个线程都有自己缓存的数据，操作系统还会帮我们做这些数据的恢复操作。 所以线程的切换非常耗性能。协程的切换只是单纯的操作CPU的上下文，所以一秒钟切换上百万次系统都抗的住。

二、通过yield实现任务切换

import time


def coroutine1():
    for i in range(5):
        print("-----coroutine1-----")
        yield
        time.sleep(1)


def coroutine2():
    for i in range(5):
        print("-----coroutine2-----")
        yield
        time.sleep(1)


if __name__ == "__main__":
    c1 = coroutine1()
    c2 = coroutine2()
    for i in range(3):
        next(c1)
        next(c2)

运行结果：

-----coroutine1-----
-----coroutine2-----
-----coroutine1-----
-----coroutine2-----
-----coroutine1-----
-----coroutine2-----

yield可以用来实现生成器，当函数中有yield时，则不再是函数而是生成器。

参考：https://blog.csdn.net/weixin_43790276/article/details/90523155

当运行到yield时，会保存当前运行状态，然后暂停执行，直到使用next()方法再次调用生成器时，才会从yield处开始执行，再次回到yield处暂停住。

利用yield的特性，我们可以用来切换任务，当任务1暂停的时候，切换到任务2，当任务2暂停时，切换回任务1，如此循环。

上面的代码中，有两个任务coroutine1和coroutine2，coroutine1和coroutine2中都有yield关键字，所以我们可以在coroutine1和coroutine2间来回切换执行。

协程就是通过yield来实现多个任务之间的切换的。

三、使用greenlet实现任务切换

安装greenlet：

pip install greenlet

import greenlet
import time


def greenlet1():
    for i in range(3):
        print("-----greenlet1-----")
        time.sleep(1)
        g2.switch()


def greenlet2():
    for i in range(3):
        print("-----greenlet2-----")
        time.sleep(1)
        g1.switch()


g1 = greenlet.greenlet(greenlet1)
g2 = greenlet.greenlet(greenlet2)

# 切换到gr1中运行
g1.switch()

运行结果：

-----greenlet1-----
-----greenlet2-----
-----greenlet1-----
-----greenlet2-----
-----greenlet1-----
-----greenlet2-----

python中的greenlet模块对yield切换任务的功能进行了封装，可以通过代码来切换任务。

上面的代码中，写了两个函数greenlet1和greenlet2，在greenlet1中的代码执行完成后，通过switch()切换到greenlet2，greenlet2中的代码执行完成后，又通过switch()方法切换回greenlet1。这样就实现了任务的切换，要调用这两个任务，只需要在主线程中先切换到greenlet1，程序就会在greenlet1和greenlet2之间来回切换执行。

四、使用gevent实现协程

安装gevent:

pip install gevent

import gevent
import time


def gevent_func():
    for i in range(3):
        print(gevent.getcurrent(), i)
        gevent.sleep(1)


start = time.time()
gevent_func()
gevent_func()
gevent_func()
end = time.time()
print('One coroutine: ', end - start)

gevent_start = time.time()
g1 = gevent.spawn(gevent_func,)
g2 = gevent.spawn(gevent_func,)
g3 = gevent.spawn(gevent_func, )
g1.join()
g2.join()
g3.join()
gevent_end = time.time()
print('Multi coroutine: ', gevent_end - gevent_start)

运行结果：

<greenlet.greenlet object at 0x0000027C66D9EF60> 0
<greenlet.greenlet object at 0x0000027C66D9EF60> 1
<greenlet.greenlet object at 0x0000027C66D9EF60> 2
<greenlet.greenlet object at 0x0000027C66D9EF60> 0
<greenlet.greenlet object at 0x0000027C66D9EF60> 1
<greenlet.greenlet object at 0x0000027C66D9EF60> 2
<greenlet.greenlet object at 0x0000027C66D9EF60> 0
<greenlet.greenlet object at 0x0000027C66D9EF60> 1
<greenlet.greenlet object at 0x0000027C66D9EF60> 2
One coroutine:  9.023481130599976
<Greenlet at 0x27c66c9f6a8: gevent_func> 0
<Greenlet at 0x27c66c9f598: gevent_func> 0
<Greenlet at 0x27c66c9f7b8: gevent_func> 0
<Greenlet at 0x27c66c9f6a8: gevent_func> 1
<Greenlet at 0x27c66c9f598: gevent_func> 1
<Greenlet at 0x27c66c9f7b8: gevent_func> 1
<Greenlet at 0x27c66c9f6a8: gevent_func> 2
<Greenlet at 0x27c66c9f598: gevent_func> 2
<Greenlet at 0x27c66c9f7b8: gevent_func> 2
Multi coroutine:  3.0032901763916016

python中的gevent模块对greenlet模块进行了封装，实现了自动切换任务，实现了协程。

其原理是当一个greenlet遇到IO(input output输入输出)、阻塞(比如网络延迟、文件操作等)操作时，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。

由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO。

上面的代码中，执行三次任务，任务是在同一个协程中执行的，耗时9秒多，当我们创建三个协程来执行任务时，耗时3秒多，说明使用多协程实现了多任务。

这也是为什么前面使用yield和greenlet时只说是任务切换，因为yield和greenlet是把一个任务(包含耗时等待)执行完后再切换到另一个任务，所以只起到任务切换的作用。而使用gevent时，只要遇到等待就会自动切换到其他协程，可以跳过等待的时间。

五、gevent的monkey补丁

细心的您应该已经看到，上面我们使用gevent实现协程的代码中，不是使用time.sleep(1)，而是使用的gevent.sleep(1)来模拟等待。

因为在程序中有耗时操作时，需要将耗时操作的代码换为gevent中自己实现的模块，才能自动切换协程。

但是，开发中代码比上面的例子复杂多了，我们尽量不要去修改之前的代码。所以gevent模块中提供了一个monkey补丁，帮我实现将耗时代码换成gevent自己实现的模块。

import gevent
from gevent import monkey
import time


monkey.patch_all()


def gevent_func():
    for i in range(3):
        print(gevent.getcurrent(), i)
        time.sleep(1)


gevent_start = time.time()
g1 = gevent.spawn(gevent_func,)
g2 = gevent.spawn(gevent_func,)
g3 = gevent.spawn(gevent_func, )
g1.join()
g2.join()
g3.join()
gevent_end = time.time()
print('Multi coroutine: ', gevent_end - gevent_start)

运行结果：

<Greenlet at 0x27fc0b77158: gevent_func> 0
<Greenlet at 0x27fc0b77268: gevent_func> 0
<Greenlet at 0x27fc0b77378: gevent_func> 0
<Greenlet at 0x27fc0b77158: gevent_func> 1
<Greenlet at 0x27fc0b77268: gevent_func> 1
<Greenlet at 0x27fc0b77378: gevent_func> 1
<Greenlet at 0x27fc0b77158: gevent_func> 2
<Greenlet at 0x27fc0b77268: gevent_func> 2
<Greenlet at 0x27fc0b77378: gevent_func> 2
Multi coroutine:  3.0212624073028564

通过monkey补丁，即使代码里面使用的是time.sleep(1)，在运行程序时，monkey补丁会帮我们自动更换为gevent.sleep(1)。

六、进程、线程、协程对比

1.进程切换需要的资源最大，效率很低。

2.线程切换需要的资源一般，效率一般，介于进程和协程之间（在不考虑GIL的情况下）。

3.协程切换任务资源很小，效率高。