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

相关文章
|
2月前
|
Java 测试技术 C++
Python Loop详解!
本文详细介绍了Python中的两种循环结构:for循环和while循环。while循环在条件为真时重复执行代码块,for循环则用于遍历序列如列表、元组、字符串和字典。文章通过多个示例展示了循环的基本用法及特点,包括嵌套循环、循环控制语句(如continue、break和pass)及else子句的使用。此外,还探讨了如何优化循环性能,例如使用列表推导式和内置函数。掌握循环是高效Python编程的基础。
56 2
|
4月前
|
存储 Python
Python中的yield到底是个什么鬼?
Python中的yield到底是个什么鬼?
Python中的yield到底是个什么鬼?
|
4月前
|
SQL 机器学习/深度学习 算法
【python】python指南(一):线程Thread
【python】python指南(一):线程Thread
51 0
|
5月前
|
物联网 Java 调度
Python中asyncio模块的实际使用
celery和asyncio写代码都差不多,但asycio用起来更简单,更适用于网络并发请求。如果用于做耗时任务处理也可以,针对如果耗时任务只有一个,明显用celery把耗时任务转到后台处理更为合适。
|
6月前
|
C语言 Python 容器
Python:从头创建 Asyncio (1)
Python:从头创建 Asyncio (1)
36 2
Python:从头创建 Asyncio (1)
|
6月前
|
API Python
Python:从头创建 Asyncio (2)
Python:从头创建 Asyncio (2)
40 0
|
Python 容器
Python之yield详解
Python之yield详解
101 0
|
算法 机器人 Java
Python asyncio之协程学习总结 1
Python asyncio之协程学习总结
138 0
|
存储 安全 API
Python asyncio之协程学习总结 2
Python asyncio之协程学习总结
127 0
|
编译器 Python
Python的__future__是什么
Python的__future__是什么
106 0