asyncio入门指南

本篇文章可以当作是官方文档的总结和补充，详细的API，还是需要看官方文档。一遍一遍看，每看都会有不同的收获。下面进行真题，发车！

1.为什么需要asyncio

asyncio库为我们提供了并发的能力。

当我们执行一个需要大量io操作任务A的时候，不需要阻塞等待任务A的结果返回，而是可以转而去执行另一个任务B，等待任务A执行结束之后，会发送一个通知，这个时候再去执行任务A的返回结果。这中间节省的时间，就是被IO阻塞的时间。可以看下方一个示例：

我们使用time.sleep来代指长时间的IO操作，在这里，我们的程序耗时为15S，是所有执行任务时间的总和。

import asyncio
import time

def taskA():
    time.sleep(10)
    
def taskB():
    time.sleep(5)


async def main():
    print(f"start main at {time.strftime('%X')}")
    taskA()
    taskB()
    print(f"finished main at {time.strftime('%X')}")

if __name__ == "__main__":
    asyncio.run(main())
# expect result: cost 15S
# start main at 22:23:06
# finished main at 22:23:21

我们使用asyncio来进行相关的IO操作，代码虽然复杂了一点，但是我们的耗时降到了10S。这里是10并不是并不是程序被阻塞住，不能够执行其他的任务，而是我们的程序需要10才结束。如果我们还有任务C、任务D等。此时程序会转而执行其他的任务，而不是一直被阻塞住。

import asyncio
import time

async def taskA():
    await asyncio.sleep(10)
    
async def taskB():
    await asyncio.sleep(5)


async def main():
    print(f"start main at {time.strftime('%X')}")
    task1 = asyncio.create_task(taskA())
    task2 = asyncio.create_task(taskB())

    await task1
    await task2
    print(f"finished main at {time.strftime('%X')}")

if __name__ == "__main__":
    asyncio.run(main())

# expect result: cost:10S
# start main at 22:21:10
# finished main at 22:21:20

 通过asyncio，我们可以尽可能地利用线程的资源，让线程一直运行，而不处于阻塞的状态。

在现实生活中，我们也会做类似的事情。去饭店吃饭，我们点完餐，一定是找个地方坐着，和朋友聊天，等待服务员上菜，而不是站在厨房旁边，等着饭菜做好。这其实就是异步不阻塞的原理。

2.什么是可等待对象

我们使用 async/await 语法，来进行异步编程。

async是声明一个协程函数，await表示调用，可以调用所有的可等待对象。

python中可等待对象如下：

注意：只有可等待对象才被await中调用。

• corotinue:使用async def func_name(),协程函数生成的对象。

• task:表示一个任务，被用来并行地调度协程。

• future:一种特殊的 低层级 可等待对象，表示一个异步操作的 最终结果,常用语底层的框架，应用层的代码很少使用。

3.区别协程函数和协程对象

协程函数是一种特殊的函数，就比如我们在上面的案例中使用async def taskA()。

协程对象是由协程函数调用返回的一个对象。当我们使用taskA()的使用，就会返回一个协程对象，我们可以使用一个变量进行接收。比如：corA = taskA(),这里的corA就是一个协程对象。

import asyncio

async def cor_func():
    await asyncio.sleep(10)

async def main():
    print(cor_func) #<function cor_func at 0x104e6e160>
    print(type(cor_func)) #<class 'function'>
    print(cor_func()) #<coroutine object cor_func at 0x105b58f40>,会报错，因为协程对象需要被await
    print(type(cor_func())) #<class 'coroutine'>


if __name__ == "__main__":
    asyncio.run(main())

我们想要调用一个协程对象，就必须使用await，不然会报错：RuntimeWarning: coroutine 'cor_func' was never awaited。

这里简单地总结一下：

调用协程函数，会返回协程对象。

而如果我们想要调用协程对象，就必须使用await，不然会报错。

4.常见API整理

明白了上面的这些概念之后，我们就可以去官方文档中进行学习了，以下简单做一个归类，可以参考一下。

正常运行协程：

• asyncio.run(),运行最高层次的入口点函数

• await 直接对协程执行

并发运行协程：

task是在事件循环中运行的，如果想要并发运行协程，需要将协程转变成任务中，在事件循环中执行。

• asyncio.create_task()创建任务，之后await执行任务。

• async with asyncio.TaskGroup() as tg: 异步上下文管理器，隐式调用加入到任务组中的task对象。

• asyncio.gather(*aws),并发执行，返回结果列表。运行任务时引发的异常不影响其他任务的运行。

除此之外，还需要学习asyncio.timeout()和asyncio.to_thread()

• asyncio.timeout() 控制IO处理的时间，如果超过了规定的时间，会取消该可等待对象的执行，并引起 asyncio.CancelledError。
• asyncio.to_thread() 重新启动一个线程运行非async函数，用来将IO密集性函数变为非阻塞的。案例如下：

• import asyncio
  import time
  
  def blocking_io():
      print(f"start blocking_io at {time.strftime('%X')}")
      # 直接阻塞当前的时间循环。
      time.sleep(3)
      print(f"blocking_io complete at {time.strftime('%X')}")
  
  async def main():
      print(f"started main at {time.strftime('%X')}")
  
      await asyncio.gather(
          asyncio.to_thread(blocking_io),
          asyncio.sleep(5))
  
      print(f"finished main at {time.strftime('%X')}")
  
  
  asyncio.run(main())

asyncio是python并发编程的重点，比较复杂，需要多看、多敲，每一个学习都会有不同的收获。