乐趣区

关于python3.x:运筹帷幄决胜千里Python310原生协程asyncio工业级真实协程异步消费任务调度实践

作者：

jiezi

在

咱们始终都置信这样一种说法：协程是比多线程更高效的一种并发工作形式，它齐全由程序自身所管制，也就是在用户态执行，协程防止了像线程切换那样产生的上下文切换，在性能方面失去了很大的晋升。毫无疑问，这是颠扑不破的业界共识，是放之四海而皆准的真谛。

但事实上，协程远比大多数人设想中的简单，正因为协程的“用户态”个性，任务调度权把握在撰写协程工作的人手里，而仅仅依赖async和await关键字远远达不到“调度”的级别，有时候反而会连累工作效率，使其在工作执行效率上还不迭“零碎态”的多线程和多过程，本次咱们来探讨一下Python3原生协程工作的调度治理。

Python3.10协程库async.io的基本操作

事件循环（Eventloop）是 原生协程库asyncio 的外围，能够了解为总指挥。Eventloop实例提供了注册、勾销和执行工作和回调的办法。

Eventloop能够将一些异步办法绑定到事件循环上，事件循环会循环执行这些办法，然而和多线程一样，同时只能执行一个办法，因为协程也是单线程执行。当执行到某个办法时，如果它遇到了阻塞，事件循环会暂停它的执行去执行其余的办法，与此同时为这个办法注册一个回调事件，当某个办法从阻塞中复原，下次轮询到它的时候将会继续执行，亦或者，当没有轮询到它，它提前从阻塞中复原，也能够通过回调事件进行切换，如此往返，这就是事件循环的简略逻辑。

而下面最外围的动作就是切换别的办法，怎么切换？用await关键字：

import asyncio  
  
  
async def job1():  
    print('job1开始')  
    await asyncio.sleep(1)  
    print('job1完结')  
  
  
async def job2():  
    print('job2开始')  
  
  
async def main():  
    await job1()  
    await job2()  
  
  
if __name__ == '__main__':  
    asyncio.run(main())

零碎返回：

job1开始  
job1完结  
job2开始

是的，切则切了，可切的对吗？事实上这两个协程工作并没有达成“合作”，因为它们是同步执行的，所以并不是在办法内await了，就能够达成协程的工作形式，咱们须要并发启动这两个协程工作：

import asyncio  
  
  
async def job1():  
    print('job1开始')  
    await asyncio.sleep(1)  
    print('job1完结')  
  
  
async def job2():  
    print('job2开始')  
  
  
async def main():  
    #await job1()  
    #await job2()  
    await asyncio.gather(job1(), job2())  
  
  
if __name__ == '__main__':  
    asyncio.run(main())

零碎返回：

job1开始  
job2开始  
job1完结

如果没有asyncio.gather的参加，协程办法就是一般的同步办法，就算用async申明了异步也杯水车薪。而asyncio.gather的根底性能就是将协程工作并发执行，从而达成“合作”。

但事实上，Python3.10也反对“同步写法”的协程办法：

async def create_task():  
    task1 = asyncio.create_task(job1())  
    task2 = asyncio.create_task(job2())  
    await task1  
    await task2

这里咱们通过asyncio.create\_task对job1和job2进行封装，返回的对象再通过await进行调用，由此两个独自的异步办法就都被绑定到同一个Eventloop了，这样尽管写法上同步，但其实是异步执行：

import asyncio  
  
  
async def job1():  
    print('job1开始')  
    await asyncio.sleep(1)  
    print('job1完结')  
  
  
async def job2():  
    print('job2开始')  
  
  
async def create_task():  
    task1 = asyncio.create_task(job1())  
    task2 = asyncio.create_task(job2())  
    await task1  
    await task2  
  
  
async def main():  
    #await job1()  
    #await job2()  
    await asyncio.gather(job1(), job2())  
  
  
if __name__ == '__main__':  
    asyncio.run(create_task())

零碎返回：

job1开始  
job2开始  
job1完结

协程工作的上下游监控

解决了并发执行的问题，当初假如每个异步工作都会返回一个操作后果：

async def job1():  
    print('job1开始')  
    await asyncio.sleep(1)  
    print('job1完结')  
  
    return "job1工作后果"  
  
  
async def job2():  
    print('job2开始')  
  
    return "job2工作后果"

通过asyncio.gather办法，咱们能够收集到工作执行后果：

async def main():  
  
    res = await asyncio.gather(job1(), job2())  
    print(res)

并发执行工作：

import asyncio  
  
  
async def job1():  
    print('job1开始')  
    await asyncio.sleep(1)  
    print('job1完结')  
  
    return "job1工作后果"  
  
  
async def job2():  
    print('job2开始')  
  
    return "job2工作后果"  
  
  
  
async def main():  
  
    res = await asyncio.gather(job1(), job2())  
    print(res)  
  
  
if __name__ == '__main__':  
    asyncio.run(main())

零碎返回：

job1开始  
job2开始  
job1完结  
['job1', 'job2']

但工作后果仅仅也就是办法的返回值，除此之外，并没有其余有价值的信息，对协程工作的执行明细守口如瓶。

当初咱们换成asyncio.wait办法：

async def main():  
  
    res = await asyncio.wait([job1(), job2()])  
    print(res)

仍然并发执行：

import asyncio  
  
  
async def job1():  
    print('job1开始')  
    await asyncio.sleep(1)  
    print('job1完结')  
  
    return "job1工作后果"  
  
  
async def job2():  
    print('job2开始')  
  
    return "job2工作后果"  
  
  
  
async def main():  
  
    res = await asyncio.wait([job1(), job2()])  
    print(res)  
  
  
if __name__ == '__main__':  
    asyncio.run(main())

零碎返回：

job1开始  
job2开始  
job1完结  
({<Task finished name='Task-2' coro=<job1() done, defined at /Users/liuyue/Downloads/upload/test/test_async.py:4> result='job1工作后果'>, <Task finished name='Task-3' coro=<job2() done, defined at /Users/liuyue/Downloads/upload/test/test_async.py:12> result='job2工作后果'>}, set())

能够看出，asyncio.wait返回的是工作对象，外面存储了大部分的工作信息，包含执行状态。

在默认状况下，asyncio.wait会期待全副工作实现 (return\_when=’ALL\_COMPLETED’)，它还反对 return\_when=’FIRST\_COMPLETED’（第一个协程实现就返回）和 return\_when=’FIRST\_EXCEPTION’（呈现第一个异样就返回）。

这就十分令人兴奋了，因为如果异步生产工作是发短信之类的须要统计达到率的工作，利用asyncio.wait个性，咱们就能够第一工夫记录工作实现或者异样的具体工夫。

协程工作守护

假如因为某种原因，咱们手动终止工作生产：

import asyncio  
  
  
async def job1():  
    print('job1开始')  
    await asyncio.sleep(1)  
    print('job1完结')  
  
    return "job1工作后果"  
  
  
async def job2():  
    print('job2开始')  
  
    return "job2工作后果"  
  
  
  
async def main():  
    task1 = asyncio.create_task(job1())  
    task2 = asyncio.create_task(job2())  
    task1.cancel()  
    res = await asyncio.gather(task1, task2)  
    print(res)  
  
  
if __name__ == '__main__':  
    asyncio.run(main())

零碎报错：

File "/Users/liuyue/Downloads/upload/test/test_async.py", line 23, in main  
    res = await asyncio.gather(task1, task2)  
asyncio.exceptions.CancelledError

这里job1被手动勾销，但会影响job2的执行，这违反了协程“相互提携”的个性。

事实上，asyncio.gather办法能够捕捉协程工作的异样：

import asyncio  
  
  
async def job1():  
    print('job1开始')  
    await asyncio.sleep(1)  
    print('job1完结')  
  
    return "job1工作后果"  
  
  
async def job2():  
    print('job2开始')  
  
    return "job2工作后果"  
  
  
  
async def main():  
    task1 = asyncio.create_task(job1())  
    task2 = asyncio.create_task(job2())  
    task1.cancel()  
    res = await asyncio.gather(task1, task2,return_exceptions=True)  
    print(res)  
  
  
if __name__ == '__main__':  
    asyncio.run(main())

零碎返回：

job2开始  
[CancelledError(''), 'job2工作后果']

能够看到job1没有被执行，并且异样代替了工作后果作为返回值。

但如果协程工作启动之后，须要保障工作状况下都不会被勾销，此时能够应用asyncio.shield办法守护协程工作：

import asyncio  
  
  
async def job1():  
    print('job1开始')  
    await asyncio.sleep(1)  
    print('job1完结')  
  
    return "job1工作后果"  
  
  
async def job2():  
    print('job2开始')  
  
    return "job2工作后果"  
  
  
  
async def main():  
    task1 = asyncio.shield(job1())  
    task2 = asyncio.create_task(job2())  
      
    res = await asyncio.gather(task1, task2,return_exceptions=True)  
  
    task1.cancel()  
    print(res)  
  
  
if __name__ == '__main__':  
    asyncio.run(main())

零碎返回：

job1开始  
job2开始  
job1完结  
['job1工作后果', 'job2工作后果']

协程工作回调

假如协程工作执行结束之后，须要立即进行回调操作，比方将工作后果推送到其余接口服务上：

import asyncio  
  
  
async def job1():  
    print('job1开始')  
    await asyncio.sleep(1)  
    print('job1完结')  
  
    return "job1工作后果"  
  
  
async def job2():  
    print('job2开始')  
  
    return "job2工作后果"  
  
  
def callback(future):  
    print(f'回调工作: {future.result()}')  
  
  
  
async def main():  
    task1 = asyncio.shield(job1())  
    task2 = asyncio.create_task(job2())  
  
    task1.add_done_callback(callback)  
      
    res = await asyncio.gather(task1, task2,return_exceptions=True)  
  
    print(res)  
  
  
if __name__ == '__main__':  
    asyncio.run(main())

这里咱们通过add\_done\_callback办法对job1指定了callback办法，当工作执行完当前，callback会被调用，零碎返回：

job1开始  
job2开始  
job1完结  
回调工作: job1工作后果  
['job1工作后果', 'job2工作后果']

与此同时，add\_done\_callback办法不仅能够获取协程工作返回值，它本人也反对参数参数传递：

import asyncio  
from functools import partial  
  
async def job1():  
    print('job1开始')  
    await asyncio.sleep(1)  
    print('job1完结')  
  
    return "job1工作后果"  
  
  
async def job2():  
    print('job2开始')  
  
    return "job2工作后果"  
  
  
def callback(future,num):  
    print(f"回调参数{num}")  
    print(f'回调工作: {future.result()}')  
  
  
  
async def main():  
    task1 = asyncio.shield(job1())  
    task2 = asyncio.create_task(job2())  
  
    task1.add_done_callback(partial(callback,num=1))  
      
    res = await asyncio.gather(task1, task2,return_exceptions=True)  
  
    print(res)  
  
  
if __name__ == '__main__':  
    asyncio.run(main())

零碎返回：

job1开始  
job2开始  
job1完结  
回调参数1  
回调工作: job1工作后果  
['job1工作后果', 'job2工作后果']

结语

成也用户态，败也用户态。所谓水能载舟亦能覆舟，协程生产工作的调度远比多线程的零碎级调度要简单，稍不留神就会造成业务上的“同步”阻塞，画蛇添足，事与愿违。这也解释了为什么类似场景中多线程的出场率要远远高于协程，就是因为多线程不须要思考启动后的“切换”问题，有为而为，简略粗犷。

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章