Python中实现多任务耗资源最小的方式

协程，又称微线程，纤程。英文名 Coroutine。

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

为啥说它是一个执行单元，因为它自带 CPU 上下文。这样只要在合适的时机， 我们可以把一个协程 切换到另一个协程。 只要这个过程中保存或恢复 CPU上下文那么程序还是可以运行的。

通俗的理解：在一个线程中的某个函数，可以在任何地方保存当前函数的一些临时变量等信息，然后切换到另外一个函数中执行，注意不是通过调用函数的方式做到的，并且切换的次数以及什么时候再切换到原来的函数都由开发者自己确定。

协程和线程差异

在实现多任务时, 线程切换从系统层面远不止保存和恢复 CPU上下文这么简单。

操作系统为了程序运行的高效性每个线程都有自己缓存 Cache 等等数据，操作系统还会帮你做这些数据的恢复操作，所以线程的切换非常耗性能。

但是协程的切换只是单纯的操作 CPU 的上下文，所以一秒钟切换个上百万次系统都抗得住。

之前我们讲过 yield 关键字，现在就用它来实现多任务。

例子：

import time

def task_1():
    while True:
        print("--1--")
        time.sleep(0.5)
        yield

def task_2():
    while True:
        print("--2--")
        time.sleep(0.5)
        yield

def main():
    t1 = task_1()
    t2 = task_2()
    while True:
        next(t1)
        next(t2)

if __name__ == "__main__":
    main()

运行过程：

先让 t1 运行一会，当 t1 遇到 yield 的时候，再返回到 main() 循环的地方，然后执行 t2 ， 当它遇到 yield 的时候，再次切换到 t1 中，这样 t1 和 t2 就交替运行，最终实现了多任务，协程。

运行结果：

greenlet

为了更好使用协程来完成多任务，Python 中的 greenlet 模块对其封装，从而使得切换任务变的更加简单。

首先你要安装一下 greenlet 模块。

pip3 install greenlet

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()

运行结果：

和我们之前用 yield 实现的效果基本一样，greenlet 其实是对 yield 进行了简单的封装。

greenlet 实现多任务要比 yield 更简单，但是我们以后还是不用它。

上面例子中的延时是0.5秒，如果延迟是100秒，那么程序就会卡住100秒，就算有其他需要执行的任务，系统也不会切换过去，这100秒的时间是无法利用的。

这个问题下面来解决。

gevent

greenlet 已经实现了协程，但是还是得进行人工切换，是不是觉得太麻烦了。

Python 还有一个比 greenlet 更强大的并且能够自动切换任务的模块 gevent。

gevent 是对 greenlet 的再次封装。

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

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

首先还是得先安装 gevent。

pip3 install gevent

例子：

import gevent

def f(n):
    for i in range(n):
        print(gevent.getcurrent(), i)

g1 = gevent.spawn(f, 3)
g2 = gevent.spawn(f, 3)
g3 = gevent.spawn(f, 3)
g1.join()
g2.join()
g3.join()

运行结果:

<Greenlet at 0x35aae40: f(3)> 0
<Greenlet at 0x35aae40: f(3)> 1
<Greenlet at 0x35aae40: f(3)> 2
<Greenlet at 0x374a780: f(3)> 0
<Greenlet at 0x374a780: f(3)> 1
<Greenlet at 0x374a780: f(3)> 2
<Greenlet at 0x374a810: f(3)> 0
<Greenlet at 0x374a810: f(3)> 1
<Greenlet at 0x374a810: f(3)> 2

可以看到，3个 greenlet 是依次运行而不是交替运行。

这还无法判断 gevent 是否实现了多任务的效果，最好的判断情况是在运行结果中 0 1 2 不按顺序出现。

在 gevent 的概念中，我们提到 gevent 在遇到延时的时候会自动切换任务。

那么，我们先给上面的例子添加延时，再看效果。

import gevent
import time

def f(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        time.sleep(0.5)

g1 = gevent.spawn(f, 3)
g2 = gevent.spawn(f, 3)
g3 = gevent.spawn(f, 3)
g1.join()
g2.join()
g3.join()

运行结果：

<Greenlet at 0x36aae40: f(3)> 0
<Greenlet at 0x36aae40: f(3)> 1
<Greenlet at 0x36aae40: f(3)> 2
<Greenlet at 0x384a780: f(3)> 0
<Greenlet at 0x384a780: f(3)> 1
<Greenlet at 0x384a780: f(3)> 2
<Greenlet at 0x384a810: f(3)> 0
<Greenlet at 0x384a810: f(3)> 1
<Greenlet at 0x384a810: f(3)> 2

在添加了延时之后，运行结果并没有改变。

其实，gevent 要的不是 time.sleep() 的延时，而是 gevent.sleep() 的延时。

import gevent

def f(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        gevent.sleep(0.5)

g1 = gevent.spawn(f, 3)
g2 = gevent.spawn(f, 3)
g3 = gevent.spawn(f, 3)
g1.join()
g2.join()
g3.join()

join 还有一种更简单的写法。

import time
import gevent

def f(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        gevent.sleep(0.5)

gevent.joinall([
    gevent.spawn(f, 3),
    gevent.spawn(f, 3),
    gevent.spawn(f, 3)
])

一般都是后面的这种写法。

运行结果:

<Greenlet at 0x2e5ae40: f(3)> 0
<Greenlet at 0x2ffa780: f(3)> 0
<Greenlet at 0x2ffa810: f(3)> 0
<Greenlet at 0x2e5ae40: f(3)> 1
<Greenlet at 0x2ffa780: f(3)> 1
<Greenlet at 0x2ffa810: f(3)> 1
<Greenlet at 0x2e5ae40: f(3)> 2
<Greenlet at 0x2ffa780: f(3)> 2
<Greenlet at 0x2ffa810: f(3)> 2

这下终于实现多任务的效果了, gevent 在遇到延时的时候，就自动切换到其他任务。

这里是将 time 中的 sleep 换成了 gevent 中的 sleep。

那如果有网络程序，网络程序中也有许多堵塞，比如 connect， recv，accept，需要不需要换成 gevent 中的对应方法。

理论上来说，是要换的。如果想用 gevent，那么就要把所有的延时操作，堵塞这一类的函数，统统换成 gevent 中的对应方法。

那有个问题，万一我的代码已经写了10万行了，这换起来怎么破......

有什么办法不需要手动修改么，有，打个补丁即可。

import time
import gevent
from gevent import monkey

# 有耗时操作时需要
# 将程序中用到的耗时操作的代码，换为gevent中自己实现的模块
monkey.patch_all()  

def f(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        time.sleep(0.5)

g1 = gevent.spawn(f, 3)
g2 = gevent.spawn(f, 3)
g3 = gevent.spawn(f, 3)
g1.join()
g2.join()
g3.join()

monkey.patch_all() 会自动去检查代码，将所有会产生延时堵塞的方法，都自动换成 gevent 中的方法。

运行结果：

<Greenlet at 0x3dd91e0: f(3)> 0
<Greenlet at 0x3dd9810: f(3)> 0
<Greenlet at 0x3dd99c0: f(3)> 0
<Greenlet at 0x3dd91e0: f(3)> 1
<Greenlet at 0x3dd9810: f(3)> 1
<Greenlet at 0x3dd99c0: f(3)> 1
<Greenlet at 0x3dd91e0: f(3)> 2
<Greenlet at 0x3dd9810: f(3)> 2
<Greenlet at 0x3dd99c0: f(3)> 2

总结：

通过利用延时的时间去做其他任务，把时间都利用起来，这就是协程最大的意义。