Python 3 async/await语法详解及基础用法示例

小岛来信
小岛来信
发布时间:2026-11-21 | 5人浏览过
原创

深入详解 Python 3 中 async 和 await 关键字的核心语法、事件循环运行机制、基础并发调用方法及常见避坑注意事项。

在 Python 3 中,async 和 await 关键字是构建单线程异步非阻塞并发程序的核心语法。与多线程由操作系统抢占式调度不同,异步编程采用协作式调度,当协程执行到耗时的 I/O 操作时,通过 await 主动让出 CPU 控制权,让给事件循环去执行其他就绪任务。本文将直接拆解这两个关键字的语法规则、事件循环交互机制、多任务并发调度方法以及初学者常见的同步阻塞误区。

一、核心概念:协程定义与 await 的运行原理

在 Python 中,通过在 def 前加上 async 关键字修饰的函数被称为异步函数(也称协程函数,Coroutine Function)。调用一个异步函数并不会立即执行其函数体内部的代码,而是立即返回一个协程对象(Coroutine Object)。

import asyncio

# 定义一个协程函数
async def fetch_status():
    print("开始获取数据...")
    # 模拟非阻塞 I/O 等待 1 秒
    await asyncio.sleep(1)
    print("数据获取成功")
    return {"status": 200}

# 仅调用函数并不会执行其内部逻辑
coro = fetch_status()
print(coro)  # 输出类似 <coroutine object fetch_status at 0x...>
coro.close() # 显式关闭未执行的协程以避免警告

要让协程对象的逻辑真正运行起来,必须将其挂载到事件循环(Event Loop)中。而在另一个协程内部驱动子协程的桥梁就是 await 关键字。await 后接的对象必须是可等待对象(Awaitable),主要包括:

  • 其他协程对象(通过调用异步函数获得)。
  • Task 任务(通过 asyncio.create_task() 包装,用于加入循环调度)。
  • Future 对象(代表一个尚未完成的底层异步操作状态)。

需要特别注意:await 只能出现在 async def 定义的函数体内部,在常规普通同步函数中直接使用 await 会在语法解析阶段报 SyntaxError: 'await' outside async function 错误。

Python 3 async/await语法详解及基础用法示例
图 1: 协程声明、事件循环挂载及 await 挂起与恢复执行步骤

二、程序主入口:使用 asyncio.run 运行顶级协程

在 Python 3.7 及更高版本中,运行异步程序推荐的标准入口是 asyncio.run()。该函数负责整套生命周期管理:创建新的事件循环、运行传入的顶级协程直至完成、关闭并销毁事件循环。

import asyncio

async def main():
    print("程序初始化...")
    await asyncio.sleep(0.5)
    print("执行主业务流程...")

if __name__ == "__main__":
    # Python 3.7+ 推荐标准启动方式
    asyncio.run(main())
注意事项:asyncio.run() 不能在同一个线程中已存在运行中的事件循环时再次调用。例如在 Jupyter Notebook 或部分已有异步网络框架的事件循环内部直接调用 asyncio.run() 会抛出 RuntimeError: This event loop is already running。

三、单任务与多任务:从串行到并发执行

初学者常犯的一个错误是连续编写多个 await,误以为这就实现了并发。实际上,直接 await 一个协程会导致当前代码同步等待该协程彻底执行完毕后才往下走,仍然是串行运行。

1. 串行等待与并发调度的差异

import asyncio
import time

async def worker(task_id: int, delay: float):
    print(f"任务 {task_id} 启动,预计耗时 {delay} 秒")
    await asyncio.sleep(delay)
    print(f"任务 {task_id} 完成")
    return f"结果 {task_id}"

# 串行执行示例:总耗时约为 1 + 2 = 3 秒
async def run_serial():
    start = time.perf_counter()
    res1 = await worker(1, 1.0)
    res2 = await worker(2, 2.0)
    print(f"串行总耗时: {time.perf_counter() - start:.2f} 秒")

# 并发执行示例:通过 asyncio.gather,总耗时由最长任务决定 (约 2 秒)
async def run_concurrent():
    start = time.perf_counter()
    results = await asyncio.gather(
        worker(1, 1.0),
        worker(2, 2.0)
    )
    print(f"并发返回值: {results}")
    print(f"并发总耗时: {time.perf_counter() - start:.2f} 秒")

async def main():
    print("--- 测试串行 ---")
    await run_serial()
    print("\n--- 测试并发 ---")
    await run_concurrent()

if __name__ == "__main__":
    asyncio.run(main())
Python 3 async/await语法详解及基础用法示例
图 2: 串行等待与并发调度的执行时序与总耗时对比

2. 使用 asyncio.create_task 后台调度

当需要将某个协程立即提交给事件循环调度,但后续代码不希望立即停下来等待时,可使用 asyncio.create_task() 将其封装为一个 Task 实例:

import asyncio

async def notify_user(uid: int):
    print(f"向用户 {uid} 发送通知中...")
    await asyncio.sleep(1)
    print(f"用户 {uid} 通知发送完毕")
    return "已送达"

async def main():
    # create_task 使得协程立即加入循环准备执行
    task1 = asyncio.create_task(notify_user(101))
    task2 = asyncio.create_task(notify_user(102))

    print("主业务无需等待通知完成,继续处理其他事务...")
    await asyncio.sleep(0.2)
    print("其他事务处理完毕,现在等待后台任务返回结果...")

    # 显式等待 Task 结束并获取返回值
    res1 = await task1
    res2 = await task2
    print(f"最终结果: {res1}, {res2}")

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

四、运行机制:单线程下的协作式让渡

理解 async/await 的关键在于明确其运行边界:默认情况下,整个 asyncio 事件循环完全运行在单个主线程中。异步并发的高效性只对I/O 密集型(如网络请求、数据库读写、文件操作)操作成立,并不改变单核 CPU 的计算限制。

Python 3 async/await语法详解及基础用法示例
图 3: 事件循环与协程之间的让出与调度关系架构

五、常见陷阱与避坑指南

初次使用 async/await 时,最容易出现由于混用同步库而导致整个事件循环“假死”的问题。以下列举两项最典型的问题及正确的应对方案:

1. 混用同步阻塞调用(如 time.sleep / requests)

如果在异步协程中调用了传统的同步阻塞函数,例如 time.sleep() 或同步 HTTP 客户端 requests.get(),当前线程将被直接卡死在底层系统调用上。在此期间,事件循环完全没有机会获得控制权,所有的并发任务都将被迫停摆。

import asyncio
import time
import httpx # 推荐的异步 HTTP 库

async def bad_example():
    # 错误:time.sleep 阻塞整个线程与事件循环
    time.sleep(2) 

async def good_example_timer():
    # 正确:非阻塞协作式挂起
    await asyncio.sleep(2)

async def good_example_http():
    # 正确:使用支持异步的客户端(如 httpx 或 aiohttp)
    async with httpx.AsyncClient() as client:
        resp = await client.get("https://httpbin.org/get")
        return resp.status_code

2. 在异步代码中处理 CPU 密集型任务

对于无法避免的同步阻塞库,或者高强度的密集计算(如大图像处理、加密解密),必须将其放入线程池或进程池中执行,脱离主事件循环线程。可以使用 asyncio.to_thread()(Python 3.9+):

import asyncio
import time

def sync_heavy_task(n: int) -> int:
    # 模拟耗时 CPU 计算或第三方同步库调用
    time.sleep(1)
    return n * n

async def main():
    # 将同步耗时函数委托到默认线程池,主事件循环保持非阻塞响应
    result = await asyncio.to_thread(sync_heavy_task, 42)
    print(f"计算结果: {result}")

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

六、知识总结与概念速查

回顾 Python 3 中的异步编程体系,掌握 async/await 语法的关键维度可归纳如下:

Python 3 async/await语法详解及基础用法示例
图 4: Python 3 异步核心概念与避坑要点全景速查图

通过合理使用 async 声明协程、await 进行非阻塞让渡,并借助 asyncio.gather 与 asyncio.create_task 进行多任务并发组织,即可在单个线程内以极低内存开销轻松承载成千上万的高并发 I/O 请求。

相关专题:

本站声明

本文内容仅供参考,不代表本站观点。转载或引用请注明出处。如发现内容问题,请通过联系我们页面反馈。

Python 相关产品和应用

全部下载

专题列表