Python 异步协程 async/await/asyncio

引自：https://blog.csdn.net/sunt2018/article/details/105138121

异步IO asyncio协程

asyncio 是python3.4 引入的，内置的对异步IO的支持。

asyncio编程是一个消息循环，我们从asyncio中获取一个EventLoop引用

然后把协程放到EventLoop中执行，就实现了异步IO

协程常见名字

先了解以下名词,有助于理解程序编写

• event_loop 事件循环： 程序开启一个循环，我们把函数注册到loop里，满足条件就会执行

• coroutine 协程: async def 定义的函数，它不能直接执行,返回的是协程对象,它要注册到loop中，由loop去执行调用

• task 任务： 一个协程对象就是一个原生可以挂起的函数，任务则是对协程对象进一步封装，增加了任务的各种状态，（比如未执行，执行中，执行结束，返回结果等等？。）

  task 是 future的子类

• future : 代表将来执行或没有执行的任务的结果，它个task没有本质区别

• async/await : python3.5 用于定义协程的关键字

创建一个协程 Coroutine

import asyncio,time

# 记录开始时间
now = lambda: time.time()
start = now()

# 01.定义一个协程
async def do_work(num):
    print("num:",num)

coroutine = do_work(1)

# 02.创建事件循环
loop = asyncio.get_event_loop()

# 03.将协程对象放入事件循环中
loop.run_until_complete(coroutine)

# 记录结束时间
print(now() - start)

　　

创建一个任务 Task

loop.run_until_complete方法传入协程，自动将协程装成任务task，它也可以直接接收task

创建task 使用以下方法都可以

asyncio.ensure_future(coroutine)

loop.create_task(coroutine)

task是future的子类。

isinstance(task,asyncio.Future) 返回Ture

import asyncio,time

# 记录开始时间
now = lambda: time.time()
start = now()

# 01.定义一个协程
async def do_work(num):
    print("num:",num)

coroutine = do_work(1)

# 02.创建事件循环
loop = asyncio.get_event_loop()

# 03.创建任务Task
task = asyncio.ensure_future(coroutine)
# 或者下面的方式 创建task也可以
# task = loop.create_task(coroutine)

# 04.将任务注册到事件循环中
loop.run_until_complete(task)

# 记录结束时间
print(now() - start)

　　

获取返回结果 回调函数future/直接使用Task获取

import asyncio,time

# 记录开始时间
now = lambda: time.time()
start = now()

# 01.定义一个协程
async def do_work(num):
    print("num:",num)
    return "num is {}".format(num)

coroutine = do_work(3)


# 02.定义回调函数
def callback(future):
    print('result is',future.result())

# 03.创建事件循环
loop = asyncio.get_event_loop()

# 04.创建任务Task
task = loop.create_task(coroutine)

# 05.给task任务绑定回调函数
task.add_done_callback(callback)

# 06.将任务注册到事件循环中
loop.run_until_complete(task)

# 记录结束时间
print(now() - start)

　　

不绑定回调，直接使用Task的结果

task.result()，必须任务执行完毕后才有这个，不然会报错

阻塞 await

import asyncio,time

# 记录开始时间
now = lambda: time.time()
start = now()

# 01.定义一个协程
async def do_work(num):
    print("num:",num)
    await asyncio.sleep(num)
    return "sleep is {}".format(num)

coroutine = do_work(3)


# 02.创建事件循环
loop = asyncio.get_event_loop()

# 03.创建任务Task
task = loop.create_task(coroutine)
print(task.result())

# 04.将任务注册到事件循环中
loop.run_until_complete(task)

# 记录结束时间
print(now() - start)
print(task.result())

　　

asyncio 实现并发

import asyncio,time

# 记录开始时间
now = lambda: time.time()
start = now()

# 01.定义一个协程
async def do_work(num):
    print("num:",num)
    await asyncio.sleep(num)
    return "sleep is {}".format(num)

coroutine1 = do_work(1)
coroutine2 = do_work(2)
coroutine3 = do_work(3)



# 02.创建任务Task
tasks =[
    asyncio.ensure_future(coroutine1),
    asyncio.ensure_future(coroutine2),
    asyncio.ensure_future(coroutine3),
    
]

# 02.创建事件循环
loop = asyncio.get_event_loop()

# 04.将任务注册到事件循环中
loop.run_until_complete(asyncio.wait(tasks))

# 记录结束时间
print(now() - start)
for task in tasks:
    print(task.result())

　　

协程嵌套

import time
import asyncio


async def do_work(x):
    print("do...work.....")
    await asyncio.sleep(x)
    return 'Done result'


async def main():
    # 创建多个协程对象
    coroutine1 = do_work(1)
    coroutine2 = do_work(2)
    coroutine3 = do_work(4)
    
    tasks = [
        asyncio.ensure_future(coroutine1),
        asyncio.ensure_future(coroutine2),
        asyncio.ensure_future(coroutine3)
    ]
    
    # --------------------------------------------
    # 获取返回结果的方式 1
    dones,pendings = await asyncio.wait(tasks)
    # dones 是任务
    for task in dones:
        print(task.result())
    # --------------------------------------------
    
# 将协程main 放入到 loop中
loop = asyncio.get_event_loop()
loop.run_until_complete(main())

　　

 获取返回结果的方式2
results =  await asyncio.gather(*tasks)
for result in results():
    print(result)

　　

# 获取方式3,不在main中获取，而是在外面获取
async def main:
    # .....
    return await asyncio.gather(*tasks)

results = loop.run_until_complete(main())
for result in results():
    print(result)

　　

# 获取方式4,不在main中获取，而是在外面获取
async def main:
    # .....
    return await asyncio.wait(tasks)

dones,pendings = loop.run_until_complete(main())
for task in dones:
    print(task.result())

　　

# 获取方式5,还是在main中

for task in asyncio.as_complete(tasks):
    result = await task
    print(result)

　　

协程的停止

future 中的几种状态

• Pending 创建future的时候，task为 pending
• Running 事件循环执行的时候，task是running
• Done 执行完毕 task状态是done
• Cancelled 任务取消

• import time
  import asyncio
  
  
  async def do_work(x):
      print("do...work.....")
      await asyncio.sleep(x)
      return 'Done result'
  
  
  coroutine1 = do_work(1)
  coroutine2 = do_work(2)
  coroutine3 = do_work(4)
  
  
  tasks = [
          asyncio.ensure_future(coroutine1),
          asyncio.ensure_future(coroutine2),
          asyncio.ensure_future(coroutine3),
  ]
  
  
  start = time.time()
  loop = asyncio.get_event_loop()
  
  try:
      loop.run_until_complete(asyncio.wait(tasks))
  except KeyboardInterrupt as e:
      for task in asyncio.Task.all_tasks():
          print(task.cancel())
      loop.stop()
      loop.run_forever()
  finally:
      loop.close()
  
  print(time.time() - start)