python异步IO编程(一)

python异步IO编程(一)

基础概念

协程:python  generator与coroutine

异步IO (async IO):一种由多种语言实现的与语言无关的范例(或模型)。

asyncio:Python 3.4版本引入的标准库,直接内置了对异步IO的支持。

 

异步IO

线程,多线程

多线程善于处理I/O密集型任务。
多进程擅长处理计算密集型(CPU-bound)任务:强密集循环和数学计算都属于此类。
并发是并行的一种特殊类型(或者说子类),多线程是并发的表现形式,多进程是并行的表现形式。
Python通过它的包 multiprocessing,threading 和 concurrent.futures 已经对这两种形式都提供了长期的支持。

 

异步IO

异步IO是一种单进程、单线程的设计:它使用协同多任务处理机制,是以协程为核心的一种编程模型。
异步IO并不是新发明的概念,它已经存在或正在被构建到其他语言及运行时环境中,如 Go,C# 和 Scala 等。
异步IO模型异步IO采用消息循环的模式,在消息循环中,主线程不断地重复“读取消息-处理消息”这一过程:

loop = get_event_loop() //实例消息队列
while True:
event = loop.get_event() //从队列中读取消息
process_event(event)    //处理消息消息模型其实早在应用在桌面应用程序中了。一个GUI程序的主线程就负责不停地读取消息并处理消息。所有的键盘、鼠标等消息都被发送到GUI程序的消息队列中,然后由GUI程序的主线程处理。

由于GUI线程处理键盘、鼠标等消息的速度非常快,所以用户感觉不到延迟。某些时候,GUI线程在一个消息处理的过程中遇到问题导致一次消息处理时间过长,此时,用户会感觉到整个GUI程序停止响应了,敲键盘、点鼠标都没有反应。
这种情况说明在消息模型中,处理一个消息必须非常迅速,否则,主线程将无法及时处理消息队列中的其他消息,导致程序看上去停止响应。
消息模型是如何解决同步IO必须等待IO操作这一问题的呢?当遇到IO操作时,代码只负责发出IO请求,不等待IO结果,然后直接结束本轮消息处理,进入下一轮消息处理过程。当IO操作完成后,将收到一条“IO完成”的消息,处理该消息时就可以直接获取IO操作结果。
在“发出IO请求”到收到“IO完成”的这段时间里,同步IO模型下,主线程只能挂起,但异步IO模型下,主线程并没有休息,而是在消息循环中继续处理其他消息。这样,在异步IO模型下,一个线程就可以同时处理多个IO请求,并且没有切换线程的操作。对于大多数IO密集型的应用程序,使用异步IO将大大提升系统的多任务处理能力。

 

 

asyncio

async与asyncio.coroutine

在 python3.5 中,创建一个协程仅仅只需使用 async 关键字,而python3.4使用 @asyncio.coroutine 装饰器。都引入了原生协程或者说异步生成器。下面的任一代码,都可以作为协程工作,形式上也是等同的:

import asyncio

async def ping_server(ip): # 3.5
pass

@asyncio.coroutine
def load_file(path): # 3.4
pass

 

 

yield from与await

3.1 中协程操作只是简单的生成器调用,常见的我们还需要在生成器或者说协程之间相互调用,用到yield from。yield from 用于一个generator调用另一个generator,主要是为了generator之间的调用。
yield from 表达式的使用方式如下:

import asyncio
@asyncio.coroutine
def get_jason(client, url):
file_content = yield from load_file('/Usrs/scott/data.txt')

 

协程的一个关键特性是它们可以被链接到一起。(记住,一个协程是可等待的,所以另一个协程可以使用 await 来等待它。)await 将控制器传递给时间循环。(挂起当前运行的协程与yield from类似),使用方式如下:

async def ping_local(ip):
  return await ping_server('192.168.1.1')

Python3.5 对这两种调用协程的方法都提供了支持,但是推荐 async/await 作为首选。


Python执行的时候, g() 函数范围内如果遇到表达式 await f(),就是 await 在告诉事件循环“挂起 g() 函数,直到 f() 返回结果,在此期间,可以运行其他函数。”

async def g():
#暂停,直到 f()结束再回到g()
  r = await f()
  return r

当你使用 await f() 时,要求 f() 是一个可等待的对象。但这并没有什么用。现在,只需要知道可等待对象要么是(1)其他的协程,要么就是(2)定义了 .await() 函数且返回迭代器的对象。如果你正在编写程序,绝大多数情况只需要关注案例#1。

使用规则

1. 使用 await 与 return 的组合创建协程函数。想要调用一个协程函数,必须使用 await 等待返回结果。
2. 在 async def 代码块中使用 yield 的情况并不多见(只有Python的近期版本才可用)。当你使用 async for 进行迭代的时候,会创建一个异步生成器。暂时先忘掉异步生成器,将目光放在使用 await 与 return 的组合创建协程函数的语法上。
3. 在任何使用 async def 定义的地方都不可以使用 yield from,这会引发异常 SyntaxError。
4. 一如在 def 定义的函数之外使用 yield 会引发异常 SyntaxError,在 async def 定义的协程之外使用 await 也会引发异常 SyntaxError。你只能在协程内部使用 await。

 

 

Event Loop

asyncio的编程模型就是一个消息循环。我们从asyncio模块中直接获取一个EventLoop的引用,然后把需要执行的协程扔到EventLoop中执行,就实现了异步IO。

用asyncio实现Hello world代码如下:

import asyncio

@asyncio.coroutine
def hello():
  print("Hello world!")
# 异步调用asyncio.sleep(1):
  r = yield from asyncio.sleep(1)
  print("Hello again!")

# 获取EventLoop:
loop = asyncio.get_event_loop()
# 执行coroutine
loop.run_until_complete(hello())
loop.close()

@asyncio.coroutine把一个generator标记为coroutine类型,然后,我们就把这个coroutine扔到EventLoop中执行。
hello()会首先打印出Hello world!,然后,yield from语法可以让我们方便地调用另一个generator。由于asyncio.sleep()也是一个coroutine,所以线程不会等待asyncio.sleep(),而是直接中断并执行下一个消息循环。当asyncio.sleep()返回时,线程就可以从yield from拿到返回值(此处是None),然后接着执行下一行语句。
把asyncio.sleep(1)看成是一个耗时1秒的IO操作,在此期间,主线程并未等待,而是去执行EventLoop中其他可以执行的coroutine了,因此可以实现并发执行。

async/await版本:

import asyncio

async def hello():
print("Hello World")
r = await asyncio.sleep(1)
print("Again")

loop = asyncio.get_event_loop()
loop.run_until_complete(hello())
loop.close()

我们用Task封装两个coroutine试试:

import threading
import asyncio

@asyncio.coroutine
def hello():
  print('Hello world! (%s)' % threading.currentThread())
yield from asyncio.sleep(1)
  print('Hello again! (%s)' % threading.currentThread())

loop = asyncio.get_event_loop()
tasks = [hello(), hello()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

观察执行过程:
Hello world! (<_MainThread(MainThread, started 140735195337472)>)
Hello world! (<_MainThread(MainThread, started 140735195337472)>)
(暂停约1秒)
Hello again! (<_MainThread(MainThread, started 140735195337472)>)
Hello again! (<_MainThread(MainThread, started 140735195337472)>)

由打印的当前线程名称可以看出,两个coroutine是由同一个线程并发执行的。
如果把asyncio.sleep()换成真正的IO操作,则多个coroutine就可以由一个线程并发执行。

 

 

参考:

https://mp.weixin.qq.com/s/fJaXmfHfYEk6XL2y8NmKmQ

https://www.jianshu.com/p/2dfaacdd0a90

 

posted @ 2019-07-11 22:13 -零 阅读(...) 评论(...) 编辑 收藏