Python asyncio 异步IO的理解
2021/7/30 20:37:34
本文主要是介绍Python asyncio 异步IO的理解,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!
1、理解概念
asyncio 是用来编写并发代码的库,使用 async/await 语法。
(1)何为并发:
并发就是在一个时间段内,同时做多个事情。
比如在单CPU的机器中(只有一个CPU的机器),我们可以一边听歌,一边斗地主,一边聊QQ。
在我们看来,我们是同时在做这三件事,可是在单CPU中,这并不是同时进行的。
单CPU把自己分成了一段一段的时间片,每个时间片用来做一个事情。
如果该时间片用光了,但是事件还没有做完,那就先不做了。CPU先去做其他的,做完其他的事情,再利用新的时间片,来接着做这个事情。
因为时间片之间的切换速度是很快的,用户根本体验不出来,所以就感觉是同时在做这些事情。
以上就可以理解为并发。
(2)何为并行
基本上提到了并发,总有人要问什么是并行,以及并行与并发的区别。
并行就是同一时间点,同时做多个事情。听起来和并发差不多,但是还是有区别的,看完下面的解释就容易理解了。
并行在单CPU中是不可能存在的,因为并行是真真实实存在的。而并发是宏观上存在的,
比如在多CPU的机器中(有多个CPU的机器,与单CPU对立),我们可以一边听歌,一边斗地主,一边聊QQ。
在我们看来,我们是同时在做这三件事,在多CPU中,其实也是同时在做这三个事情
一个CPU负责听歌的进程,一个CPU负责斗地主的进程,一个CPU负责QQ的进程。
在物理时间上,CPU真的就是在同时做这三个事情,只是每个事件用的CPU不同而已。
以上可以理解为并行。
备注:我这里所说的多CPU,一个CPU负责一个进程,其实也可以理解为一个CPU有多个核,一个核负责一个进程,这样也是说的通的。
因为我对多CPU以及多核CPU还没有理解清楚,所以上面的举例就用了多CPU。本文主要是记录自己的理解,所以难免有不懂的地方。请包涵。
(3)并发与并行的共同点与区别
共同点:
我们可以理解并发与并行都是同一个时间,做多个事情,执行多个程序。
不同点:
并发是在宏观上存在的,是在逻辑上存在的,理解了(1),应该就能理解这句话了。这也是为什么用单CPU举例的意义所在。
并行是在物理上存在的,是真实存在的。理解了(2),应该就能理解这句话了。
单核CPU是不可能存在并行的。
单CPU中进程只能是并发,多CPU计算机中进程可以并行。
单CPU单核中线程只能并发,单CPU多核中线程可以并行。
(4)并发与并行学习链接
https://cloud.tencent.com/developer/article/1424249 图形并茂的,助于理解!
https://laike9m.com/blog/huan-zai-yi-huo-bing-fa-he-bing-xing,61/ 义正言辞的!
https://sunweiguo.github.io/2019/11/17/miscellany/20%E5%85%B3%E4%BA%8E%E5%A4%9ACPU%E5%92%8C%E5%A4%9A%E6%A0%B8CPU%E7%9A%84%E5%8C%BA%E5%88%AB/ CPU知识点!
(5)协程理解
一般实现并发的方式就是使用多进程,多线程。这里加入一个协程概念,协程也可以实现并发。
asyncio就是通过协程,实现的并发。与本文第一句相互呼应,嘿嘿!
我们编写程序,正常执行是串行的,即从上而下依次执行。
比如定义一个函数,执行函数就是从函数的第一行,依次执行第二行,再执行第三行......最后执行最后一行,然后结束函数的执行。
协程就是执行一个函数,到某一行,然后转去执行其他函数,执行其他函数到某一行,又去执行了其他函数,最后在合适的时间点,又转回来执行最初的函数
在合适的时间点,指的是其他函数运行结束,或者其他函数主动释放CPU。
比如某个函数中有sleep操作,这个时间,等待睡眠是浪费CPU的,这个时候可以跳出该函数,转去执行其他函数,当其他函数执行完,再接着执行这个sleep的后一句
以上就是个人理解协程,比较空洞,结合下面的代码,就能容易理解一点了。
2、使用async关键字定义协程
def function(name): print('这是正常的函数,name:{}'.format(name)) async def coroutines_function(name): print('这是协程函数,name:{}'.format(name)) if __name__ == '__main__': function('hello') # 正常执行 coroutines_function('hello') # 报错 coroutine 'coroutines_function' was never awaited
3、通过asyncio运行协程(开始了asycnio的使用)
协程对象不能直接运行,需要添加到事件循环中,在合适的时间点,事件循环自动运行
合适的时间点指的是CPU分配时间片给他,其他程序不占用CPU
import asyncio # 导入异步io库 async def coroutines_function(name): print('这是协程函数,name:{}'.format(name)) if __name__ == '__main__': obj = coroutines_function('墨玉麒麟') # 返回协程对象 print(type(obj)) # <class 'coroutine'> loop = asyncio.get_event_loop() # 获取事件循环 loop.run_until_complete(obj) # 注册到事件循环中 loop.close() # 关闭事件循环
运行
4、创建task对象
上面3中的示例代码 loop.run_until_complete(obj)
传入的参数是一个协程对象,传入后协程对象会被包装成task对象,这样运行的就是task对象,而不是协程对象
可以这么写,创建一个task对象,然后传给run_until_complete函数
import asyncio # 导入异步io库 async def coroutines_function(name): print('这是协程函数,name:{}'.format(name)) if __name__ == '__main__': obj = coroutines_function('墨玉麒麟') # 返回协程对象 print(type(obj)) # <class 'coroutine'> loop = asyncio.get_event_loop() # 获取事件循环 task = loop.create_task(obj) # 创建task print(type(task)) # <class '_asyncio.Task'> loop.run_until_complete(task) # 注册到事件循环中 loop.close() # 关闭事件循环
运行
5、task对象的状态
task对象被创建出来时,不会被执行,这时候状态是pending
之后被添加到事件循环中,等待执行
执行结束后状态为finished
import asyncio # 导入异步io库 async def coroutines_function(name): print('这是协程函数,name:{}'.format(name)) if __name__ == '__main__': obj = coroutines_function('墨玉麒麟') # 返回协程对象 print(type(obj)) # <class 'coroutine'> loop = asyncio.get_event_loop() # 获取事件循环 task = loop.create_task(obj) # 创建task print(type(task)) # <class '_asyncio.Task'> print(task) # <Task pending coro=<coroutines_function() loop.run_until_complete(task) # 注册到事件循环中 print(task) # <Task finished coro=<coroutines_function() done loop.close() # 关闭事件循环
运行
6、回调函数
可以为task对象添加一个回调函数,执行完task后,自动执行绑定的回调函数
import asyncio # 导入异步io库 async def coroutines_function(name): print('这是协程函数,name:{}'.format(name)) def callback(function): print('协程函数本身:{}'.format(function)) print('回调函数完成 ---> coroutines_function') if __name__ == '__main__': obj = coroutines_function('墨玉麒麟') # 返回协程对象 loop = asyncio.get_event_loop() # 获取事件循环 task = loop.create_task(obj) # 创建task task.add_done_callback(callback) loop.run_until_complete(task) # 注册到事件循环中 loop.close() # 关闭事件循环
运行
7、获取协程函数的返回值
只有当协程函数执行完毕,状态为finished时,才可以获取返回值,提前获取报错
import asyncio # 导入异步io库 async def coroutines_function(name): print('这是协程函数,name:{}'.format(name)) return 'coroutines_function-->{}'.format(name) def callback(function): print('协程函数本身:{}'.format(function)) print('回调函数完成 ---> coroutines_function') if __name__ == '__main__': obj = coroutines_function('墨玉麒麟') # 返回协程对象 loop = asyncio.get_event_loop() # 获取事件循环 task = loop.create_task(obj) # 创建task # print(task.result()) # 报错 Result is not set. task.add_done_callback(callback) loop.run_until_complete(task) # 注册到事件循环中 print('task result:{}'.format(task.result())) # coroutines_function-->墨玉麒麟 loop.close() # 关闭事件循环
运行
8、await让出CPU控制器
以上的例子都不能演示并发的情景,因为以上的例子没有用到await关键字
我们可以通过使用await关键字,来让出CPU的控制器,去执行其他函数的语句,从而实现并发机制
当事件循环看到await关键字时,事件循环会挂起该协程,从而去执行其他协程。其他协程挂起时,或者其他协程执行完毕,事件循环再继续执行最初的协程
(1)举个睡眠的例子
import asyncio # 导入异步io库 import time async def sleep_second(second): print('将要睡眠{}秒'.format(second)) await asyncio.sleep(second) print('睡眠{}秒完成,醒过来了'.format(second)) return '休息了{}秒'.format(second) if __name__ == '__main__': start = time.time() obj1 = sleep_second(5) # 返回协程对象 obj3 = sleep_second(3) # 返回协程对象 obj5 = sleep_second(1) # 返回协程对象 loop = asyncio.get_event_loop() # 获取事件循环 task1 = loop.create_task(obj1) # 创建task task3 = loop.create_task(obj3) # 创建task task5 = loop.create_task(obj5) # 创建task loop.run_until_complete(task1) # 注册到事件循环中 loop.run_until_complete(task3) # 注册到事件循环中 loop.run_until_complete(task5) # 注册到事件循环中 loop.close() # 关闭事件循环 end = time.time() print('耗时:{}'.format(end - start))
运行
可以看出,当运行到睡眠5秒的时候,程序并没有等待,而是去运行睡眠3秒,再去运行睡眠1秒,最后1秒先执行完毕,先返回,再是睡眠3秒返回,再是睡眠5秒返回
用时是5秒,而不是5 + 3 + 1 = 9 秒
备注 await后面需要跟协程函数,而不能是普通函数,这里不能用time.sleep()代替asyncio.sleep(),用了会报错,可以自己换了尝试一下看看
(2)演示协程嵌套
import asyncio # 导入异步io库 import time async def fun1(name): print('fun1 name begin:{}'.format(name)) print('fun1 name end:{}'.format(name)) async def fun2(name): print('fun2 name begin:{}'.format(name)) await fun1('墨玉麒麟') print('fun2 name end:{}'.format(name)) async def fun3(name): print('fun3 name begin:{}'.format(name)) await fun2('张龙赵虎') print('fun3 name end:{}'.format(name)) if __name__ == '__main__': start = time.time() obj3 = fun3('神龙吸水') # 返回协程对象 loop = asyncio.get_event_loop() # 获取事件循环 task3 = loop.create_task(obj3) # 创建task loop.run_until_complete(task3) # 注册到事件循环中 loop.close() # 关闭事件循环 end = time.time() print('耗时:{}'.format(end - start))
运行
备注:实际项目中,一般asyncio.sleep()都是用其他协程的库来代替,比如aiohttp、 aiomysq等
学习链接: https://www.jianshu.com/p/b5e347b3a17c
这篇关于Python asyncio 异步IO的理解的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!
- 2024-11-14获取参数学习:Python编程入门教程
- 2024-11-14Python编程基础入门
- 2024-11-14Python编程入门指南
- 2024-11-13Python基础教程
- 2024-11-12Python编程基础指南
- 2024-11-12Python基础编程教程
- 2024-11-08Python编程基础与实践示例
- 2024-11-07Python编程基础指南
- 2024-11-06Python编程基础入门指南
- 2024-11-06怎么使用python 计算两个GPS的距离功能-icode9专业技术文章分享