专栏首页Python乱炖Asyncio---Python牛不牛就靠你了

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

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

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

首先要做的事情:

Asyncio是干嘛的?

异步,并发,协程

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

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

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

详情可参考:

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

本文分享自微信公众号 - Python乱炖(Cooking_python),作者:我被狗咬了

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-04-01

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 数据分析高级教程(二)

    该项目的数据分析过程在hadoop集群上实现,主要应用hive数据仓库工具,因此,采集并经过预处理后的数据,需要加载到hive数据仓库中,以进行后续的挖掘分析。

    我被狗咬了
  • Msgpack有没有兴趣了解一下?

    在我们做开发的时候经常会考虑到客户端服务器通信到问题,简单的来说就是客户端首发数据的问题。

    我被狗咬了
  • MachineLearning ----KNN

    今天呢,我们就要来接触稍微高级一点的东西了,我们所做的事情不仅仅局限于代码的层面上了,要基于某种算法解决问题,而此时的python则是我们完成问题的工具啦!

    我被狗咬了
  • Python与协程从Python2—Python3

    协程,又称微线程、纤程,英文名Coroutine;用一句话说明什么是线程的话:协程是一种用户态的轻量级线程。

    嘉为科技
  • Python-并发下载-gevent库

    协程,就是同时开启多个任务,但一次只顺序执行一个。等到所执行的任务遭到阻塞,就切换到下一个任务继续执行,从而节省阻塞所占用的时间。

    小团子
  • 微信phxrpc源码分析(三)-phxrpc协程与Tars协程对比

    在TarsRPC源码解读篇:使用C++重写Tars-RPC主逻辑框架的3.2节中曾聊过Tars的协程切换流程。这里再复习一下。

    路小饭
  • 破解 Kotlin 协程 番外篇(2) - 协程的几类常见的实现

    前面一篇文章我们大概讨论了协程是怎么一回事,也举了一些例子,不过整体上覆盖的细节比较少。这篇文章我们按照协程的经典论文 “Revisiting Coroutin...

    bennyhuo
  • [Go] golang的MPG调度模型

    MPG模式运行状态1 1)当前程序有三个M,如果三个M都在一个cpu运行,就是并发,如果在不同的cpu运行就是并行 2)M1,M2,M3正在执行一个G,M1的协...

    陶士涵
  • 在 Android 开发中使用协程 | 上手指南

    本文是介绍 Android 协程系列中的第二部分,这篇文章主要会介绍如何使用协程来处理任务,并且能在任务开始执行后保持对它的追踪。

    Android 开发者
  • Swoole 4.4 协程抢占式调度器详解

    Swoole内核团队开设的专栏,会逐渐投入精力写文章介绍Swoole的开发历程,实现原理,应用实践等,大家可以更好的交流,共同学习,建设PHP生态。

    桶哥

扫码关注云+社区

领取腾讯云代金券