Asyncio---Python牛不牛就靠你了

简介: Asyncio---Python牛不牛就靠你了

之前在看gevent的时候不小心又看到了这个模块,gevent其实并不是python官方的标准库,有一些缺陷,所以这个时候Asyncio出现了。

这是官网也非常推荐的一个实现高并发的一个模块。在python3.6中已经稳定支持了。

640.jpg

首先要做的事情:

Asyncio是干嘛的?

异步,并发,协程

CPU 的执行是顺序的,线程是操作系统提供的一种机制,允许我们在操作系统的层面上实现“并行”。而协程则可以认为是应用程序提供的一种机制(用户或库来完成),允许我们在应用程序的层面上实现“并行”。

由于本质上程序是顺序执行的,要实现这种“并行”的假像,我们需要一种机制,来“暂停”当前的执行流,并在之后“恢复”之前的执行流。这在操作系统及多线程/多进程中称为“上下文切换” (context switch)。其中“上下文”记录了某个线程执行的状态,包括线程里用到的各个变量,线程的调用栈等。而“切换”指的就是保存某个线程当前的运行状态,之后再从之前的状态中恢复。只不过线程相关的工作是由操作系统完成,而协程则是由应用程序自己来完成。


关于asyncio,有很多的模块支持,如图(一部分):

640.jpg

详情可参考:

https://github.com/aio-libs

下面来介绍一下Asyncio里面可等待的对象(可等待的对象的意思就是可以在await方法中进行使用)一共分为以下三种:

coroutine (协程):

协程对象,指一个使用async关键字定义的函数,它的调用不会立即执行函数,而是会返回一个协程对象。协程对象需要注册到事件循环,由事件循环调用。

task (任务):

用来设置日程,以便并发执行协程,是对协程进一步封装,其中包含了任务的各种状态。

future(最终结果):

是一种特殊的 低层级 可等待对象,表示一个异步操作的最终结果。



Coroutine

关于协程,一般通过async/await方法进行声明定义,来看一个最基本的例子,在hello输出1秒后输出world。

import asyncio
async def main():
    print('hello')
    await asyncio.sleep(1)
    print('world')

以上就是定义一个简单的协程方法,定义好来就可以运行,关于运行,我们有三种方法可以调用(代表三种不同的运行机制),他们分别是:run,await,create_task


Run函数

asyncio.run(coro, *, debug=False)

run函数运行传入的协程,负责管理 asyncio 事件循环并完结异步生成器。

当有其他 asyncio 事件循环在同一线程中运行时,run函数不能被调用。

如果 debug 为 True,事件循环将以调试模式运行。

run函数总是会创建一个新的事件循环并在结束时关闭。它应当被用作 asyncio 程序的主入口点,理想情况下应当只被调用一次。也就是说,run函数里面的第一个参数应该是main函数。


Create_task函数

asyncio.create_task(coro)

将 coro 协程打包成一个 Task排入日程准备执行。返回 一个Task 对象。

该任务会在 get_running_loop() 返回的循环中执行,如果当前线程没有在运行的循环则会引发 RuntimeError。

await

await用于挂起阻塞的异步调用接口。

await可以针对耗时的操作进行挂起,就像生成器里的yield一样,函数让出控制权。协程遇到await,事件循环将会挂起该协程,执行别的协程,直到其他的协程也挂起或者执行完毕,再进行下一个协程的执行。

async def do_some_work(x):
    print("waiting:",x)
    # await 后面就是调用耗时的操作
    await asyncio.sleep(x)
    return "Done after {}s".format(x)


Future

Future 是一种特殊的可等待对象,表示一个异步操作的最终结果。

当一个 Future 对象 被等待,这意味着协程将保持等待直到该 Future 对象在其他地方操作完毕。

在 asyncio 中需要 Future 对象以便允许通过 async/await 使用基于回调的代码。

通常情况是不需要创建Future的代码的。
future会在api中用到,用户可在api中查看。

async def main():
    await function_that_returns_a_future_object()
    # this is also valid:
    await asyncio.gather(
        function_that_returns_a_future_object(),
        some_python_coroutine()
    )

Task

协程对象不能直接运行,在注册事件循环的时候,其实是run_until_complete方法将协程包装成为了一个任务(task)对象. task对象是Future类的子类,保存了协程运行后的状态,用于未来获取协程的结果。

task和future类似,可以运行协程。

Task 对象被用来在事件循环中运行协程。如果一个协程在等待一个 Future 对象,Task 对象会挂起该协程的执行并等待该 Future 对象完成。当该 Future 对象 完成,被打包的协程将恢复执行。

运行机制:一个事件循环每次运行一个 Task 对象。一个 Task 对象会等待一个 Future 对象完成,该事件循环会运行其他 Task、回调或执行 IO 操作。

创建Task:

import asyncio
import time
now = lambda: time.time()
async def do_some_work(x):
    print("waiting:", x)
start = now()
coroutine = do_some_work(2)
loop = asyncio.get_event_loop()
task = loop.create_task(coroutine)
print(task)
loop.run_until_complete(task)
print(task)
print("Time:",now()-start)



关于阻塞

使用async可以定义协程对象,使用await可以针对耗时的操作进行挂起,就像生成器里的yield一样,函数让出控制权。协程遇到await,事件循环将会挂起该协程,执行别的协程,直到其他的协程也挂起或者执行完毕,再进行下一个协程的执行

耗时的操作一般是一些IO操作,例如网络请求,文件读取等。我们使用asyncio.sleep函数来模拟IO操作。协程的目的也是让这些IO操作异步化。

import asyncio
import time
now = lambda :time.time()
async def do_some_work(x):
    print("waiting:",x)
    # await 后面就是调用耗时的操作
    await asyncio.sleep(x)
    return "Done after {}s".format(x)
start = now()
coroutine = do_some_work(2)
loop = asyncio.get_event_loop()
task = asyncio.ensure_future(coroutine)
loop.run_until_complete(task)
print("Task ret:", task.result())
print("Time:", now() - start)

代码里的sleep,模拟了阻塞或者耗时操作,这个时候就会让出控制权。 即当遇到阻塞调用的函数的时候,使用await方法将协程的控制权让出,以便loop调用其他的协程。


关于并发

简而言之就是有多个任务需要同时进行,这个时候就相当于我在同一时刻需要完成多个任务。可以看看下面这个例子:

import asyncio
import time
now = lambda :time.time()
# 定义协程方法
async def do_work(x):
    print("Waiting:",x)
    await asyncio.sleep(x)
    return "Done after {}s".format(x)
start = now()
# 实例协程
coroutine1 = do_work(1)
coroutine2 = do_work(2)
coroutine3 = do_work(4)
# 协程的最终结果
tasks = [
    asyncio.ensure_future(coroutine1),
    asyncio.ensure_future(coroutine2),
    asyncio.ensure_future(coroutine3)
]
# 最先调用get_event_loop,开启协程的入口
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
for task in tasks:
    print("Task ret:",task.result())
# 耗时
print("Use Time:",now()-start)

运行代码,我们可以看到运行的结果大概在4点几秒,小于七秒,如果是同步执行,我的最终耗时至少为1+2+4=7s,如果使用异步并发,总耗时接近在4s,4s的阻塞时间,足够前面两个协程执行完毕。这就是协程的并发使用。



关于协程还有很多的知识点,在这里只是管中窥豹,如果想要了解更多的内容,可以访问:

https://docs.python.org/zh-cn/3/library/asyncio-task.html#asyncio.gather

相关文章
|
3月前
|
物联网 Java 调度
Python中asyncio模块的实际使用
celery和asyncio写代码都差不多,但asycio用起来更简单,更适用于网络并发请求。如果用于做耗时任务处理也可以,针对如果耗时任务只有一个,明显用celery把耗时任务转到后台处理更为合适。
|
4月前
|
C语言 Python 容器
Python:从头创建 Asyncio (1)
Python:从头创建 Asyncio (1)
26 2
Python:从头创建 Asyncio (1)
|
3月前
|
调度 开发者 Python
什么是Python asyncio
**Python的asyncio库概述** asyncio是Python的异步I/O框架,基于协程,提供了一种编写并发代码的简洁方式。它引入了`async`和`await`关键字,用于定义和执行异步操作,简化了IO密集型任务的并发处理。事件循环是核心,负责调度协程任务。asyncio解决了传统多线程/多进程并发的复杂性和效率问题,尤其适合结构化的网络编程。例如,通过并发下载多个网站,asyncio能提高效率,对比之下,使用`threading`模块则更为低效。简而言之,asyncio是Python高效异步编程的标准工具。
|
4月前
|
API Python
Python:从头创建 Asyncio (2)
Python:从头创建 Asyncio (2)
29 0
|
3月前
|
调度 开发者 Python
Python asyncio是什么?
**Python的asyncio库简介** asyncio是Python的异步I/O框架,基于协程,用以编写并发代码。它引入了`async`和`await`关键字,简化了异步编程,避免回调地狱。核心是事件循环,管理并调度异步任务。asyncio旨在解决Python 3.4之前的并发问题,如多线程和多进程的复杂性和低效。通过asyncio,开发者可以更高效地处理IO密集型任务,如并发下载多个网站内容。例如,使用`asyncio.gather`并发等待所有网络请求,相比`threading`模块,代码更简洁,执行更高效。
|
4月前
|
JSON 语音技术 数据格式
python---aiohttp的使用详细剖析
python---aiohttp的使用详细剖析
57 0
|
4月前
|
Python
Python yield与实现教程分享
Python yield与实现教程分享
28 0
|
5月前
|
安全 Python Windows
Python 的并发编程:在 Python 中如何使用 `threading` 和 `multiprocessing` 模块?
Python 的并发编程:在 Python 中如何使用 `threading` 和 `multiprocessing` 模块?
67 1
|
5月前
|
Python
Python3 asyncio
Python3 asyncio
38 0
|
API Python
Gevent----非官方的python协程库
Gevent----非官方的python协程库
92 0
下一篇
无影云桌面