python 异步 async/await -1.一文理解什么是协程

python 异步 async/await -1.一文理解什么是协程

前言

Python 在 3.5 版本中引入了关于协程的语法糖 async 和 await, 在 python3.7 版本可以通过 asyncio.run() 运行一个协程。

所以建议大家学习协程的时候使用 python3.7+ 版本，本文示例代码在 python3.8 上运行的。

什么是协程？

网上有个关于洗衣机的例子，写的挺好的，借用下

假设有1个洗衣房，里面有10台洗衣机，有一个洗衣工在负责这10台洗衣机。那么洗衣房就相当于1个进程，洗衣工就相当1个线程。如果有10个洗衣工，就相当于10个线程，1个进程是可以开多线程的。这就是多线程！**那么协程呢？**先不急。大家都知道，洗衣机洗衣服是需要等待时间的，如果10个洗衣工，1人负责1台洗衣机，这样效率肯定会提高，但是不觉得浪费资源吗？明明1 个人能做的事，却要10个人来做。只是把衣服放进去，打开开关，就没事做了，等衣服洗好再拿出来就可以了。就算很多人来洗衣服，1个人也足以应付了，开好第一台洗衣机，在等待的时候去开第二台洗衣机，再开第三台，……直到有衣服洗好了，就回来把衣服取出来，接着再取另一台的（哪台洗好先就取哪台，所以协程是无序的）。这就是计算机的协程！洗衣机就是执行的方法。”

协程，又称微线程。

协程的作用是在执行函数A时可以随时中断去执行函数B，然后中断函数B继续执行函数A（可以自由切换）。

但这一过程并不是函数调用，这一整个过程看似像多线程，然而协程只有一个线程执行。

协程很适合处理IO密集型程序的效率问题。协程的本质是个单线程，它不能同时将 单个CPU 的多个核用上,因此对于CPU密集型程序协程需要和多进程配合。

** 进程与线程 **

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。线程（thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。一个进程可以有很多线程，每条线程并行执行不同的任务。

洗衣机例子

假设有3台洗衣机在工作，每个洗衣机工作的时长不一样

import timedef washing1(): time.sleep(3) # 第一台洗衣机, print('washer1 finished') # 洗完了def washing2(): time.sleep(8) print('washer2 finished')def washing3(): time.sleep(5) print('washer3 finished')if __name__ == '__main__': start_time = time.time() washing1() washing2() washing3() end_time = time.time() print('总共耗时：{}'.format(end_time-start_time))

我们通过函数的方式调用，3个函数，总共耗时16 秒！

这里函数的执行方式是同步运行的，于是这里需要知道一个概念：

** 同步/异步 **

同步：在发出一个同步调用时，在没有得到结果之前，该调用就不返回。异步：在发出一个异步调用后，调用者不会立刻得到结果，该调用就返回了。

再举个小学生在学校学习的一个案例：

小明同学的妈妈给他早上安排了三件事：

1.洗衣机洗衣服需要花 15 分钟，

2.电饭煲做饭需要花 20 分钟，

3.做作业需要花 25 分钟

那么请问：小明同学早上完成以上三件事需要花多久？？?

这个大家肯定都知道是25分钟，因为在做作业的时候，可以先按下洗衣机和电饭煲的按钮，不用等它完成，洗衣机和电饭煲做好了会发出‘滴滴滴’的声音通知你。

所以这三件事是可以异步完成的，这就是异步的魅力！

协程（异步）

这里我们需要学一个新的语法糖 ​​async​​, 例如，以下代码段（需要 Python 3.7+)

import timeasync def washing1(): time.sleep(3) # 第一台洗衣机, print('washer1 finished') # 洗完了async def washing2(): time.sleep(8) print('washer2 finished')async def washing3(): time.sleep(5) print('washer3 finished')if __name__ == '__main__': start_time = time.time() washing1() washing2() washing3() end_time = time.time() print('总共耗时：{}'.format(end_time-start_time))

如果我们直接当函数运行,会出现警告，并且并没有只需函数里面的print内容

untimeWarning: coroutine 'washing1' was never awaited washing1()RuntimeWarning: Enable tracemalloc to get the object allocation traceback

先看下​​async​​ 定义的异步函数到底返回的是什么

import timeasync def fun(): time.sleep(3) # 第一台洗衣机, print('washer1 finished') # 洗完了 res = fun()print(res) #

返回的是​​coroutine object​​ 也就是协程对象，并没直接执行

执行协程 coroutine 函数

执行协程函数，必须使用事件循环​​get_event_loop()​​。

import timeimport asyncioasync def fun(): time.sleep(3) # 第一台洗衣机, print('washer1 finished') # 洗完了coroutine_1 = fun() # 协程是一个对象，不能直接运行loop = asyncio.get_event_loop() # 创建一个事件循环result = loop.run_until_complete(coroutine_1) # 将协程对象加入到事件循环中，并执行

在python3.7+以后的版本，可以直接​​asyncio.run()​​去执行一个协程函数

import timeimport asyncioasync def fun(): time.sleep(3) # 第一台洗衣机, print('washer1 finished') # 洗完了coroutine_1 = fun() # 协程是一个对象，不能直接运行asyncio.run(coroutine_1)

多个任务执行 asyncio.create_task()

当我们需要3台洗衣机一起来工作，这时候需要创建多个任务，也就是会用到​​asyncio.create_task()​​

import timeimport asyncioasync def washing1(): time.sleep(3) # 第一台洗衣机, print('washer1 finished') # 洗完了async def washing2(): time.sleep(8) print('washer2 finished')async def washing3(): time.sleep(5) print('washer3 finished')async def main(): print('start main:') start_time = time.time() task1 = asyncio.create_task(washing1()) task2 = asyncio.create_task(washing2()) task3 = asyncio.create_task(washing3()) await task1 await task2 await task3 end_time = time.time() print('-----------end main----------') print('总共耗时:{}'.format(end_time-start_time))if __name__ == '__main__': # asyncio.run(main()) loop = asyncio.get_event_loop() # 创建一个事件循环 result = loop.run_until_complete(main()) # 将协程对象加入到事件循环中，并执行

运行结果：

start main:washer1 finishedwasher2 finishedwasher3 finished-----------end main----------总共耗时:16.000632286071777

我们发现运行的总耗时还是16秒，并没有达到我们想要的结果，最大耗时8秒，这个问题稍后再讲，先解决如果有很多个任务，那我们总不会一直写

task1 = asyncio.create_task(washing1()) task2 = asyncio.create_task(washing2()) task3 = asyncio.create_task(washing3()) await task1 await task2 await task3

这里可以优化下

import timeimport asyncioasync def washing1(): time.sleep(3) # 第一台洗衣机, print('washer1 finished') # 洗完了async def washing2(): time.sleep(8) print('washer2 finished')async def washing3(): time.sleep(5) print('washer3 finished')if __name__ == '__main__': print('start main:') start_time = time.time() # step1 创建一个事件循环 loop = asyncio.get_event_loop() # step2 将异步函数（协程）加入事件队列 tasks = [ washing1(), washing2(), washing3() ] # step3 执行事件队列 直到最晚的一个事件被处理完毕后结束 loop.run_until_complete(asyncio.wait(tasks)) end_time = time.time() print('-----------end main----------') print('总共耗时:{}'.format(end_time-start_time))

优化后，运行结果

start main:washer3 finishedwasher1 finishedwasher2 finished-----------end main----------总共耗时:16.00227665901184

await 使用

上面虽然异步执行了三个任务，但是时间并没减少，主要是因为 ​​time.sleep()​​ 是阻塞的，需换成异步的

import timeimport asyncioasync def washing1(): await asyncio.sleep(3) # 第一台洗衣机, print('washer1 finished') # 洗完了async def washing2(): await asyncio.sleep(8) print('washer2 finished')async def washing3(): await asyncio.sleep(5) print('washer3 finished')if __name__ == '__main__': print('start main:') start_time = time.time() # step1 创建一个事件循环 loop = asyncio.get_event_loop() # step2 将异步函数（协程）加入事件队列 tasks = [ washing1(), washing2(), washing3() ] # step3 执行事件队列 直到最晚的一个事件被处理完毕后结束 loop.run_until_complete(asyncio.wait(tasks)) end_time = time.time() print('-----------end main----------') print('总共耗时:{}'.format(end_time-start_time))

这样就可以达到我们的预期，总共耗时是8秒了

start main:washer1 finishedwasher3 finishedwasher2 finished-----------end main----------总共耗时:8.002010822296143

接着我们在看下 await 如何使用, 当我们直接 ​​await time.sleep(3)​​ 时

import timeimport asyncioasync def washing1(): await time.sleep(3) # 第一台洗衣机, print('washer1 finished') # 洗完了coroutine_1 = washing1() # 协程是一个对象，不能直接运行loop = asyncio.get_event_loop() # 创建一个事件循环result = loop.run_until_complete(coroutine_1) # 将协程对象加入到事件循环中，并执行

运行会报错:TypeError: object NoneType can't be used in 'await' expression

Traceback (most recent call last): File "D:/demo/a6.py", line 11, in result = loop.run_until_complete(coroutine_1) # 将协程对象加入到事件循环中，并执行 File "D:\python3.8\lib\asyncio\base_events.py", line 616, in run_until_complete return future.result() File "D:/demo/a6.py", line 6, in washing1 await time.sleep(3) # 第一台洗衣机,TypeError: object NoneType can't be used in 'await' expression

因为 ​​await​​ 后面必须要是一个可等待对象

await + 可等待对象（协程对象，Future，Task对象（IO等待））等待到对象的返回结果，才会继续执行后续代码

可等待对象 await 的使用

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

可等待 对象有三种主要类型: 协程, 任务 和 Future .

协程：python中的协程属于 可等待 对象，所以可以在其他协程中被等待

接着我们再把洗衣机工作的场景分2个步骤实现，第一个步骤是放衣服，第二个步骤是洗衣机工作

import timeimport asyncioasync def add_clothes(): print('往洗衣机添加衣服....') await asyncio.sleep(2) # 模拟这个任务耗时2秒async def washing1(): print('洗衣机工作之前，需加衣服进去') await add_clothes() # 等待这个事情完成 print('衣服加进去，可以开始工作了。。。。') await asyncio.sleep(3) # 模拟洗衣机工作的耗时 print('washer1 finished') # 洗完了print('start washing:')start_time = time.time()coroutine_1 = washing1() # 协程是一个对象，不能直接运行loop = asyncio.get_event_loop() # 创建一个事件循环result = loop.run_until_complete(coroutine_1) # 将协程对象加入到事件循环中，并执行end_time = time.time()print('-----------end washing----------')print('总共耗时:{}'.format(end_time-start_time))

运行结果

start washing:洗衣机工作之前，需加衣服进去往洗衣机添加衣服....衣服加进去，可以开始工作了。。。。washer1 finished-----------end washing----------总共耗时:5.001740217208862

往洗衣机加衣服和洗衣机工作这2个事情，它是需要等第一件事完成才能执行，所以这2个任务是需要等待完成才能做下一步的。

2个洗衣机工作，是互不影响的，所以不需要等第一个洗衣机工作完成，2个洗衣机工作的任务是异步的。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。