Python黑魔法--异步IO（asyncio）协程 （一）

python asyncio

网络模型有很多种，为了实现高并发也有很多方案，多线程，多进程。无论多线程和多进程，IO的调度更多取决于系统，而协程的方式，调度来自用户，用户可以在函数中yield一个状态。使用协程可以实现高效的并发任务。
Python的在3.4中引入了协程的概念，可是这个还是以生成器对象为基础，3.5则确定了协程的语法。
下面将简单介绍asyncio的使用。实现协程的不仅仅是asyncio，tornado和gevent都实现了类似的功能。

概念

event_loop 事件循环

程序开启一个无限的循环，程序员会把一些函数注册到事件循环上。当满足事件发生的时候，调用相应的协程函数。

coroutine 协程

协程对象，指一个使用async关键字定义的函数，它的调用不会立即执行函数，而是会返回一个协程对象。协程对象需要注册到事件循环，由事件循环调用。

task 任务

一个协程对象就是一个原生可以挂起的函数，任务则是对协程进一步封装，其中包含任务的各种状态。

future

代表将来执行或没有执行的任务的结果。它和task上没有本质的区别

async/await 关键字

python3.5 用于定义协程的关键字，async定义一个协程，await用于挂起阻塞的异步调用接口。

定义一个协程

定义一个协程很简单，使用 async 关键字，就想定义一个普通函数一样：

import time
import asyncio


async def do_some_work(x):
    print("Waiting: ", x)

now = lambda: time.time()
start = now()
coroutine = do_some_work(2)
loop = asyncio.get_event_loop()
loop.run_until_complete(coroutine)
print("TIME:", now()-start)

通过async关键字定义一个协程（coroutine），协程也是一种对象。协程不能直接运行，需要把协程加入到事件循环（loop），由后者在适当的时候调用协程。asyncio.get_event_loop方法可以创建一个事件循环，然后使用run_until_complete将协程注册到事件循环，并启动事件循环。因为本例只有一个协程，于是可以看见如下输出：

Waiting:  2
TIME: 0.0019998550415039062

创建一个Task

协程对象不能直接运行，在注册事件循环的时候，其实是 run_until_complete 方法将协程包装成了一个任务（task）对象。所谓task对象是Future类的子类。保存了协程运行之后的状态，用于未来获取协程的结果。

import asyncio
import time


async def do_some_work(x):
    print("Waiting: ", x)


now = lambda: time.time()
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)

可以看到输出的结果为：

<Task pending coro=<do_some_work() running at C:/Users/Administrator/PycharmProjects/demo01/demo02.py:5>>
Waiting:  2
<Task finished coro=<do_some_work() done, defined at C:/Users/Administrator/PycharmProjects/demo01/demo02.py:5> result=None>
TIME:  0.0019998550415039062

创建task之后，task在加入事件循环之前是 pending 的状态，因为do_some_work()中没有耗时的阻塞操作，task很快就执行完了，后面打印出来的是finished的状态。

asyncio.ensure_future(coroutine)和loop.create_task(coroutine)都可以创建一个task，run_until_complete的参数是一个future对象。当传入一个协程，其内部会自动封装成task，task是Future的子类。isinstance(task,asyncio.Future) 将会输出 True。

绑定回调

绑定回调，在task执行完毕的时候，可以获取执行的结果，回调的最后一个参数是future 对象，通过该对象可以获取协程返回值。

import time
import asyncio


async def do_some_work(x):
    print("Waiting: ", x)
    return "Done after {}s".format(x)


def callback(future):
    print("Callback: ", future.result())


now = lambda: time.time()
start = now()
coroutine = do_some_work(2)
loop = asyncio.get_event_loop()
task = asyncio.ensure_future(coroutine)
task.add_done_callback(callback)
loop.run_until_complete(task)

print("TIME: ", now()-start)

执行结果：
Waiting: 2
Callback: Done after 2s
TIME: 0.0010001659393310547

如果回调需要多个参数，可以通过偏导数导入：

import functools
import time
import asyncio


async def do_some_work(x):
    print("Waiting: ", x)
    return "Done after {}s".format(x)


def callback(t, future):
    print("Callback: ", t, future.result())


now = lambda: time.time()
start = now()
coroutine = do_some_work(2)
loop = asyncio.get_event_loop()
task = asyncio.ensure_future(coroutine)
task.add_done_callback(functools.partial(callback, 2))
loop.run_until_complete(task)

print("TIME: ", now()-start)

运行结果：

Waiting:  2
Callback:  2 Done after 2s
TIME:  0.0010001659393310547

可以看到，coroutine 执行结束的时候回调用回调函数，并且通过参数future获取协程执行的结果。我们创建的task和回调里面的future对象，实际上是同一个对象。

另外： 关于偏导数的用法参考：

https://wiki.jikexueyuan.com/project/explore-python/Functional/partial.html
partial 的功能：固定函数参数，返回一个新的函数。
当函数参数太多，需要固定某些参数时，可以使用 functools.partial 创建一个新的函数。

future 和 result

回调一直是很多异步编程的噩梦，程序员更喜欢使用同步的编写方式写异步代码，以避免回调的噩梦。
回调中我们使用了future对象的result方法。前面不绑定回调的例子中，我们可以看到task有finashed状态。在finashed状态下，可以直接读取task的result方法。

import time
import asyncio


async def do_some_work(x):
    print("Waiting: {}".format(x))
    return "Done after {}s".format(x)

now = lambda: time.time()
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:{}".format(task.result()))
print("TIME: ", now()-start)

可以看到输出结果是：

Waiting: 2
Task ret:Done after 2s
TIME:  0.002000093460083008

阻塞和await

使用asyncio可以定义协程对象，使用await可以针对耗时的操作进行挂起，就像生成器里的yield一样，函数让出控制权。协程遇到了await，事件循环就会挂起该协程，执行别的协程，直到其他协程也挂起或者是执行完毕，再进行下一个协程的执行。

耗时的操作一般是一些IO操作，例如网络请求，文件读取等等。我们使用 asyncio.sleep函数来模拟IO操作。协程的目的也是让这些IO操作异步化。

import time
import asyncio


async def do_some_work(x):
    print("Waiting: {}".format(x))
    await asyncio.sleep(x)
    return "Done after {}s".format(x)

now = lambda: time.time()
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:{}".format(task.result()))
print("TIME: ", now()-start)

运行结果：

Waiting: 2
Task ret:Done after 2s
TIME:  2.0011143684387207

在sleep的时候，使用await让出控制权。即当遇到阻塞调用的函数的时候，使用await方法将协程的控制权让出，以便loop调用其他的协程。现在我们的例子就用耗时的阻塞操作了。