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,

你可能感兴趣的:(asyncio 异步请求(涉及python 3.5 新引用语法))