罗罗编程学习记录
本页内容 展开查看

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、内存)
  • [ ] 能判断一个接口该不该改异步

自测题(先自己想,再看要点):

  1. await 到底做了什么?
    • 要点:挂起当前协程,把控制权交还事件循环;IO 完成后恢复执行。
  2. FastAPI 的 def 与 async def 区别?
    • 要点:def 放线程池,适合同步库;async def 在事件循环,必须用异步库。
  3. GIL 保护什么、不保护什么?
    • 要点:保护对象引用计数;IO 操作与 C 扩展内部释放 GIL。
  4. CPU 密集为什么用多进程不用多线程?
    • 要点:GIL 限制多线程单时刻执行字节码;多进程各自独立 GIL。
  5. RuntimeError: Event loop is closed 怎么产生?
    • 要点:在已关闭的循环里再跑协程;脚本用 asyncio.run。
  6. 压测为什么要看 P99 而不只看平均 QPS?
    • 要点:长尾请求决定用户体验;平均高可能掩盖个别慢请求。
  7. 怎么定位接口慢?
    • 要点:py-spy 看火焰图、数据库慢查询日志、tracemalloc 看内存。