（本文主要参照Python在线文档进行学习）

0.前言

进程有自己独立的堆和栈，由操作系统调度；线程有独立的栈，共享堆空间，标准的线程也是由操作系统调度；协程和线程一样共享堆不共享栈，但是是由程序员在协程的代码里显示调度。协程避免了无意义的调度，进而提升性能，但也增加了程序员的责任。

1.初探

asyncio是一个使用 async / await 语法编写并发代码的库，在Python 3.4 引入，直接内置了对异步IO的支持，并在后来的版本中不断完善。早期基于生成器来实现协程，但是在 Python 3.8 开始不推荐使用该方式，并将在 3.10 移除。目前标准的是使用 async / await 语法来实现协程。

要实际运行协程，asyncio 提供了三种主要机制：

a.使用 asyncio.run() 函数来运行顶层入口点

（运行代码需要 Python3.7 ；要注意的是，直接调用 func() 并不能执行）

import asyncio
import time

async def func():
    print('func in'+time.strftime('%X'))
    await asyncio.sleep(3)
    print('func out'+time.strftime('%X'))

print('begin'+time.strftime('%X'))
asyncio.run(func())
print('end'+time.strftime('%X'))

b.等待协程

import asyncio
import time

async def say_after(delay, what):
    await asyncio.sleep(delay)
    print(what)

async def main():
    print(f"started at {time.strftime('%X')}")
    await say_after(1, 'hello')
    await say_after(2, 'world')
    print(f"finished at {time.strftime('%X')}")

asyncio.run(main())

c.用asyncio.create_task() 函数把协程作为异步任务来同时执行

（修改上个示例的 main 函数）

async def main():
    task1 = asyncio.create_task(
        say_after(1, 'hello'))

    task2 = asyncio.create_task(
        say_after(2, 'world'))

    print(f"started at {time.strftime('%X')}")

    # Wait until both tasks are completed (should take
    # around 2 seconds.)
    await task1
    await task2

    print(f"finished at {time.strftime('%X')}")

2.可等待的对象 awaitable

如果可以在 await 表达式中使用，则这个对象是 awaitable 的。可等待的对象主要有三种：协程coroutines，任务Tasks，期望Futures。

a.协程coroutines

Python 协程是可等待的，并且可以等待自其他协程：

import asyncio

async def nested():
    return 42

async def main():
    # 一个协程对象创建了但是没有被等待，不会执行
    print(nested())
    # 输出 "42".
    print(await nested())  

asyncio.run(main())

协程相关的两个重要概念：协程函数，通过 async def 定义的函数；协程对象，调用协程函数返回的对象。

b.任务Tasks

任务可以用来调度协程并发执行。当使用 asyncio.create_task() 打包一个协程，该协程很快会自动计划运行。

import asyncio

async def nested():
    return 42

async def main():
    # nested() 与 main() 会同时运行
    task = asyncio.create_task(nested())
    # "task" 现在可用于取消 "nested()", 或是等待其完成
    await task

asyncio.run(main())

c.期望Futures

Futures 是特殊的低级可等待对象，代表异步操作的最终结果。当 await 一个 Futures 时，协程将等待直到 Futures 在别的地方完成。一般不需要在应用中创建 Futures 对象。

3.部分API参考

a.运行一个异步程序

asyncio.run(coro, *, debug = False )

执行协程 coro 并返回结果。它应该用作 asyncio 程序的主要入口点，理想情况下应该只调用一次。

b.创建任务

asyncio.create_task(coro, *, name = None )

将协程 coro 包装为一个 Task 并调度执行，返回一个 Task 对象。

c.休眠

asyncio.sleep(delay, result=None, *, loop=None)

阻塞等待 delay 秒，sleep 挂起当前任务，允许其他任务运行。

d.同时运行

asyncio.gather(*aws, loop=None, return_exceptions=False)

并发执行 aws 列表中的可等待对象。如果 aws 中有任何可等待的协程，将自动作为一个 Task 调度。

import asyncio

async def factorial(name, number):
    f = 1
    for i in range(2, number + 1):
        print(f"Task {name}: Compute factorial({i})...")
        await asyncio.sleep(1)
        f *= i
    print(f"Task {name}: factorial({number}) = {f}")

async def main():
    # Schedule three calls *concurrently*:
    await asyncio.gather(
        factorial("A", 2),
        factorial("B", 3),
        factorial("C", 4),
    )

asyncio.run(main())

# Expected output:
#
#     Task A: Compute factorial(2)...
#     Task B: Compute factorial(2)...
#     Task C: Compute factorial(2)...
#     Task A: factorial(2) = 2
#     Task B: Compute factorial(3)...
#     Task C: Compute factorial(3)...
#     Task B: factorial(3) = 6
#     Task C: Compute factorial(4)...
#     Task C: factorial(4) = 24

e.超时等待

asyncio.wait_for(aw, timeout, *, loop=None)

aw 是一个协程，如果 timeout 秒数为 None，将会阻塞直到完成。

async def eternity():
    # Sleep for one hour
    await asyncio.sleep(3600)
    print('yay!')

async def main():
    # Wait for at most 1 second
    try:
        await asyncio.wait_for(eternity(), timeout=1.0)
    except asyncio.TimeoutError:
        print('timeout!')

asyncio.run(main())

# Expected output:
#
#     timeout!

协程相关的接口还是挺多的，这里只列举了部分，详情可以参照书籍或文档