asyncio 异步请求（涉及python 3.5 新引用语法）

asyncio 异步请求（python 3.5 新引用语法）

python 3.4 引入了协程的概念。在 python 3.5 中确定了协程的语法

• event_loop 事件循环：程序开启一个无限的循环，程序员会把一些函数注册到事件循环上。当满足事件发生的时候，调用相应的协程函数。
• coeoutine 协程：协程对象，指一个使用 async 关键字定义的函数，它的调用不会立即执行函数，而是返回一个协程对象。写成对象需要注册到事件循环中，由事件循环调用。
• task 任务：一个协程对象就是一个原生可以挂起的函数，任务则是对协程进一步封装，其中包含任务的各种状态。
• future：代表将来执行或没有执行的任务的结果。它和 task 没有本质上的区别。
• async / await 关键字：python 3.5 用于定义协程的关键字，async定义一个协程，await 用于挂起阻塞的异步调用接口。

定义一个协程

使用 async 关键字定义协程。

import time
import asyncio

# 定义时间函数（计算程序执行时间差）
now = lambda: time.time()
async def func1(x):
    print('test', x)
    
start = now()
coroutine = func1(2)
loop = asyncio.get_event_loop()
loop.run_until_complete(coroutine)

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

# 返回值：
"""
test 2
TIME 0.0019989013671875
"""

通过 async 关键定义了一个协程，协程也是一种对象， 协程不能直接运行，需要把写成加入到时间循环（loop）, 由 loop 在适当的时候调用协程，asyncio.get_event_loop 方法可以创建一个事件循环，然后使用 run_until_complete 将协程注册到事件循环，并启动事件循环。

创建一个 task

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

创建task

• task = asyncio.ensure_future(coroutine)
• task = loop.create_task(coroutine)

代码如下：

import asyncio
import time

new = lambda: time.time()
start = new()

async def func1(x):
    print('waiting:', x)


coroutine = func1(2)
loop = asyncio.get_event_loop()
task = loop.create_task(coroutine)
print(task)
loop.run_until_complete(task)
print(task)
loop.close()

print('Programe finished in %s'  % ( start - new()))

# 返回值：
"""
>
waiting: 2
 result=None>
Programe finished in -0.0019981861114501953
"""

创建 task 后，task 在加入事件循环之前是 pending 状态（即等待状态），当task被执行完毕了，就变为 finished 状态

绑定回调

在 task 执行完毕的时候可以获取执行的结果，回调的最后一个参数是 future 对象，通过该对象可以获取协程返回值。如果回调需要多个参数，可以通过偏函数导入。

import asyncio
import time

now = lambda: time.time()
start = now()
async def func1(x):
    print('waiting', x)
    return 'Done after{}s'.format(x)

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

coroutine = func1(2)
loop = asyncio.get_event_loop()
task = loop.create_task(coroutine)
task.add_done_callback(callback)
loop.run_until_complete(task)
loop.close()

print('Program finished in {}s'.format(start-now()))

# 返回值：
"""
waiting 2
Callback:  Done after2s
Program finished in -0.0009989738464355469s
"""

coroutine 执行结束时会调用回调函数，并通过参数 future 获取协程执行的结果。我们创建的 task 和 回调里的 future ，实际上是同一个对象。async 函数中的 return 的结果再回掉函数中被 futuren.result() 调用。

future 与 result

回调中使用了 future 对象的 result 方法。

import asyncio
import time

now = lambda: time.time()

start = now()
async def func1(x):
    print('waiting {}'.format(x))
    return 'Done after {}s'.format(x)

coroutine = func1(2)

loop = asyncio.get_event_loop()
task = loop.create_task(coroutine)
loop.run_until_complete(task)

print('task return value {}'.format(task.result()))
print('Program finished in {}s'.format(start - now()))

阻塞 和 await

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

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

import asyncio
import time

now = lambda: time.time()

async def func1(x):
    print('waiting', x)
    await asyncio.sleep(1)
    return 'Done after {}s'.format(x)

start = now()
coroutine = func1(2)
loop = asyncio.get_event_loop()
task = loop.create_task(coroutine)
loop.run_until_complete(task)

loop.close()

print('task return value {}'.format(task.result()))
print('Program finished in {}'.format(now() - start))

并发与并行

• 并发：通常指多个任务需要同时进行。
• 并行：指同一时刻有多个任务执行。

以下棋为例：并发是指一对一，但是一个人同时对战多个人，而并行则是一对一，但是有很多桌在同时对战。

asyncio 实现并发，就需要多个协程来完成任务，当有阻塞的时候就 await ，然后其他协程继续工作。创建多个协程的列表，然后将这些列表注册到事件循环中。

import asyncio
import time

now = lambda: time.time()

async def func1(x):
    print('waiting {}'.format(x))
    await asyncio.sleep(x)
    return 'Done after {}s'.format(x)

start = now()
coroutine1 = func1(1)
coroutine2 = func1(2)
coroutine3 = func1(3)
coroutine4 = func1(4)

tasks = [
    asyncio.ensure_future(coroutine1),
    asyncio.ensure_future(coroutine2),
    asyncio.ensure_future(coroutine3),
    asyncio.ensure_future(coroutine4)
]

loop = asyncio.get_event_loop()

loop.run_until_complete(asyncio.wait(tasks))

for task in tasks:
    print('task return value {}'.format(task.result()))
    
print('program finished in {}s'.format(now() - start))

# 返回值
"""
waiting 1
waiting 2
waiting 3
waiting 4
task return value Done after 1s
task return value Done after 2s
task return value Done after 3s
task return value Done after 4s
program finished in 4.002517223358154s
"""

程序总执行事件为 4 秒。

• 如果是同步执行，至少需要 10 秒；
• 此时使用 asyncio 实现了并发，执行时间只需要4秒，asyncio.wait(tasks) 接收 task 列表。也可以使用asyncio.gather(*tasks) 接收一堆task，