Python—协程(Coroutine)

参考手册：https://docs.python.org/zh-cn/3.10/library/asyncio-task.html

1、概念简介

协程不是被操作系统内核所管理，而完全是由程序所控制（也就是在用户态执行），是一种用户状态内的上下文切换技术，其实就是通过一个线程实现代码块相互切换执行，因此也称为轻量级的线程。

协程的切换完全由程序控制，而非通过操作系统内核来实现，因此对资源的开销更小；

2、使用场景

通过 async & awiat 实现异步编程，是Python实现异步操作的主流技术；

如果一个对象可以在 await 语句中使用，那么它就是 可等待 对象。许多 asyncio API 都被设计为接受可等待对象。

可等待 对象有三种主要类型: Coroutine(协程)，task(任务) 和 Future；

3、实现方式

1）greenlet：一个第三方模块，需要提前安装 pip3 install greenlet才能使用；

2）yield生成器：借助生成器的特点亦可以实现协程代码；

3）asyncio：在python3.4 种引入的模块，用于编写协程代码；

说明：主要通过装饰器 @asyncio.coroutine 来实现协程函数定义；Python3.8之后 @asyncio.coroutine 装饰器会被移除，推荐使用async & awit 关键字实现协程代码。

4）async & awiat：在python3.5中引入的两个关键字，结合asyncio模块使用；

4、代码案例

场景：目前解析一个 xml文件，需要解析的节点处理为一个列表，然后希望并发解析列表里的节点数据；

实现方式1：多线程方式
1）创建函数 parseNode(node, delay)；
2）循环该节点列表，每个节点分配一个线程去执行 parseNode(node, delay)，同时将该线程加入线程列表 thread_list；
3）循环线程列表，执行 th.join()，使主线程等待每个线程执行完成；
4）执行主线程后续步骤；

实现方式2：协程方式

代码1：直接执行协程对象

# -*- coding= utf-8 -*-
"""
@DevTool  : PyCharm
@Author   : xxx
@DateTime : 2024/1/29 15:36
@FileName : coroutineDemo.py
"""
import asyncio
import time


async def parseNode(th_n: int, delay: int):
    print("协程{}-开始执行!".format(th_n))
    await asyncio.sleep(delay)
    print("协程{}-执行结束,耗时{}秒!".format(th_n, delay))


node_list = [x for x in range(1, 21)]
print("主线程-运行开始")
v_start = time.time()
for x in node_list:
    asyncio.run(parseNode(x, x))

v_end = time.time()
print("主线程-运行结束,耗时{}秒!".format(round((v_end - v_start), 2)))

输出结果1：

E:\PythonProject\dataSpider\venv\Scripts\python.exe E:/PythonProject/dataSpider/coroutineDemo.py
主线程-运行开始
协程1-开始执行!
协程1-执行结束，耗时1秒!
协程2-开始执行!
协程2-执行结束，耗时2秒!
协程3-开始执行!
协程3-执行结束，耗时3秒!
协程4-开始执行!
协程4-执行结束，耗时4秒!
协程5-开始执行!
协程5-执行结束，耗时5秒!
协程6-开始执行!
协程6-执行结束，耗时6秒!
协程7-开始执行!
协程7-执行结束，耗时7秒!
协程8-开始执行!
协程8-执行结束，耗时8秒!
协程9-开始执行!
协程9-执行结束，耗时9秒!
协程10-开始执行!
协程10-执行结束，耗时10秒!
协程11-开始执行!
协程11-执行结束，耗时11秒!
协程12-开始执行!
协程12-执行结束，耗时12秒!
协程13-开始执行!
协程13-执行结束，耗时13秒!
协程14-开始执行!
协程14-执行结束，耗时14秒!
协程15-开始执行!
协程15-执行结束，耗时15秒!
协程16-开始执行!
协程16-执行结束，耗时16秒!
协程17-开始执行!
协程17-执行结束，耗时17秒!
协程18-开始执行!
协程18-执行结束，耗时18秒!
协程19-开始执行!
协程19-执行结束，耗时19秒!
协程20-开始执行!
协程20-执行结束，耗时20秒!
主线程-运行结束,耗时210.15秒!

Process finished with exit code 0

从输出结果看，明显是串行执行的，下面用另外一种代码实现并行执行；

代码2：执行代理主函数对象

Python 在3.7 中加入了asyncio.create_task() 函数，低版本的Python可以改用低层级的 asyncio.ensure_future() 函数；
asyncio.create_task() 函数用来并发运行作为 asyncio 任务 的多个协程。

# -*- coding= utf-8 -*-
"""
@DevTool  : PyCharm
@Author   : xxx
@DateTime : 2024/1/29 15:36
@FileName : coroutineDemo.py
"""
import asyncio
import time


async def parseNode(th_n: int, delay: int):
    print("协程{}-开始执行!".format(th_n))
    await asyncio.sleep(delay)
    print("协程{}-执行结束,耗时{}秒!".format(th_n, delay))


async def proxyMain():
    exec_list = [x for x in range(1, 21)]
    task_list = list() # 任务列表
    for x in exec_list:
        task = asyncio.create_task(parseNode(x, x))
        task_list.append(task) # 将每个任务都放入任务列表

    for y in task_list:
        await y # 使主线程等待每个任务执行完成


v_start = time.time()
print("主线程-运行开始")
asyncio.run(proxyMain())
v_end = time.time()
print("主线程-运行结束,耗时{}秒!".format(round((v_end - v_start), 2)))

输出结果2：

E:\PythonProject\dataSpider\venv\Scripts\python.exe E:/PythonProject/dataSpider/encryptDemo.py
主线程-运行开始
协程1-开始执行!
协程2-开始执行!
协程3-开始执行!
协程4-开始执行!
协程5-开始执行!
协程6-开始执行!
协程7-开始执行!
协程8-开始执行!
协程9-开始执行!
协程10-开始执行!
协程11-开始执行!
协程12-开始执行!
协程13-开始执行!
协程14-开始执行!
协程15-开始执行!
协程16-开始执行!
协程17-开始执行!
协程18-开始执行!
协程19-开始执行!
协程20-开始执行!
协程1-执行结束，耗时1秒!
协程2-执行结束，耗时2秒!
协程3-执行结束，耗时3秒!
协程4-执行结束，耗时4秒!
协程5-执行结束，耗时5秒!
协程6-执行结束，耗时6秒!
协程7-执行结束，耗时7秒!
协程8-执行结束，耗时8秒!
协程9-执行结束，耗时9秒!
协程10-执行结束，耗时10秒!
协程11-执行结束，耗时11秒!
协程12-执行结束，耗时12秒!
协程13-执行结束，耗时13秒!
协程14-执行结束，耗时14秒!
协程15-执行结束，耗时15秒!
协程16-执行结束，耗时16秒!
协程17-执行结束，耗时17秒!
协程18-执行结束，耗时18秒!
协程19-执行结束，耗时19秒!
协程20-执行结束，耗时20秒!
主线程-运行结束,耗时20.01秒!

Process finished with exit code 0

从输出结果看，执行时间从之前的 210秒 降到了20秒；
说明：上述代码中必须先全部使用 create_task任务，然后在调用每个任务；

代码3：asyncio.gather(task)任务组

# -*- coding= utf-8 -*-
"""
@DevTool  : PyCharm
@Author   : xxx
@DateTime : 2024/1/29 15:36
@FileName : coroutineDemo.py
"""
import asyncio
import time


async def parseNode(th_n: int, delay: int):
    print("协程{}-开始执行!".format(th_n))
    await asyncio.sleep(delay)
    print("协程{}-执行结束,耗时{}秒!".format(th_n, delay))


async def proxyMain():
    exec_list = [x for x in range(1, 21)]
    task_list = list()  # 任务列表
    task_set = asyncio.gather()
    for x in exec_list:
        task = asyncio.create_task(parseNode(x, x))
        task_set = asyncio.gather(task)  # 将每个任务都放入任务列表

    await task_set


v_start = time.time()
print("主线程-运行开始")
asyncio.run(proxyMain())
v_end = time.time()
print("主线程-运行结束,耗时{}秒!".format(round((v_end - v_start), 2)))

代码4：

python 在 3.11 版本加入了 asyncio.TaskGroup类，提供了create_task() 更现代化的替代；

# -*- coding= utf-8 -*-
"""
@DevTool  : PyCharm
@Author   : gzh
@DateTime : 2024/2/1 15:57
@FileName : coroutDemo.py
"""

import asyncio
import time


async def parseNode(th_n: int, delay: int):
    print("协程{}-开始执行!".format(th_n))
    await asyncio.sleep(delay)
    print("协程{}-执行结束,耗时{}秒!".format(th_n, delay))


async def proxyMain():
    exec_list = [x for x in range(1, 21)]
    async with asyncio.TaskGroup() as tg:
        for x in exec_list:
           task =  tg.create_task(parseNode(x, x))


v_start = time.time()
print("主线程-运行开始")
asyncio.run(proxyMain())
v_end = time.time()
print("主线程-运行结束,耗时{}秒!".format(round((v_end - v_start), 2)))

5、注意事项

1）直接调用一个使用 async 定义的函数，是不会执行的；
2）协程执行的业务代码一般不会写在主函数中，而是定义个代理主函数；即通过一个协程调用其他协程；

============================================ over ==========================================