Python Async/Await 的编译器转换：协程对象的生成、挂起与恢复的字节码分析
大家好，今天我们来深入探讨 Python 中 async/await 关键字背后的编译器转换机制。我们将从协程对象的生成开始，逐步分析协程的挂起与恢复，并结合字节码指令，理解 Python 如何实现异步编程。
1. 协程的基石：生成器与状态机
在理解 async/await 之前，必须先回顾 Python 的生成器。生成器使用 yield 关键字，允许函数暂停执行并返回一个值，稍后可以从暂停的位置恢复执行。这为我们构建状态机提供了基础。
async/await 本质上是基于生成器的语法糖。编译器会将 async 函数转换为一个生成器函数，并使用 yield 实现挂起和恢复的功能。
示例：简单的生成器
def my_generator():
print("First yield")
yield 1
print("Second yield")
yield 2
print("Finished")
gen = my_generator()
print(next(gen)) # Output: First yield, 1
print(next(gen)) # Output: Second yield, 2
try:
print(next(gen)) # Output: Finished, StopIteration
except StopIteration:
print("Generator finished")这个简单的生成器函数 my_generator 演示了 yield 关键字如何暂停函数的执行。每次调用 next() 函数时，生成器会从上次 yield 的位置继续执行，直到遇到下一个 yield 或函数结束。
2. async def：协程函数的定义
async def 关键字用于定义协程函数。协程函数与普通函数的区别在于，它可以包含 await 表达式，用于挂起协程的执行，等待另一个协程完成。
示例：简单的协程函数
async def my_coroutine():
print("Coroutine started")
await asyncio.sleep(1) # Simulate an asynchronous operation
print("Coroutine finished")
async def main():
await my_coroutine()
import asyncio
asyncio.run(main())在这个例子中，my_coroutine 是一个协程函数。await asyncio.sleep(1) 会挂起 my_coroutine 的执行，直到 asyncio.sleep(1) 完成。这允许其他协程在此期间运行，提高程序的并发性。
3. 编译器转换：将 async def 转换为生成器
Python 编译器会将 async def 函数转换为一个特殊的生成器函数。这个生成器函数会返回一个协程对象，该对象实现了 __await__ 方法，可以被 await 表达式使用。
为了理解这一点，我们需要查看生成的字节码。我们可以使用 dis 模块来反汇编 Python 代码，查看其字节码指令。
示例：反汇编协程函数
import dis
async def my_coroutine():
print("Coroutine started")
await asyncio.sleep(1)
print("Coroutine finished")
dis.dis(my_coroutine)输出的字节码如下 (简化版，不同 Python 版本可能略有差异):
4 0 LOAD_GLOBAL 0 (print)
2 LOAD_CONST 1 ('Coroutine started')
4 CALL_FUNCTION 1
6 POP_TOP
5 8 LOAD_GLOBAL 1 (asyncio)
10 LOAD_METHOD 2 (sleep)
12 LOAD_CONST 2 (1)
14 CALL_METHOD 1
16 GET_AWAITABLE
18 LOAD_CONST 0 (None)
20 YIELD_FROM
6 22 LOAD_GLOBAL 0 (print)
24 LOAD_CONST 3 ('Coroutine finished')
26 CALL_FUNCTION 1
28 POP_TOP
30 LOAD_CONST 0 (None)
32 RETURN_VALUE关键的字节码指令是 GET_AWAITABLE 和 YIELD_FROM。
GET_AWAITABLE: 检查asyncio.sleep(1)的返回值是否是 awaitable 对象（即实现了__await__方法）。如果不是，则抛出TypeError。YIELD_FROM: 将控制权转移给asyncio.sleep(1)返回的 awaitable 对象。YIELD_FROM负责处理 awaitable 对象的完成，并将结果返回给协程。
理解 YIELD_FROM
YIELD_FROM 是实现协程挂起和恢复的核心。当执行到 YIELD_FROM 指令时，协程会被挂起，控制权转移到 awaitable 对象。 awaitable 对象完成时（例如，asyncio.sleep(1) 完成后），它会向挂起的协程发送一个信号，通知它可以恢复执行。 YIELD_FROM 指令接收这个信号，并将 awaitable 对象的结果作为 yield 的返回值，协程就可以继续执行。
4. 协程对象的生成
当我们调用一个 async def 函数时，并不会立即执行函数体内的代码。相反，它会返回一个 协程对象。这个协程对象代表了函数的执行过程，包含了函数的状态和局部变量。
示例：协程对象的创建
async def my_coroutine():
print("Coroutine started")
await asyncio.sleep(1)
print("Coroutine finished")
coro = my_coroutine() # Create a coroutine object
print(type(coro)) # Output: <class 'coroutine'>
import asyncio
asyncio.run(coro) # Run the coroutinemy_coroutine() 返回一个 coroutine 类型的对象。这个对象本身并不是一个生成器，而是可以被 await 的对象，或者可以被 asyncio.run() 函数调度执行。
5. 协程的挂起：await 表达式的作用
await 表达式是协程挂起的关键。当遇到 await 表达式时，协程会暂停执行，直到 await 后面的 awaitable 对象完成。
Awaitable 对象的要求
一个对象要能够被 await，必须满足以下条件之一：
- 它是一个协程对象（由
async def函数返回）。 - 它定义了
__await__方法，该方法必须返回一个迭代器。 - 它定义了
__then__方法 (通常用于与 JavaScript 的 Promises 兼容)。
__await__ 方法
__await__ 方法是实现 awaitable 接口的关键。当一个对象被 await 时，Python 解释器会调用该对象的 __await__ 方法。该方法必须返回一个迭代器，通常是一个生成器对象。这个迭代器负责驱动 awaitable 对象完成，并在完成后通知协程。
示例：自定义 awaitable 对象
class MyAwaitable:
def __init__(self, value):
self.value = value
def __await__(self):
yield self.value # Yield the value for demonstration
async def my_coroutine():
print("Coroutine started")
result = await MyAwaitable(10)
print(f"Coroutine finished with result: {result}")
import asyncio
asyncio.run(my_coroutine())在这个例子中，MyAwaitable 类定义了 __await__ 方法，返回一个生成器。当 await MyAwaitable(10) 被执行时，MyAwaitable 对象的 __await__ 方法会被调用，返回的生成器被 YIELD_FROM 处理，协程会被挂起，直到生成器完成。
6. 协程的恢复：事件循环的调度
协程的恢复是由事件循环负责的。事件循环是一个单线程的循环，负责监听事件（例如，I/O 完成），并将事件分发给相应的协程。
当一个协程被 await 挂起时，事件循环会继续处理其他事件。当 awaitable 对象完成时（例如，asyncio.sleep(1) 完成后），事件循环会将挂起的协程添加到准备就绪队列中。当事件循环再次调度到该协程时，协程会从上次 await 的位置恢复执行。
asyncio.run() 的作用
asyncio.run() 函数用于创建一个事件循环，并将给定的协程添加到事件循环中进行调度。它负责启动事件循环，并处理协程的完成。
示例：事件循环的调度
import asyncio
async def task1():
print("Task 1 started")
await asyncio.sleep(2)
print("Task 1 finished")
async def task2():
print("Task 2 started")
await asyncio.sleep(1)
print("Task 2 finished")
async def main():
await asyncio.gather(task1(), task2())
asyncio.run(main())在这个例子中，asyncio.gather() 函数用于并发地执行多个协程。事件循环会交替地执行 task1 和 task2，直到它们都完成。 asyncio.sleep() 模拟了耗时的 I/O 操作，允许事件循环在等待 I/O 完成期间调度其他协程。
7. 字节码分析：挂起与恢复的细节
为了更深入地理解协程的挂起与恢复，我们再次查看字节码，并结合事件循环的调度过程进行分析。
以下是一个更详细的字节码分析示例：
import asyncio
import dis
async def my_coroutine():
print("Coroutine started")
await asyncio.sleep(1)
print("Coroutine resumed")
return "Coroutine finished"
async def main():
result = await my_coroutine()
print(result)
dis.dis(my_coroutine)
dis.dis(main)my_coroutine 的字节码（简化版）：
4 0 LOAD_GLOBAL 0 (print)
2 LOAD_CONST 1 ('Coroutine started')
4 CALL_FUNCTION 1
6 POP_TOP
5 8 LOAD_GLOBAL 1 (asyncio)
10 LOAD_METHOD 2 (sleep)
12 LOAD_CONST 2 (1)
14 CALL_METHOD 1
16 GET_AWAITABLE
18 LOAD_CONST 0 (None)
20 YIELD_FROM
6 22 LOAD_GLOBAL 0 (print)
24 LOAD_CONST 3 ('Coroutine resumed')
26 CALL_FUNCTION 1
28 POP_TOP
7 30 LOAD_CONST 4 ('Coroutine finished')
32 RETURN_VALUEmain 的字节码（简化版）：
11 0 LOAD_GLOBAL 0 (my_coroutine)
2 CALL_FUNCTION 0
4 GET_AWAITABLE
6 YIELD_FROM
8 STORE_FAST 0 (result)
12 10 LOAD_GLOBAL 1 (print)
12 LOAD_FAST 0 (result)
14 CALL_FUNCTION 1
16 POP_TOP
18 LOAD_CONST 0 (None)
20 RETURN_VALUE详细分析：
-
my_coroutine执行到YIELD_FROM:asyncio.sleep(1)返回一个 future 对象 (实现了__await__)。GET_AWAITABLE确保其是 awaitable 对象。YIELD_FROM将控制权交给这个 future。 协程my_coroutine的状态被保存，包括局部变量、程序计数器等。 -
事件循环介入: 事件循环监听
asyncio.sleep(1)对应的 future 对象。 当 1 秒后，asyncio.sleep(1)完成，future 对象的状态变为 "已完成"。 -
协程恢复: 事件循环将
my_coroutine重新加入到就绪队列。 当事件循环再次调度到my_coroutine时，YIELD_FROM指令从 future 对象获取结果 (在本例中是None, 因为asyncio.sleep没有返回值)。my_coroutine从YIELD_FROM指令的下一条指令开始继续执行。 -
main函数的处理:main函数也使用了YIELD_FROM来等待my_coroutine完成。YIELD_FROM从my_coroutine获取返回值 (字符串 "Coroutine finished") 并将其存储到局部变量result中。
总结
| 指令 | 描述 |
|---|---|
GET_AWAITABLE |
检查表达式是否为 awaitable 对象，如果不是，则抛出 TypeError。 |
YIELD_FROM |
将控制权转移给 awaitable 对象，挂起当前协程的执行，直到 awaitable 对象完成。当 awaitable 对象完成时，YIELD_FROM 获取其结果，并作为 yield 的返回值，恢复协程的执行。 |
8. 错误处理
协程中的错误处理与普通函数类似，可以使用 try...except 块。但是，需要注意的是，如果一个协程中发生了未处理的异常，它可能会导致整个事件循环崩溃。因此，建议在协程中捕获并处理所有可能发生的异常。
示例：协程中的错误处理
import asyncio
async def my_coroutine():
try:
print("Coroutine started")
await asyncio.sleep(1)
raise ValueError("Something went wrong")
print("Coroutine finished") # This line will not be executed
except ValueError as e:
print(f"Caught an exception: {e}")
async def main():
await my_coroutine()
asyncio.run(main())在这个例子中，my_coroutine 中抛出了一个 ValueError 异常，该异常被 try...except 块捕获并处理。
9. 深入理解：Task 对象与 Future 对象
asyncio 库中使用了 Task 和 Future 对象来管理协程的执行。
-
Task 对象:
Task对象是Future的子类，它封装了一个协程，并负责将其添加到事件循环中进行调度。 当你使用asyncio.create_task()或asyncio.ensure_future()创建一个任务时，实际上是创建了一个Task对象。 -
Future 对象:
Future对象代表了一个尚未完成的异步操作的结果。asyncio.sleep()等函数会返回Future对象。 你可以使用await来等待Future对象完成，或者使用future.result()来获取其结果 (如果 future 已经完成)。
示例：使用 Task 对象
import asyncio
async def my_coroutine():
print("Coroutine started")
await asyncio.sleep(1)
print("Coroutine finished")
return "Coroutine result"
async def main():
task = asyncio.create_task(my_coroutine()) # Create a Task object
print("Task created")
result = await task # Wait for the task to complete
print(f"Task result: {result}")
asyncio.run(main())在这个例子中，asyncio.create_task() 函数创建了一个 Task 对象，该对象封装了 my_coroutine 协程。 await task 会等待 my_coroutine 完成，并获取其返回值。
10. 通过掌握异步的关键元素，更好地应用并发编程
我们深入探讨了 Python 中 async/await 关键字背后的编译器转换机制，从协程对象的生成，挂起，恢复，以及字节码指令层面进行了分析。理解了 GET_AWAITABLE 和 YIELD_FROM 这两个关键的字节码指令，以及事件循环在协程调度中的作用。希望这些知识能帮助大家更好地理解和使用 Python 的异步编程特性。
更多IT精英技术系列讲座，到智猿学院