Python 协程

 使用yield完成多任务

  yield --------- 可以让一个函数暂停执行，并且每次调用的值依旧保存，下次调用可以继续使用（原理）

下面的一个小demo，在一个进程和一个线程的情况下，通过yield实现了两个函数并发执行，占用资源比 多进程，多线程 均少

#!/usr/bin/env python
# _*_ coding:utf-8 _*_

import time


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


def task_2():
    while True:
        print("----2----")
        time.sleep(0.3)
        yield
        # 先让t1运行，当t1中遇到yield时，再返回25行，然后
        # 执行t2，当它遇到yield时，再次切换到t1中
        # 这样t1 t2 t1 t2 交替运行，最终实现了多任务....协程


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


if __name__ == '__main__':
    main()

 

使用 greenlet、gevent 完成多任务

greenlet 替换 yield

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

#!/usr/bin/env python
# _*_ coding:utf-8 _*_

from greenlet import greenlet
import time


def task_1():
    while True:
        print("----A----")
        gr2.switch()  # 切换到task_2()，下次运行从下方开始
        time.sleep(0.3)


def task_2():
    while True:
        print("----B----")
        gr1.switch()  # 切换到task_1()，下次运行从下方开始
        time.sleep(0.3)


gr1 = greenlet(task_1)
gr2 = greenlet(task_2)

gr1.switch()    # 运行task_1()

 

自动切换任务的模块 gevent  （最常用）

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

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

 

使用gevent时，程序运行时，会自动的判断是否阻塞耗时，当阻塞耗时时，切换任务。不阻塞不切换，当使用 time.sleep()、

socket.recv() 等阻塞耗时时，默认不认可为阻塞状态（顺序执行），均需配置成 gevent.sleep() 等类似方法才会被认为阻塞耗时，当代码改动较大时，可以导入  monkey.patch_all() 方法（该方法自动寻找替换为对应的gevent阻塞耗时方法）放在最开始，这样就可以继续使用之前的代码，认可对应的阻塞状态，完成自动切换任务，实现并发。

from gevent import monkey
import gevent
import time

# monkey.patch_all()       # 有耗时操作时使用
def f1(n):
    for i in range(n):
        print(gevent.getcurrent(), i)       # 输出对象
        # time.sleep(0.5)
        # gevent.sleep(0.5)


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


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


print("----1---")
g1 = gevent.spawn(f1, 5)  # 不执行，创建对象
print("----2---")
g2 = gevent.spawn(f2, 5)
print("----3---")
g3 = gevent.spawn(f3, 5)
print("----4---")
g1.join()
g2.join()
g3.join()

                     

                             图 1                                                               图 2                                                            图 3 

图1 注释 monkey.patch_all()，使用time.sleep()效果，顺序执行，并没有实现多任务。

图2 注释 monkey.patch_all()，使用gevent.sleep()效果，实现了多任务。

图3  使用monkey.patch_all()，使用time.sleep()效果，依然实现了多任务。

 

继续优化，即最终版 优化调用的join()方法，减少多次调用，使用 gevent.joinall([]) 代替 join() ，参数为一个列表，

列表中为创建的对象，自动调用，当所有任务完成时，结束 gevent.joinall()方法。

#!/usr/bin/env python
# _*_ coding:utf-8 _*_

from gevent import monkey
import gevent
import time

monkey.patch_all()  # 有耗时操作时使用


def f1(n):
    for i in range(n):
        print(gevent.getcurrent(), i)  # 输出对象
        time.sleep(0.5)


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


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


gevent.joinall([
    gevent.spawn(f1, 3),
    gevent.spawn(f2, 3),
    gevent.spawn(f3, 3)
])

 

一个实现协程并发下载图片的小demo（网络下载图片过程实际就是一个耗时过程）

#!/usr/bin/env python
# _*_ coding:utf-8 _*_


import gevent
from gevent import monkey

monkey.patch_all()
# 把import gevent，from gevent import monkey，monkey.patch_all()三行语句放在其他所有的import语句之前，可以避免出现警告或者报错信息
import requests


def download_img(img_name, img_url):
    req = requests.get(img_url)

    # 保存图片已二进制的方式~ 必须加db 字符串方式写不进去  不需要decode
    with open(img_name, "wb") as f:
        f.write(req.content)


def main():
    gevent.joinall([
        gevent.spawn(download_img, "1.jpg",
                     "http://anchorpost.msstatic.com/cdnimage/anchorpost/1010/74/44042109f82ced7fb1829942dcd3c7_1663_1562725570.jpg"),
        gevent.spawn(download_img, "2.jpg",
                     "http://anchorpost.msstatic.com/cdnimage/anchorpost/1046/e3/0efd2d20148c7df76f8cd0142467b1_1663_1564061844.jpg"),
        gevent.spawn(download_img, "3.jpg",
                     "http://anchorpost.msstatic.com/cdnimage/anchorpost/1062/34/674623a49a38fadcbaeb9f2d9db1c7_1663_1560753477.jpg"),
        gevent.spawn(download_img, "4.jpg",
                     "http://anchorpost.msstatic.com/cdnimage/anchorpost/1099/77/b931b564b23177b08d94c3eafbd719_1663_1561376292.jpg")
    ])


if __name__ == '__main__':
    main()

 

 

进程、线程、协程对比

1 进程是资源分配的单位

2 线程是操作系统调度的单位

3 进程切换需要的资源很大，效率很低

4 线程切换需要的资源一般（不考虑GIL的情况）

5 协程切换任务资源很小，效率高

6 多进程、多线程根据CPU核数不一样可能是并行的，但是协程是在一个线程中，所以一定是并发