asyncio是什么？

news/2025/1/15 21:48:01/

如果把进程比作从A处到B处去这件事，那么线程就是可供选择的多条道路，协程就是道路上特殊路段（类似限速，一整条道路都是特殊路段的话，就是全部由协程实现）
例图如下：
协程

1. 什么是协程（Coroutines）

在了解异步之前，先大致了解一下什么是协程。
网上的讲法有各种：

  • 协程是一种比线程更加轻量级的存在
  • 协程是一种用户级的轻量级线程
  • 协程，又称微线程

大体看过之后就感觉，我好像懂了，有好像没懂，个人感觉有点晕乎乎的，没太明白。（PS:可能是我个人智商没够不能快速领悟的原因）
个人理解（PS：不涉及其本质来源、底层实现、仅仅就着这个异步爬虫来说）：协程就像一条带应急车道的高速公路（具体作用就是让任务有了暂停切换功能）
线程：把需要执行的任务比作汽车，线程就像一条单行且只有一条道的高速公路，只有等前一辆车到达终点后面的车才能出发，如果其中一辆出了事情停在了路上，那么这俩车后面的车就只能原地等待直到它恢复并到达终点才能继续上路。
协程：把需要执行的任务比作汽车，协程就像一条带应急车道的高速公路，如果汽车在中途出了问题就可以直接到一边的应急车道停下处理问题，下一辆车可以直接上路，简单来说就是可以通过程序控制哪辆车行驶，哪辆车在应急车道休息。

2.同步跟异步

同步跟异步是两个相对的概念：
同步：意味着有序
异步：意味着无序
小故事模拟事件：
小明在家需要完成如下事情：

  1. 电饭锅煮饭大约30分钟
  2. 洗衣机洗衣服大约40分钟
  3. 写作业大约50分钟

在同步情况下：小明需要电饭锅处等待30分钟、洗衣机处等待40分钟、写作业50分钟，总计花费时间120分钟。
在异步情况下：小明需要电饭锅处理并启动花费10分钟、洗衣机处理并启动花费10分钟，写作业花费50分钟，总计花费时间70分钟。
即同步必须一件事情结束之后再进行下一件事，异步是可以在一件事情没结束就去处理另外一件事情了。
注意：此处异步比同步耗时更短是有前提条件的！要是I/O阻塞才可以（说人话：类似电饭锅煮饭，电饭锅可以自行完成这种的）

3、asyncio应用场景

  • 在程序在执行 IO 密集型任务的时候，程序会因为等待 IO 而阻塞。
  • 协程遇到io操作而阻塞时，立即切换到别的任务，如果操作完成则进行回调返回执行结果

4、asyncio的一些关键字的说明

  • event_loop 事件循环：程序开启一个无限循环，把一些函数注册到事件循环上，当满足事件发生的时候，调用相应的协程函数
  • coroutine协程：协程对象，指一个使用async关键字定义的函数，它的调用不会立即执行函数，而是会返回一个协程对象。协程对象需要注册到事件循环，由事件循环调用。
  • task 任务：一个协程对象就是一个原生可以挂起的函数，任务则是对协程进一步封装，其中包含了任务的各种状态
  • future: 代表将来执行或没有执行的任务的结果。它和task上没有本质上的区别
  • async/await 关键字：python3.5用于定义协程的关键字，async定义一个协程，await用于挂起阻塞的异步调用接口。

5. asyncio基本使用

5.1、定义协程并创建tasks

  • 在上面带中我们通过async关键字定义一个协程（coroutine）,当然协程不能直接运行，需要将协程加入到事件循环loop中
  • asyncio.get_event_loop：创建一个事件循环，然后使用run_until_complete将协程注册到事件循环，并启动事件循环
  • 协程对象不能直接运行，在注册事件循环的时候，其实是run_until_complete方法将协程包装成为了一个任务（task）对象.
  • task对象是Future类的子类，保存了协程运行后的状态，用于未来获取协程的结果
    定义一个协程并创建tasks:
import asyncio
import time# 我们通过async关键字定义一个协程,当然协程不能直接运行，需要将协程加入到事件循环loop中
async def do_some_work(x):print("waiting:", x)start = time.time()coroutine = do_some_work(2)
loop = asyncio.get_event_loop()        # asyncio.get_event_loop：创建一个事件循环
# 通过loop.create_task(coroutine)创建task,同样的可以通过 asyncio.ensure_future(coroutine)创建task
task = loop.create_task(coroutine)     # 创建任务, 不立即执行
loop.run_until_complete(task)         # 使用run_until_complete将协程注册到事件循环，并启动事件循环
print("Time:",time.time() - start)

5.2、绑定回调

绑定回调，在task执行完成的时候可以获取执行的结果，回调的最后一个参数是future对象，通过该对象可以获取协程返回值。
asyncio绑定回调:

import asyncio
import time# 我们通过async关键字定义一个协程,当然协程不能直接运行，需要将协程加入到事件循环loop中
async def do_some_work(x):print("waiting:", x)return "Done after {}s".format(x)def callback(future):print("callback:",future.result())start = time.time()coroutine = do_some_work(2)
loop = asyncio.get_event_loop()        # asyncio.get_event_loop：创建一个事件循环
# 通过loop.create_task(coroutine)创建task,同样的可以通过 asyncio.ensure_future(coroutine)创建task
task = loop.create_task(coroutine)     # 创建任务, 不立即执行
# task = asyncio.ensure_future(coroutine)
task.add_done_callback(callback)
# 绑定回调，在task执行完成的时候可以获取执行的结果
loop.run_until_complete(task)         # 使用run_until_complete将协程注册到事件循环，并启动事件循环
print("Time:",time.time() - start)''' 运行结果
waiting: 2
callback: Done after 2s
Time: 0.0010030269622802734

5.3、阻塞和await

  • 使用async可以定义协程对象，使用await可以针对耗时的操作进行挂起，就像生成器里的yield一样，函数让出控制权。
  • 协程遇到await，事件循环将会挂起该协程，执行别的协程，直到其他的协程也挂起或者执行完毕，再进行下一个协程的执行
  • 耗时的操作一般是一些IO操作，例如网络请求，文件读取等。
  • 我们使用asyncio.sleep函数来模拟IO操作。协程的目的也是让这些IO操作异步化。
    普通串行花费7秒:
# 普通串行花费7秒
import time
def do_some_work(t):time.sleep(t)print('用了%s秒' % t)start = time.time()
coroutine1 = do_some_work(1)
coroutine2 = do_some_work(2)
coroutine3 = do_some_work(4)
print(time.time()-start)
'''
用了1秒
用了2秒
用了4秒
7.002151012420654
'''

使用协程并发执行只花费4秒:

# 使用协程并发执行只花费4秒
import asyncio
import timeasync def do_some_work(x):print("Waiting:",x)await asyncio.sleep(x)return "Done after {}s".format(x)start = time.time()coroutine1 = do_some_work(1)
coroutine2 = do_some_work(2)
coroutine3 = do_some_work(4)tasks = [asyncio.ensure_future(coroutine1),asyncio.ensure_future(coroutine2),asyncio.ensure_future(coroutine3)
]loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))for task in tasks:print("Task ret:",task.result())print("Time:",time.time() - start)
'''
Waiting: 1
Waiting: 2
Waiting: 4
Task ret: Done after 1s
Task ret: Done after 2s
Task ret: Done after 4s
Time: 4.0038135051727295
'''

5.4、协程嵌套

  • 使用async可以定义协程，协程用于耗时的io操作，我们也可以封装更多的io操作过程
  • 这样就实现了嵌套的协程，即一个协程中await了另外一个协程，如此连接起来。
    1）协程嵌套写法
    协程嵌套 普通写法:
# 1. 使用async可以定义协程，协程用于耗时的io操作，我们也可以封装更多的io操作过程
# 2. 这样就实现了嵌套的协程，即一个协程中await了另外一个协程，如此连接起来。import asyncio
import time
import asyncioasync def do_some_work(x):print("waiting:",x)await asyncio.sleep(x)return "Done after {}s".format(x)async def main():coroutine1 = do_some_work(1)coroutine2 = do_some_work(2)coroutine3 = do_some_work(4)tasks = [asyncio.ensure_future(coroutine1),asyncio.ensure_future(coroutine2),asyncio.ensure_future(coroutine3)]dones, pendings = await asyncio.wait(tasks)for task in dones:print("Task ret:", task.result())# results = await asyncio.gather(*tasks)# for result in results:#     print("Task ret:",result)start = time.time()loop = asyncio.get_event_loop()
loop.run_until_complete(main())
print("Time:", time.time() - start)
'''
waiting: 1
waiting: 2
waiting: 4
Task ret: Done after 1s
Task ret: Done after 2s
Task ret: Done after 4s
Time: 4.003407716751099
'''

2)协程嵌套 使用列表推导式简写:

import time
import asyncioasync def job(t):            # 使用 async 关键字将一个函数定义为协程await asyncio.sleep(t)   # 等待 t 秒, 期间切换执行其他任务print('用了%s秒' % t)async def main(loop):           # 使用 async 关键字将一个函数定义为协程tasks = [loop.create_task(job(t)) for t in range(1,3)]  # 创建任务, 不立即执行await asyncio.wait(tasks)   # 执行并等待所有任务完成start = time.time()
loop = asyncio.get_event_loop()      # 创建一个事件loop
loop.run_until_complete(main(loop))  # 将事件加入到事件循环loop
loop.close()                         # 关闭 loopprint(time.time()-start)
'''
用了1秒
用了2秒
2.0013420581817627
'''

http://www.ppmy.cn/news/1027790.html

相关文章

OPENCV C++(九)鼠标响应+dft+idft

OPENCV C++(九)鼠标响应+dft+idft

鼠标响应回调函数（固定格式） void on_mouse(int EVENT, int x, int y, int flags, void* userdata) {Mat hh;hh *(Mat*)userdata;Point p(x, y);switch (EVENT){case EVENT_LBUTTONDOWN:{points.x x;points.y y;mousePoints.push_back(points);circle…
阅读更多...
Java项目-苍穹外卖-Day03

Java项目-苍穹外卖-Day03

文章目录 员工分页查询功能实现需求分析和设计代码开发pageHelper底层代码完善 启用禁用员工账号功能开发需求分析 员工分页查询功能实现 需求分析和设计 代码开发 先设计类 将对应分页查询的传参类以及结果类进行封装 对应真正返回的为Result<PageResult>Controller…
阅读更多...
spring boot实现实体类参数自定义校验

spring boot实现实体类参数自定义校验

安装依赖项 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-validation</artifactId></dependency>1、新建实体类 Data public class UserEntity {private String name;private Integer age;…
阅读更多...
SAP MM学习笔记20- SAP中的英文1 - 移动Type（Movement Types）

SAP MM学习笔记20- SAP中的英文1 - 移动Type（Movement Types）

SAP中的部分移动类型。 101 : 購買発注入庫 GR goods receipt 102 : 購買発注入庫取消 GR for PO reversal 122 : 仕入返品 RE return to vend 123 : 仕入返品取消 RE rtrn vendor reversal 161 : 仕入返品 GR returns 162 : 仕入返品取消 GR rtrns revers…
阅读更多...
什么是响应式设计？列举几种实现响应式设计的方法。

什么是响应式设计？列举几种实现响应式设计的方法。

聚沙成塔每天进步一点点 ⭐ 专栏简介⭐ 什么是响应式设计&#xff1f;⭐ 实现响应式设计的方法⭐ 写在最后 ⭐ 专栏简介 前端入门之旅&#xff1a;探索Web开发的奇妙世界 记得点击上方或者右侧链接订阅本专栏哦 几何带你启航前端之旅 欢迎来到前端入门之旅&#xff01;这个专栏…
阅读更多...
【ARM 嵌入式 编译系列 3.3 -- gcc 动态库与静态库的链接方法介绍】

【ARM 嵌入式 编译系列 3.3 -- gcc 动态库与静态库的链接方法介绍】

文章目录 1.1 GCC 链接器 LD 介绍1.1.1 GCC 链接器 LD 常用参数介绍1.2 动态库和静态库介绍1.2.1 动态库和静态库优缺点1.2.2 库文件链接方式1.2.3 ldd 工具介绍1.2.4 静态库链接时搜索路径顺序1.2.5 动态库链接时、执行时搜索路径顺序1.2.6 头文件搜索路径1.2.7 有关环境变量上…
阅读更多...
【深度学习注意力机制系列】—— SKNet注意力机制（附pytorch实现）

【深度学习注意力机制系列】—— SKNet注意力机制（附pytorch实现）

SKNet&#xff08;Selective Kernel Network&#xff09;是一种用于图像分类和目标检测任务的深度神经网络架构&#xff0c;其核心创新是引入了选择性的多尺度卷积核&#xff08;Selective Kernel&#xff09;以及一种新颖的注意力机制&#xff0c;从而在不增加网络复杂性的情况…
阅读更多...
提升SQLAlchemy使用效率：查询、关系和事务

提升SQLAlchemy使用效率：查询、关系和事务

在前一篇文章中&#xff0c;我们介绍了如何使用SQLAlchemy进行基础的数据库操作。在这篇文章中&#xff0c;我们将进一步学习如何使用SQLAlchemy进行查询、处理表之间的关系以及管理事务。 一、使用查询语言 SQLAlchemy的查询语言(Query Language)提供了一种易于理解和使用的…
阅读更多...
最新文章

Copyright @ 2022~2023