【转】以Python为例的Async / Await的编程基础

转, 原文:https://www.cnblogs.com/middleware/p/11996731.html

-----------------------------------

来源:Redislabs

作者:Loris Cro

翻译:Kevin (公众号:中间件小哥)

近年来,许多编程语言都在努力改进它们的并发原语。Go 语言有 goroutines,Ruby 有 fibers,当然,还有 Node.js 帮助普及的 async/await,这是当今使用最为广泛的并发操作类型。在本文中,我将以 python 为例讨论 async/await 的基础知识。我选择python语言,是因为这个功能在python 3中比较新,很多用户可能对它还不是很熟悉。使用 async/await 的主要原因是通过减少 I/O 执行时的空闲时间来提高程序的吞吐量。使用这个操作符的程序通过隐式地使用一个称为事件循环的抽象来同时处理多个执行路径。在某些方面,这些事件循环类似于多线程编程,但是事件循环通常存在于单个线程中,因此,它不能同时执行多个计算。正因为如此,单独的事件循环不能提高计算密集型应用程序的性能。但是,对于进行大量网络通信的程序,比如连接到Redis数据库的应用程序,它可以极大地提高性能。每次程序向 Redis 发送一个命令时,它都会等待 Redis 的响应,如果 Redis 部署在另一台机器上,就会出现网络延迟。而一个不使用事件循环的单线程应用程序在等待响应时处于空闲状态,会占用大量的CPU周期。需要注意的是,网络延迟是以毫秒为单位的,而 CPU 指令需要纳秒来执行,这两者相差六个数量级。这里举个例子,下面的代码样例是用来跟踪一个游戏的获胜排行榜。每个流条目都包含获胜者的名字,我们的程序会更新一个 Redis 的有序集合(Sorted Set),这个有序集合用来作为排行榜。这里我们主要关注的是阻塞代码和非阻塞代码的性能。

 1 import redis
 2
 3 # The operation to perform for each event
 4 def add_new_win(conn, winner):
 5     conn.zincrby(‘wins_counter‘, 1, winner)
 6     conn.incr(‘total_games_played‘)
 7
 8 def main():
 9     # Connect to Redis
10     conn = redis.Redis()
11     # Tail the event stream
12     last_id = ‘$‘
13     while True:
14         events = conn.xread({‘wins_stream‘: last_id}, block=0, count=10)
15         # Process each event by calling `add_new_win`
16         for _, e in events:
17             winner = e[‘winner‘]
18             add_new_win(conn, winner)
19             last_id = e[‘id‘]
20
21 if __name__ == ‘__main__‘:
22 main()

  

我们使用aio-libs/aioredis实现与上面代码有相同效果的异步版本。aio-libs 社区正在重写许多 Python 网络库,以包括对 asyncio 的支持,asyncio 是 Python 事件循环的标准库实现。下面是上面代码的非阻塞版本:

 1 import asyncio
 2 import aioredis
 3
 4 async def add_new_win(pool, winner):
 5     await pool.zincrby(‘wins_counter‘, 1, winner)
 6     await pool.incr(‘total_games_played‘)
 7
 8 async def main():
 9     # Connect to Redis
10     pool = await aioredis.create_redis_pool(‘redis://localhost‘, encoding=‘utf8‘)
11     # Tail the event stream
12     last_id = ‘$‘
13     while True:
14         events = await pool.xread([‘wins_stream‘], latest_ids=[last_id], timeout=0, count=10)
15         # Process each event by calling `add_new_win`
16         for _, e_id, e in events:
17             winner = e[‘winner‘]
18             await add_new_win(pool, winner)
19             last_id = e_id
20
21 if __name__ == ‘__main__‘:
22     loop = asyncio.get_event_loop()
23     loop.run_until_complete(main())


这段代码与上面那段代码相比,除了多了一些 await 关键字之外,其他的几乎是相同的。最大的不同之处在最后两行。在 Node.js 中,环境会默认加载事件循环,而在 Python 中,必须显示地开启。
 重写之后,我们可能会认为这么做就可以提高性能了。不幸的是,我们代码的非阻塞版本还没有提高性能。这里的问题在于我们编写代码的细节,而不仅仅是使用 async / await 的一般思想。

Await 使用的限制

我们重写代码后的主要问题是我们过度使用了 await。当我们在异步调用前面加上 await 时,我们做了以下两件事:

1. 为执行做相应的调度

2. 等待完成

有时候,这样做是对的。例如,在完成对第 15 行流的读取之前,我们不能对每个事件进行迭代。在这种情况下,await 关键字是有意义的,但是看看 add_new_win 方法:

1 async def add_new_win(pool, winner):
2     await pool.zincrby(‘wins_counter‘,  1, winner)
3     await pool.incr(‘total_games_played‘)

在这个函数中,第二个操作并不依赖于第一个操作。我们可以将第二个命令与第一个命令一起发送,但是当我们发送第一个命令时,await 将阻塞执行流。我们其实更想要一种能立即执行这两个操作的方法。为此,我们需要一个不同的同步原语。

1 async def add_new_win(pool, winner):
2     task1 = pool.zincrby(‘wins_counter‘, 1, winner)
3     task2 = pool.incr(‘total_games_played‘)
4     await asyncio.gather(task1, task2)

首先,调用一个异步函数不会执行其中的任何代码,而是会先实例化一个“任务”。根据选择的语言,这可能被称为 coroutine, promise 或 future 等等。对我们来说,任务是一个对象,它表示一个值,该值只有在使用了 await 或其他同步原语(如 asyncio.gather)之后才可用。 在 Python 的官方文档中,你可以找到更多关于 asyncio.gather 的信息。简而言之,它允许我们在同一时间执行多个任务。我们需要等待它的结果,因为一旦所有的输入任务完成,它就会创建一个新的任务。Python 的 asyncio.gather 相当于 JavaScript 的 Promise.all,C# 的 Task.WhenAll, Kotlin 的 awaitAll 等等。

改进我们的主循环代码

我们对 add_new_win 所做的事情也可以用于主流事件处理循环。这是我所指的代码:

1 last_id = ‘$‘
2 while True:
3     events = await pool.xread([‘wins_stream‘], latest_ids=[last_id], timeout=0, count=10)
4     for _, e_id, e in events:
5         winner = e[‘winner‘]
6         await add_new_win(pool, winner)
7         last_id = e_id

到目前为止,你会注意到我们是顺序地处理每个事件。因为在第 6 行中,使用 await 既可以执行又可以等待 add_new_win 的完成。有时这正是你希望发生的情况,因为如果你不按顺序执行,程序逻辑就会中断。在我们的例子中,我们并不真正关心排序,因为我们只是更新计数器。

1 last_id = ‘$‘
2 while True:
3     events = await pool.xread([‘wins_stream‘], latest_ids=[last_id], timeout=0, count=10)
4     tasks = []
5     for _, e_id, e in events:
6         winner = e[‘winner‘]
7         tasks.append(add_new_win(pool, winner))
8         last_id = e_id
9     await asyncio.gather(*tasks)

我们现在也在并发地处理每一批事件,并且对代码的改动是最小的。最后要记住,有时即使不使用 asyncio.gather,程序也可以是高性能的。特别是,当你为 web 服务器编写代码并使用像 Sanic 这样的异步框架时,该框架将以并发的方式调用你的请求处理程序,即使你在等待每个异步函数调用,也能确保巨大的吞吐量。

总结

下面是我们进行上面两个更改之后的完整代码示例:

 1 import asyncio
 2 import aioredis
 3
 4 async def add_new_win(pool, winner):
 5     # Creating tasks doesn‘t schedule them
 6     # so you can create multiple and then
 7     # schedule them all in one go using `gather`
 8     task1 = pool.zincrby(‘wins_counter‘, 1, winner)
 9     task2 = pool.incr(‘total_games_played‘)
10     await asyncio.gather(task1, task2)
11
12 async def main():
13     # Connect to Redis
14     pool = await aioredis.create_redis_pool(‘redis://localhost‘, encoding=‘utf8‘)
15     # Tail the event stream
16     last_id = ‘$‘
17     while True:
18         events = await pool.xread([‘wins_stream‘], latest_ids=[last_id], timeout=0, count=10)
19         tasks = []
20         for _, e_id, e in events:
21             winner = e[‘winner‘]
22             # Again we don‘t actually schedule any task,
23             # and instead just prepare them
24             tasks.append(add_new_win(pool, winner))
25             last_id = e_id
26         # Notice the spread operator (`*tasks`), it
27         # allows using a single list as multiple arguments
28         # to a function call.
29         await asyncio.gather(*tasks)
30
31 if __name__ == ‘__main__‘:
32     loop = asyncio.get_event_loop()
33     loop.run_until_complete(main())

为了利用非阻塞 I/O,你需要重新考虑如何处理网络操作。值得高兴的是这并不是很困难,你只需要知道顺序性什么时候重要,什么时候不重要。尝试使用 aioredis 或等效的异步 redis 客户端,看看可以在多大程度上提高应用程序的吞吐量。

原文地址:https://www.cnblogs.com/oxspirt/p/11997478.html

时间: 2024-10-08 12:27:59

【转】以Python为例的Async / Await的编程基础的相关文章

[C#] 开始接触 async/await 异步编程

开始接触 async/await 异步编程 序 之前已经整理了 4 篇关于 LINQ 的随笔,想换换口味. 目录 What's 异步? async/await 结构 What’s 异步方法? 一.What's 异步? 启动程序时,系统会在内存中创建一个新的进程.进程是构成运行程序资源的集合. 在进程内部,有称为线程的内核对象,它代表的是真正的执行程序.系统会在 Main 方法的第一行语句就开始线程的执行. 线程: (1)默认情况,一个进程只包含一个线程,从程序的开始到执行结束: (2)线程可以派

.NET 中的 async/await 异步编程

前言 最近在学习Web Api框架的时候接触到了async/await,这个特性是.NET 4.5引入的,由于之前对于异步编程不是很了解,所以花费了一些时间学习一下相关的知识,并整理成这篇博客,如果在阅读的过程中发现不对的地方,欢迎大家指正. 同步编程与异步编程 通常情况下,我们写的C#代码就是同步的,运行在同一个线程中,从程序的第一行代码到最后一句代码顺序执行.而异步编程的核心是使用多线程,通过让不同的线程执行不同的任务,实现不同代码的并行运行. 前台线程与后台线程 关于多线程,早在.NET2

async & await 异步编程的一点巧方法

await 关键字不会创建新的线程,而是由Task任务或是FCL中的xxxAsync等方法创建的线程,而且这里创建的线程都是基于线程池创建的工作线程,属于后台线程. await关键字会阻塞/暂停调用它的方法,也即下面的 Phycology 方法.当阻塞其调用方法的时候,程序会回到UI线程中去执行,也就是main方法中去执行,这点可以通过 C#中 Thread,Task,Async/Await,IAsyncResult 的那些事儿! 其内的程序来判断. async & await 组合的程序片段一

Async/Await 异步编程中的最佳做法

近日来,涌现了许多关于 Microsoft .NET Framework 4.5 中新增了对 async 和 await 支持的信息. 本文旨在作为学习异步编程的“第二步”:我假设您已阅读过有关这一方面的至少一篇介绍性文章. 本文不提供任何新内容,Stack Overflow.MSDN 论坛和 async/await FAQ 这类在线资源提供了同样的建议. 本文只重点介绍一些淹没在文档海洋中的最佳做法. 本文中的最佳做法更大程度上是“指导原则”,而不是实际规则. 其中每个指导原则都有一些例外情况

async & await 异步编程小示例,一看就懂

1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using System.Threading; 6 using System.Threading.Tasks; 7 8 namespace ConAppAsync 9 { 10 class Program 11 { 12 13 //第一步,创建一个普通的耗时的方法 14 static string Gree

async await 异步编程杂记

1. async 仅仅是用了标记 方法中有异步调用(就是有await...) 2  await  用来把「当前线程」中的代码“分成片”,通过一定条件和事件回调的形式  “依次执行”. 3. await并不是「阻塞」主线程,遇到 await ,主线程返回「线程池」 4. 内部用了Task,解决返回值,异常等问题. 5. 还有一些语法糖之类.Task的返回值只有 await之后得到.以前的是Task. 以上

Async await 异步编程说明

希望在编程上有些许提高所以 最近连续2篇博客都在说明多线程和异步编程的使用,异步和多线程之间区别请自行百度,因为理解不是特别透彻就不在叙述以免误导大家,这里写下新研究整理 task  和 await 的异步编程使用 调用子方法和耗时方法如下 /// <summary> /// 有返回值异步方法 /// </summary> /// <returns></returns> static async Task<int> HaveReturnAsync

python学习第十四天 -面向对象编程基础

python也是支持面向对象编程的.这一章节主要讲一些python面向对象编程的一些基础. 什么是面向对象的编程? 1.面向对象编程是一种程序设计范式 2.把程序看做不同对象的相互调用 3.对现实世界建立对象模型 面向对象编程的基本思想: 1.类用于定义抽象类型 2.实例根据类的定义被创建出来 如何定义一个类并创建实例? >>> class Animal(object): pass >>> dog = Animal() >>> cat = Animal

【python之路】【2、编程基础】Python简介和入门

1.Python前世今生 python的创始人为吉多·范罗苏姆(Guido van Rossum).1989年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的脚本解释程序,作为ABC语言的一种继承. 最新的TIOBE排行榜,Python赶超PHP占据第五!!! 由上图可见,Python整体呈上升趋势,反映出Python应用越来越广泛并且也逐渐得到业内的认可!!! Python可以应用于众多领域,如:数据分析.组件集成.网络服务.图像处理.数值计算和科学计算等众多领域.目前业