python必背源代码async/await协程代码

Ada
Ada
发布时间:2026-11-18 | 4人浏览过
原创

本文梳理掌握Python async/await协程必背的核心源代码,涵盖基础启动生命周期、TaskGroup结构化并发、超时熔断控制、信号量限流以及阻塞解耦,配以清晰的架构原理图与实战注意事项。

Python 3 协程 asyncio 并发编程 核心源码 适用环境:Python 3.8+ (推荐 Python 3.11+)
python必背源代码async/await协程代码
图0:Python 协程 async/await 核心架构缩略图

编写 Python 高并发网络爬虫、API 服务与异步 I/O 应用时,async/await 协程机制是解决并发瓶颈的核心工具。协程利用单线程内的事件循环(Event Loop),在等待网络响应或文件读写时主动让出 CPU 控制权,从而在极低内存占用下支撑成千上万个并发连接。本文精选了掌握 Python 协程必须熟练默写的 5 大经典场景核心源码,逐一拆解基础启动、并发编排、超时熔断、流量控制及阻塞解耦的最佳实践。

一、协程的本质与事件循环调度原理

初学者最容易产生的一个误解是:认为用 async def 定义的函数可以直接像普通函数一样调用。但在 Python 中,直接调用协程函数只会返回一个处于挂起状态的 coroutine 对象,函数内部的代码一行都不会执行。

协程必须被提交到“事件循环”(Event Loop)中注册为任务(Task)才会真正运转。事件循环好比一个不间断运行的调度器:当某个协程执行到 await 表达式时,如果底层的网络 I/O 尚未就绪,该协程会主动把 CPU 运行权让还给事件循环,事件循环立即转去执行其他处于就绪状态的协程;一旦底层数据包到达,操作系统通知事件循环,原协程就会在上次让出的断点处无缝恢复运行。

python必背源代码async/await协程代码
图1:单线程事件循环与协程调度核心原理架构图

二、必背核心代码 1:基础协程定义与标准生命周期管理

在 Python 3.7+ 中,启动顶级协程的唯一推荐标准方式是 asyncio.run()。它会自动创建全新的事件循环、运行传入的根协程直到返回、妥善取消未完成的残留任务,并在退出时完整关闭事件循环与底层异步生成器。

import asyncio

# 1. 使用 async def 定义协程函数
async def fetch_data(item_id: int) -> dict:
    print(f"[任务 {item_id}] 开始请求远端数据...")
    # await 模拟非阻塞 I/O(不能使用同步的 time.sleep)
    await asyncio.sleep(1.0)
    print(f"[任务 {item_id}] 数据抓取完成!")
    return {"id": item_id, "status": "success"}

# 2. 定义业务主入口协程
async def main():
    # 使用 await 挂起当前协程并等待结果返回
    result = await fetch_data(101)
    print("收到主程序处理结果:", result)

# 3. 标准生命周期启动函数(Python 3.7+ 唯一推荐主入口)
if __name__ == "__main__":
    asyncio.run(main())
示例运行输出
[任务 101] 开始请求远端数据...
[任务 101] 数据抓取完成!
收到主程序处理结果: {'id': 101, 'status': 'success'}
核心细节提醒 await 只能写在 async def 函数的内部。如果尝试在普通同步函数中直接写 await,Python 解释器会在语法解析阶段直接抛出 SyntaxError: 'await' outside async function。

三、必背核心代码 2:现代结构化并发编排(TaskGroup 与 gather)

单独按顺序执行多个 await 并不能发挥协程的并发优势——如果依次执行三次等待 1 秒的协程,总耗时依然是 3 秒。要实现真正的“并发执行”,必须将多个协程同时注册到事件循环中并发推进。

在代码组织上,Python 提供了两种主要编排工具:

  • asyncio.TaskGroup(Python 3.11+ 首选推荐):提供结构化并发(Structured Concurrency)。它作为异步上下文管理器使用,一旦组内任意一个任务抛出未捕获异常,其余所有正在运行的任务都会被立即自动取消,从根本上防止任务悬空泄漏。
  • asyncio.gather(经典兼容方案):接收可变数量的协程,并发启动后按传入顺序将所有执行结果打包成列表统一返回。
python必背源代码async/await协程代码
图2:同步阻塞模式 vs 异步并发任务编排执行时序对比图

1. 现代化方案:asyncio.TaskGroup(推荐)

import asyncio
import time

async def worker(task_name: str, delay: float) -> str:
    print(f"[{task_name}] 开始执行,预估耗时 {delay}s")
    await asyncio.sleep(delay)
    print(f"[{task_name}] 执行完毕")
    return f"{task_name}_done"

async def main():
    start_time = time.perf_counter()
    tasks = []

    # 使用 TaskGroup 管理任务组生命周期
    async with asyncio.TaskGroup() as tg:
        # tg.create_task 会立即将协程封装为 Task 并提交至事件循环并发运行
        t1 = tg.create_task(worker("Task-A", 1.5))
        t2 = tg.create_task(worker("Task-B", 0.8))
        t3 = tg.create_task(worker("Task-C", 1.2))
        tasks.extend([t1, t2, t3])

    # 退出上下文管理器时,所有任务已全部完成
    results = [t.result() for t in tasks]
    total_time = time.perf_counter() - start_time
    print("并发聚合结果:", results)
    print(f"总耗时: {total_time:.2f} 秒 (以最长子任务 1.5s 为准,而非 3.5s)")

if __name__ == "__main__":
    asyncio.run(main())
示例运行输出
[Task-A] 开始执行,预估耗时 1.5s
[Task-B] 开始执行,预估耗时 0.8s
[Task-C] 开始执行,预估耗时 1.2s
[Task-B] 执行完毕
[Task-C] 执行完毕
[Task-A] 执行完毕
并发聚合结果: ['Task-A_done', 'Task-B_done', 'Task-C_done']
总耗时: 1.50 秒 (以最长子任务 1.5s 为准,而非 3.5s)

2. 经典方案:asyncio.gather 批量收集

import asyncio

async def fetch_api(endpoint: str) -> str:
    await asyncio.sleep(0.5)
    return f"Response from {endpoint}"

async def main():
    endpoints = ["/users", "/orders", "/products"]
    
    # 构造协程列表并通过解包操作 (*) 传入 gather
    # return_exceptions=True 可以确保即使某个任务报错,其他任务正常返回且不中断程序
    results = await asyncio.gather(
        *(fetch_api(ep) for ep in endpoints),
        return_exceptions=True
    )
    print("批量拉取结果集:", results)

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

四、必背核心代码 3:超时熔断与异常保护(wait_for)

网络通信存在不可控性,任何远端 API 请求都有可能遭遇网络丢包、服务端死锁或慢响应。如果不加限制地等待,某个挂起的协程将永久占用连接资源。

使用 asyncio.wait_for(coro, timeout=秒数) 可以在指定时间内等待协程结果;一旦超时,系统会自动向底层协程发送 CancelledError 终止执行,并向外抛出 TimeoutError。

import asyncio

async def slow_network_request() -> str:
    print("正在连接远端网关...")
    # 模拟耗时 5 秒的长连接请求
    await asyncio.sleep(5.0)
    return "成功获取数据"

async def main():
    try:
        # 设置最大超时阈值为 2.0 秒
        result = await asyncio.wait_for(slow_network_request(), timeout=2.0)
        print("请求成功:", result)
    except TimeoutError:
        # 注意:Python 3.11+ 中 TimeoutError 与 asyncio.TimeoutError 已统一
        print("[超时拦截] 网络请求耗时超过 2 秒限制,任务已被强制取消并安全回收!")

if __name__ == "__main__":
    asyncio.run(main())
示例运行输出
正在连接远端网关...
[超时拦截] 网络请求耗时超过 2 秒限制,任务已被强制取消并安全回收!

五、必背核心代码 4:高并发流量限流(asyncio.Semaphore)

在爬虫抓取、数据库写入或微服务调用中,“并发度越大越快”是一个严重的误区。如果瞬间发起 5000 个 HTTP 请求,会导致操作系统打开的文件描述符(fd)耗尽抛出 OSError: Too many open files,或者直接触发目标服务器的反爬与熔断封禁(HTTP 429 Too Many Requests)。

使用 asyncio.Semaphore(value) 信号量可以像控制停车场车位一样,严格限定当前同时处于执行状态的协程数量上限。

python必背源代码async/await协程代码
图3:asyncio.Semaphore 信号量并发槽位管控架构图
import asyncio

# 限制最多只允许 3 个协程同时处于活跃执行状态
semaphore = asyncio.Semaphore(3)

async def limited_worker(worker_id: int):
    # 使用 async with 语法自动申请 (acquire) 与释放 (release) 信号量槽位
    async with semaphore:
        print(f"[槽位占用] 任务 {worker_id} 获得执行权,开始下载...")
        await asyncio.sleep(1.0)
        print(f"[槽位释放] 任务 {worker_id} 下载完毕,释放配额。")
        return f"Worker_{worker_id}_OK"

async def main():
    # 模拟同时产生 9 个突发网络任务
    tasks = [limited_worker(i) for i in range(1, 10)]
    # 虽然一次性调度 9 个任务,但由于 Semaphore 约束,会以 3 个为一组分批推进
    results = await asyncio.gather(*tasks)
    print("全部限流任务处理完成,样本数:", len(results))

if __name__ == "__main__":
    asyncio.run(main())
示例运行输出(可见每批次最多 3 个并行)
[槽位占用] 任务 1 获得执行权,开始下载...
[槽位占用] 任务 2 获得执行权,开始下载...
[槽位占用] 任务 3 获得执行权,开始下载...
[槽位释放] 任务 1 下载完毕,释放配额。
[槽位释放] 任务 2 下载完毕,释放配额。
[槽位释放] 任务 3 下载完毕,释放配额。
[槽位占用] 任务 4 获得执行权,开始下载...
[槽位占用] 任务 5 获得执行权,开始下载...
[槽位占用] 任务 6 获得执行权,开始下载...
... (其余任务顺次推进)
全部限流任务处理完成,样本数: 9

六、必背核心代码 5:异步资源管理与流式迭代(async with / async for)

异步编程中同样需要保证网络 Session 连接池、数据库事务或文件句柄的平稳关闭。Python 提供了专门的 async with(异步上下文管理器)与 async for(异步迭代器)协议。

import asyncio

# 1. 自定义异步上下文管理器(实现 __aenter__ 与 __aexit__)
class AsyncDatabaseConnection:
    def __init__(self, dsn: str):
        self.dsn = dsn

    async def __aenter__(self):
        print(f"[DB] 正在建立异步连接池: {self.dsn}")
        await asyncio.sleep(0.2)
        print("[DB] 连接成功建立")
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        print("[DB] 正在安全回收数据库连接并归还连接池...")
        await asyncio.sleep(0.1)
        print("[DB] 连接池回收完毕")

# 2. 自定义异步生成器(使用 async def 与 yield)
async def async_data_stream(total_batches: int):
    for batch_id in range(1, total_batches + 1):
        await asyncio.sleep(0.3)  # 模拟分批拉取网络流
        yield f"Data_Chunk_{batch_id}"

async def main():
    # 使用 async with 确保连接即使异常也能可靠释放
    async with AsyncDatabaseConnection("postgresql://user:pass@localhost:5432/app") as db:
        print("[业务] 开始流式消费远端数据块...")
        # 使用 async for 逐批消费异步流,避免一次性将海量数据载入内存
        async for chunk in async_data_stream(3):
            print(f" -> 实时处理数据块: {chunk}")

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

七、混合编程解阻塞:使用 asyncio.to_thread 防止事件循环假死

这是异步编程中最致命的隐形陷阱:单线程事件循环最怕被同步阻塞代码硬性卡死。如果在协程函数内部直接调用了同步库(例如 requests.get()、time.sleep() 或复杂的图像计算),整个 Python 主线程就会被同步代码完全霸占。在此期间,事件循环被冻结,所有排队的几十甚至几百个并发协程都将完全停摆!

当无法找到纯异步库(如 aiohttp 或 httpx)替代、必须调用旧版同步函数时,应使用 Python 3.9+ 提供的 asyncio.to_thread,它会自动将该同步函数扔到后台独立线程池中执行,并在协程层以非阻塞的方式 await 它的返回。

import asyncio
import time

# 模拟第三方遗留的同步阻塞函数(如 requests.get 或密集计算)
def legacy_blocking_io(name: str, seconds: int) -> str:
    print(f"[同步线程] 开始执行阻塞代码: {name}")
    time.sleep(seconds)  # 同步硬阻塞
    print(f"[同步线程] 阻塞代码完成: {name}")
    return f"{name}_result"

async def background_tick():
    for i in range(3):
        print(f"  [事件循环滴答] 心跳正常执行中... (tick {i+1})")
        await asyncio.sleep(0.5)

async def main():
    # 错误做法(绝对禁止):直接在协程里调用 legacy_blocking_io() 会瞬间卡死事件循环!
    # 正确做法:使用 asyncio.to_thread 转移到工作线程池执行
    print("启动并发测试:异步心跳 + 后台线程阻塞任务")
    await asyncio.gather(
        background_tick(),
        asyncio.to_thread(legacy_blocking_io, "Task-Sync", 1.5)
    )
    print("并发混合任务执行成功,事件循环未被阻塞!")

if __name__ == "__main__":
    asyncio.run(main())
生产环境致命避坑准则 在异步代码库中,检查代码质量的第一条铁律就是:严禁出现 import time; time.sleep(...)。必须全部替换为 await asyncio.sleep(...);凡是耗时的普通同步 I/O,必须通过 asyncio.to_thread 桥接隔离。

八、核心代码全景速查与学习路径总结

掌握 Python 协程不仅是背诵 async 与 await 两个关键字,更需要建立分层的并发思维模型。下表整理了本文介绍的 5 套核心源码的功能定位与选型指导:

代码模式 / API 核心作用 典型应用场景 关键注意事项
asyncio.run(main()) 顶层启动入口与生命周期管理 命令行脚本、主程序入口启动 每个线程只能有一个主循环,禁止在已有循环中嵌套调用
async with asyncio.TaskGroup() 结构化并发编排(Python 3.11+) 批量网络请求、多源并行聚合 具备异常级联取消机制,子任务报错会统一取消同伴
asyncio.gather(*tasks) 经典批量并发结果汇总 允许部分失败的数据并行抓取 配合 return_exceptions=True 实现容错收集
asyncio.wait_for(coro, timeout) 单任务执行超时保护 远端 API 调用的网络熔断防挂死 超时会自动向底层协程注入 CancelledError 并抛出 TimeoutError
asyncio.Semaphore(N) 并发配额控制与流量限速 高并发爬虫、数据库连接数受限操作 搭配 async with sem: 确保槽位必被释放
asyncio.to_thread(func, *args) 同步阻塞代码桥接异步 调用旧版 requests、文件压缩、密码哈希 交由内置线程池执行,防止主线程事件循环卡死
python必背源代码async/await协程代码
图4:Python 协程核心知识体系与必背源代码全景总结图

九、常见报错与排查清单

  1. RuntimeWarning: coroutine '...' was never awaited:
    原因:调用了 async def 函数但没有在前面加上 await,也没有用 create_task() 注册到事件循环。
    解决:在调用处加上 await,或者使用 asyncio.create_task(...) 提交至后台执行。
  2. RuntimeError: This event loop is already running:
    原因:在已经启动的事件循环环境内部(例如 Jupyter Notebook、IPython、Tornado 或 FastAPI 的路由函数中)再次调用了 asyncio.run()。
    解决:在已有事件循环的环境中,不要调用 asyncio.run(),直接在顶层执行 await main(),或通过 loop.create_task() 派发任务。

熟练默写并理解上述 5 段核心源码及其实际运行边界,是应对 Python 异步网络编程、现代 Web 框架(FastAPI / Sanic)开发及高性能分布式数据采集的关键基石。

相关专题:

本站声明

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

Python 相关产品和应用

全部下载

专题列表