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 time


def 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分钟，因为在做作业的时候，可以先按下洗衣机和电饭煲的按钮，不用等它完成，洗衣机和电饭煲做好了会发出‘滴滴滴’的声音通知你。

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

协程（异步）

协程（coroutines）通过 async/await 语法进行声明，是编写 asyncio 应用的推荐方式。

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

import time


async 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 time


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


res = fun()
print(res) # <coroutine object fun at 0x000001FA1882B9C0>

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

执行协程 coroutine 函数

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

import time
import asyncio


async 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 time
import asyncio


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


coroutine_1 = fun() # 协程是一个对象，不能直接运行
asyncio.run(coroutine_1)

多个任务执行 asyncio.create_task()

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

import time
import asyncio


async 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 finished
washer2 finished
washer3 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 time
import asyncio


async 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 finished
washer1 finished
washer2 finished
-----------end main----------
总共耗时:16.00227665901184

await 使用

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

import time
import asyncio


async 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 finished
washer3 finished
washer2 finished
-----------end main----------
总共耗时:8.002010822296143

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

import time
import asyncio


async 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 <module>
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 time
import asyncio


async 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个洗衣机工作的任务是异步的。