python异步IO编程(一)

基础概念

异步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