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 也就是协程对象,并没直接执行

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

你可能感兴趣的:(Python,python)