python asyncio——异步IO（ asyncio） 协程 （下）

出处：https://www.jianshu.com/p/b5e347b3a17c

asyncio

python3.4开始引入的标准库,内置了对移步io的支持
asyncio本身是一个消息循环。
网络模型有很多中，为了实现高并发也有很多方案，多线程，多进程。无论多线程和多进程，IO的调度更多取决于系统，而协程的方式，调度来自用户，用户可以在函数中yield一个状态。使用协程可以实现高效的并发任务。

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

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

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

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

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

定义协程

import time
import asyncio

now = lambda : time.time()

#async关键字定义一个协程（coroutine）。
async def do_some_work(x):
    print('Waiting: ', x)

start = now()

#协程也是一种对象
coroutine = do_some_work(2)

#协程不能直接运行，需要把协程加入到事件循环（loop），后者在适当的时候调用协程。
#asyncio.get_event_loop()方法创建一个事件循环
loop = asyncio.get_event_loop()
#将协程注册到事件循环，并启动事件循环
loop.run_until_complete(coroutine)

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

结果：
Waiting:  2
TIME:  0.0004658699035644531

创建task

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

import threading
import asyncio

@asyncio.coroutine
def hello():
    print('Hello world! (%s)' % threading.currentThread())
    print('Start..... (%s)' % threading.currentThread())
    yield from asyncio.sleep(10)
    print('Done..... (%s)' % threading.currentThread())
    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 15112)>)
Start..... (<_MainThread(MainThread, started 15112)>)
Hello world! (<_MainThread(MainThread, started 15112)>)
Start..... (<_MainThread(MainThread, started 15112)>)
Done..... (<_MainThread(MainThread, started 15112)>)
Hello again! (<_MainThread(MainThread, started 15112)>)
Done..... (<_MainThread(MainThread, started 15112)>)
Hello again! (<_MainThread(MainThread, started 15112)>)

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 = asyncio.ensure_future(coroutine)
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 D:/exe.pycharm/notebook/v8.py:6>>
Waiting:  2
<Task finished coro=<do_some_work() done, defined at D:/exe.pycharm/notebook/v8.py:6> result=None>
TIME:  0.0010008811950683594

创建task后，task在加入事件循环之前是pending状态，因为do_some_work中没有耗时的阻塞操作，task很快就执行完毕了。后面打印的finished状态。
syncio.ensure_future(coroutine) 和 loop.create_task(coroutine)都可以创建一个task，run_until_complete的参数是一个futrue对象。当传入一个协程，其内部会自动封装成task，task是Future的子类。isinstance(task, asyncio.Future)将会输出True。