08.7 阶段 6:异步模型、高并发与性能
所属:全栈开发面试题库 / 学习路径 / 08 Python 全栈
本页目录
一、阶段定位
前面阶段的代码都是同步的:请求进来,数据库查询,外部 API 调用,返回。当接口要同时调 3 个外部服务、要处理 1000 个并发请求时,同步模型会因为线程阻塞而吞吐上不去。本阶段讲清楚 Python 的并发模型:GIL 到底限制了什么、协程怎么在 IO 等待时让出控制权、为什么同步阻塞库放进异步端点会拖垮整个事件循环。同时补上性能定位工具——cProfile、py-spy、tracemalloc,以及压测指标(QPS、P95/P99、内存)。
与前后阶段的衔接:因为阶段 4 已经写了 FastAPI,本阶段的异步端点才有载体;因为阶段 5 已经理解了连接池与 Celery,本阶段的「同步阻塞库污染事件循环」才有具体例子。不理解 GIL 与协程边界,阶段 7 部署时配置 worker 数会拍脑袋;不理解性能定位方法,线上出问题只能靠猜。
原有卡点及判断依据:
- 把协程当线程理解:判断现象是写了
async def但里面调了requests.get,以为这样就是并发。实际上同步调用会阻塞事件循环。见 5.4。 - 在异步端点里调用同步阻塞库拖垮整个事件循环:判断现象是一个慢接口导致所有接口都变慢。见 5.4。
- 优化只盯平均 QPS,忽略 P99 长尾与内存增长:判断现象是平均 QPS 达标,但用户反馈偶发卡顿。见 5.7。
- CPU 密集任务强行用协程提升吞吐:判断现象是用 asyncio 跑 CPU 计算,结果比同步还慢。见 5.5。
二、阶段目标与投入
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
能解释事件循环、task 与 await 的关系 |
画出协程让出控制权的时机 |
能用 asyncio.gather 并发执行多个 IO 调用,用 Semaphore 限制并发 |
3 个 API 调用总耗时约等于最慢那个,而非三者之和 |
| 能识别同步阻塞库在异步端点中的危害,用线程池隔离 | 慢接口不阻塞其他接口 |
| 能解释 GIL 保护什么、不保护什么,CPU 密集为什么用多进程 | 能写出 RuntimeError: Event loop is closed 的原因 |
| 能用 py-spy 定位接口耗时热点 | 给出优化前后对比 |
| 能输出压测报告(QPS、P95/P99、内存) | 指标完整,能定位瓶颈 |
建议学时:
- 全职:2 周,约 60 小时。asyncio 20 小时、GIL 与并发模型 10 小时、性能工具 15 小时、压测 15 小时。
- 在职:5–6 周,约 70 小时。
学时分配建议:asyncio 基础 25%、阻塞库与边界 20%、GIL 与多进程 15%、性能定位 20%、压测指标 20%。
三、先修自检
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| FastAPI 基础 | 能写异步端点 | 08.5 阶段 4 |
| 生成器与 yield | 能写生成器 | 08.3 阶段 2 |
| HTTP 与 curl | 能发请求 | 08.1 阶段 0 |
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| asyncio | 事件循环、task、await、gather、Semaphore |
能讲清原理 | 09.1 高并发基础 |
| 阻塞库 | requests 污染事件循环、run_in_executor |
能讲清原理 | 09.1 高并发基础 |
| GIL | CPython 全局锁、IO/CPU 密集边界、多进程 | 能讲清原理 | 04.7 Python |
| 性能定位 | cProfile、py-spy、火焰图、tracemalloc | 会用 | 09.1 高并发基础 |
| 压测 | QPS、P95/P99、内存、慢请求 | 会用 | 09.1 高并发基础 |
| 缓存与慢查询 | Redis 缓存、SQL 慢查询日志 | 会用 | 09.3 缓存体系 |
进度管理建议:本阶段必须动手跑,光看不练。《知识点全清单》「并发模型」「性能」段是全量清单。
五、分模块精讲
5.1 asyncio 事件循环与 await
为什么需要它:协程不是线程,它由事件循环调度。await 遇到 IO 等待时让出控制权,事件循环去跑别的协程,IO 完成后再回来。理解这套机制,才能写对异步代码。
核心机制:
- 事件循环:注册、轮询、切换协程任务;处理 IO 完成回调。
async def定义协程函数;调用后返回协程对象,不立即执行。await:挂起当前协程,等待可等待对象(协程、Task、Future)完成,期间事件循环跑别的协程。asyncio.run(main()):在脚本入口启动事件循环。- 未 await 的协程不会执行,会报
RuntimeWarning: coroutine was never awaited。
最小可运行示例:
import asyncio
import time
async def say_after(delay: float, msg: str):
await asyncio.sleep(delay)
print(msg)
return msg
async def main():
start = time.perf_counter()
# 串行:总耗时约 3 秒
await say_after(1, "first")
await say_after(2, "second")
print(f"串行:{time.perf_counter() - start:.2f}s")
start = time.perf_counter()
# 并发:总耗时约 2 秒
await asyncio.gather(
say_after(1, "first"),
say_after(2, "second"),
)
print(f"并发:{time.perf_counter() - start:.2f}s")
asyncio.run(main())
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
RuntimeWarning: coroutine 'xxx' was never awaited |
协程函数没 await | 用 await 或 asyncio.create_task |
RuntimeError: Event loop is closed |
在已关闭的循环里再跑 | 不要跨循环复用;脚本用 asyncio.run |
面试考法:常问「await 到底做了什么」。答「挂起当前协程,把控制权交还事件循环;IO 完成后恢复执行」。
5.2 task、gather 与 Semaphore
为什么需要它:gather 并发执行多个协程,但同时发起 1000 个会把外部服务打垮;Semaphore 限制并发数。
核心机制:
asyncio.create_task(coro):把协程包装成 Task,立即调度。asyncio.gather(*coros):并发执行全部,收集结果;任一异常默认抛出。asyncio.Semaphore(n):信号量,限制同时进入临界区的协程数。- 超时:
asyncio.wait_for(coro, timeout=5.0)。
最小可运行示例:
sem = asyncio.Semaphore(10) # 最多并发 10
async def fetch_url(url: str):
async with sem: # 限制并发
async with httpx.AsyncClient() as client:
resp = await client.get(url, timeout=5.0)
return resp.status_code
async def main():
urls = ["https://example.com"] * 100
results = await asyncio.gather(
*[fetch_url(u) for u in urls],
return_exceptions=True, # 单个失败不影响其他
)
print(f"成功 {sum(1 for r in results if r == 200)}/100")
asyncio.run(main())
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 外部服务 429 | 没限制并发 | 用 Semaphore |
| 一个协程异常导致整个 gather 失败 | 默认异常传播 | return_exceptions=True |
面试考法:常问「gather 与 Task 的关系」。答「gather 内部用 create_task 包装,等待全部完成」。
5.3 异步上下文管理器与异步迭代
为什么需要它:数据库连接、HTTP 连接池这类资源,同步的 with 在异步端点里会阻塞事件循环;必须用 async with。
核心机制:
- 异步上下文管理器:实现
__aenter__/__aexit__,配合async with。 - 异步迭代器:实现
__aiter__/__anext__,配合async for。 - 数据库驱动:
async with async_session() as session:是异步 Session。
最小可运行示例:
import httpx
async def fetch_all():
async with httpx.AsyncClient() as client: # 异步上下文
resp = await client.get("https://example.com")
return resp.text
# 异步迭代:逐行读异步响应
async def stream_lines():
async with httpx.AsyncClient() as client:
async with client.stream("GET", "https://example.com/lines") as resp:
async for line in resp.aiter_lines():
if "ERROR" in line:
print(line)
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
在 async with 里用了同步文件 IO |
同步操作阻塞事件循环 | 用 aiofiles 或线程池 |
TypeError: async for requires async iterator |
对象没实现 __aiter__ |
用异步驱动的 API |
面试考法:常问「为什么异步端点不能用同步 with open(...)」。答「文件 IO 是同步阻塞,会卡住事件循环;用 aiofiles 或 run_in_executor」。
5.4 同步阻塞库污染事件循环
为什么需要它:FastAPI 异步端点里调 requests.get(同步),整个事件循环会被这一个请求阻塞,其他所有协程都要等。这是异步工程最常见的坑。
核心机制:
requests是同步库,调用时阻塞当前线程,事件循环所在线程也被卡住。- 解决:用异步 HTTP 库(
httpx.AsyncClient);或用loop.run_in_executor把同步调用丢到线程池。 - FastAPI 对同步端点(
def而非async def)会自动放到线程池执行,但async def端点里调同步库就会阻塞。
最小可运行示例:
from fastapi import FastAPI
import httpx
import requests
app = FastAPI()
# 错误:异步端点里调同步库
@app.get("/bad")
async def bad():
resp = requests.get("https://httpbin.org/delay/2") # 阻塞事件循环 2 秒
return resp.json()
# 正确 1:用异步库
@app.get("/good1")
async def good1():
async with httpx.AsyncClient() as client:
resp = await client.get("https://httpbin.org/delay/2")
return resp.json()
# 正确 2:同步端点,FastAPI 自动放线程池
@app.get("/good2")
def good2():
resp = requests.get("https://httpbin.org/delay/2")
return resp.json()
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 一个慢接口导致所有接口变慢 | 异步端点里调同步库 | 改用异步库,或改成 def 同步端点 |
| 同步数据库驱动在异步端点 | psycopg2 是同步 |
用 asyncpg 或 SQLAlchemy 异步 |
面试考法:常问「FastAPI 的 def 与 async def 区别」。答「def 放线程池执行,适合同步库;async def 在事件循环跑,必须用异步库,否则阻塞」。
5.5 GIL 与多进程/线程/协程边界
为什么需要它:GIL 是 CPython 的互斥锁,同一时刻只有一个线程执行 Python 字节码。这意味着多线程无法利用多核跑 CPU 密集任务;但 IO 等待时 GIL 会释放,多线程仍有收益。
核心机制:
- GIL 保护:Python 对象引用计数(防止并发修改)。
- GIL 不保护:IO 操作(释放 GIL)、C 扩展内部(numpy、torch 自己释放)。
- 多线程:适合 IO 密集(网络、文件、DB),GIL 在 IO 等待时释放。
- 多进程:适合 CPU 密集,每个进程独立 GIL;内存开销大,进程间通信成本高。
- 协程:适合 IO 密集,用户态调度,不能绕开 GIL 做 CPU 并行。
最小可运行示例:
# CPU 密集:多进程
from concurrent.futures import ProcessPoolExecutor
def cpu_task(n: int) -> int:
return sum(i * i for i in range(n))
with ProcessPoolExecutor(max_workers=4) as ex:
results = list(ex.map(cpu_task, [10**7] * 4))
# IO 密集:协程即可,不必多进程
async def io_task():
await asyncio.sleep(1)
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| CPU 密集用多线程,速度没提升 | GIL 限制 | 用多进程或 C 扩展 |
| 多进程内存暴涨 | 每个进程复制解释器 | 减少进程数,或用共享内存 |
面试考法:常问「GIL 是什么、多线程为什么不能利用多核」。答「CPython 全局锁,同一时刻一个线程执行字节码;CPU 密集用多进程,IO 密集用多线程或协程」。
5.6 cProfile、py-spy 与 tracemalloc
为什么需要它:性能问题不能靠猜。cProfile 统计函数耗时,py-spy 采样生成火焰图,tracemalloc 跟踪内存分配。
核心机制:
- cProfile:统计每个函数调用次数与耗时,适合离线分析;开销大,不适合线上。
- py-spy:采样工具,无需重启进程,生成火焰图;适合线上定位。
- tracemalloc:标准库,跟踪 Python 内存分配,对比快照定位泄漏。
最小可运行示例:
# cProfile
python -m cProfile -o output.prof my_script.py
python -m pstats output.prof
# py-spy 采样(线上)
sudo py-spy dump --pid 12345
sudo py-spy record -o flame.svg --pid 12345
# tracemalloc 内存分析
import tracemalloc
tracemalloc.start()
snapshot1 = tracemalloc.take_snapshot()
# 做操作
...
snapshot2 = tracemalloc.take_snapshot()
top = snapshot2.compare_to(snapshot1, "lineno")
for stat in top[:10]:
print(stat)
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 内存持续上涨不下降 | 全局缓存、未关闭连接 | 用 tracemalloc 定位增长点 |
| 线上不敢用 cProfile | 开销大 | 用 py-spy 采样 |
面试考法:常问「怎么定位接口慢」。答「py-spy 看火焰图找热点;数据库慢查询日志看 SQL;tracemalloc 看内存」。
5.7 压测指标与慢查询
为什么需要它:优化不能只看平均 QPS,P95/P99 长尾与内存增长才是用户真实体验。慢查询是接口慢的常见原因。
核心机制:
- QPS:每秒请求数;P95/P99:95%/99% 请求在多少毫秒内完成。
- 压测工具:
wrk、ab、locust。 - 慢查询:数据库开启慢查询日志,定位执行时间超过阈值的 SQL。
- 连接池耗尽:压测时观察数据库连接数,确认是否达到上限。
最小可运行示例:
# wrk 压测
wrk -t4 -c100 -d30s http://127.0.0.1:8000/api/items
# 慢查询(MySQL)
# slow_query_log = ON
# long_query_time = 1
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 平均 QPS 高但 P99 很差 | 长尾请求拖慢 | 看慢查询、加缓存、优化 SQL |
| 压测后连接数不释放 | 连接泄漏 | 检查 Session 关闭逻辑 |
面试考法:常问「压测怎么看指标」。答「QPS 看吞吐,P95/P99 看长尾,内存看泄漏;三者结合定位瓶颈」。
六、分层练习
6.1 复现型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 串行与并发对比 | 复现 say_after 的串行与 gather | 总耗时差异明显 | 1 小时 |
| 阻塞库污染 | 在异步端点里调 requests.get,观察其他接口变慢 |
能复现并解释 | 1.5 小时 |
| GIL 多线程实验 | CPU 密集用多线程 vs 多进程 | 速度差异明显 | 2 小时 |
| py-spy 火焰图 | 对一个接口采样 | 生成火焰图 | 1.5 小时 |
6.2 改造型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 修阻塞调用 | 把异步端点里的 requests 改成 httpx.AsyncClient | 不阻塞事件循环 | 1.5 小时 |
| 加 Semaphore | 给批量抓取加并发限制 | 外部服务不 429 | 1.5 小时 |
| 用 tracemalloc | 定位一段内存增长的代码 | 找到泄漏点 | 2 小时 |
6.3 设计型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 压测报告 | 对一个接口压测,输出 QPS/P95/P99/内存 | 指标完整,定位瓶颈 | 3 小时 |
| 性能优化方案 | 针对一个慢接口给出优化前后对比 | 指标有改善 | 4 小时 |
| 异步改造评估 | 判断一个接口该不该改异步 | 给出理由 | 1 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
RuntimeWarning: coroutine was never awaited |
协程没 await | 看调用处 | 加 await 或 create_task |
RuntimeError: Event loop is closed |
跨循环复用 | 看事件循环创建处 | 脚本用 asyncio.run |
| 一个慢接口拖慢所有接口 | 异步端点调同步库 | 看端点是否 async def |
改异步库或 def 同步端点 |
| CPU 密集用多线程速度没提升 | GIL 限制 | 看 CPU 使用率 | 用多进程 |
| 内存持续上涨 | 全局缓存或连接泄漏 | 用 tracemalloc | 定位增长点 |
| 压测 P99 很差 | 长尾请求或慢 SQL | 看慢查询日志 | 加缓存、优化 SQL |
| 外部服务 429 | 没限制并发 | 看外部响应 | 用 Semaphore |
八、出口条件
全部勾选后再进入 08.8 阶段 7:AI 服务化落地与部署。
- [ ] 能解释事件循环、task 与
await的关系 - [ ] 能用
gather并发执行多个 IO 调用,用 Semaphore 限制并发 - [ ] 能识别同步阻塞库在异步端点中的危害
- [ ] 能解释 GIL 保护什么、不保护什么,CPU 密集为什么用多进程
- [ ] 能用 py-spy 定位接口耗时热点
- [ ] 能输出压测报告(QPS、P95/P99、内存)
- [ ] 能判断一个接口该不该改异步
自测题(先自己想,再看要点):
await到底做了什么?- 要点:挂起当前协程,把控制权交还事件循环;IO 完成后恢复执行。
- FastAPI 的
def与async def区别?- 要点:
def放线程池,适合同步库;async def在事件循环,必须用异步库。
- 要点:
- GIL 保护什么、不保护什么?
- 要点:保护对象引用计数;IO 操作与 C 扩展内部释放 GIL。
- CPU 密集为什么用多进程不用多线程?
- 要点:GIL 限制多线程单时刻执行字节码;多进程各自独立 GIL。
RuntimeError: Event loop is closed怎么产生?- 要点:在已关闭的循环里再跑协程;脚本用
asyncio.run。
- 要点:在已关闭的循环里再跑协程;脚本用
- 压测为什么要看 P99 而不只看平均 QPS?
- 要点:长尾请求决定用户体验;平均高可能掩盖个别慢请求。
- 怎么定位接口慢?
- 要点:py-spy 看火焰图、数据库慢查询日志、tracemalloc 看内存。