数据库连接池总被打满?FastAPI0.163终于给出官方解法

admin 2026-11-20 09:00:23 网络安全文章 来源:ZONE.CI 全球网 0 阅读模式

数据库连接池总被打满?FastAPI 0.163 终于给出官方解法

原创

didiplus
didiplus

攻城狮成长日记

2026年11月16日 21:22
广东

去阅读

NEW预计阅读 10 分钟 · 共 3671 字

数据库连接池总被打满?FastAPI 0.163 终于给出官方解法

FastAPI 0.163.0 新特性

FastAPI#并发限制#连接池保护

READING PATH

阅读路线

7 个章节

01

前言

-

02

为什么需要 max\_concurrency

-

03

基本用法

-

04

完整案例:保护数据库连接池

-

05

重要注意事项

-

06

适用场景总结

-

07

结语

CHAPTER 01

01前言INTRODUCTION

2026 年 11 月 14 日,FastAPI 正式发布 0.163.0 版本,带来了一个看似简单却极其实用的新参数——Depends 的 max_concurrency。

这个功能解决的是生产环境中非常常见的一类问题:在高并发场景下,如何优雅地限制某个依赖的并发使用数量,从而保护后端连接池,避免资源耗尽甚至死锁。

本文将从问题背景出发,完整讲解这个特性的原理、使用方式,并通过真实对比案例 + 图表,直观展示它的实际价值。

CHAPTER 02

02为什么需要 max\_concurrencyPROBLEM

在 FastAPI 中,我们经常会写这样的数据库依赖:

python

def get\_session():

with Session(engine) as session:

yield session

这是非常标准的写法。但在高并发场景下,它存在几个隐患:

RISKS

三大隐患

1

连接池被瞬间打满

假设连接池大小是 5,瞬时并发 30,很容易导致连接池耗尽,后续请求全部超时失败

2

死锁风险

多个请求同时获取多个资源,在资源有限的情况下形成互相等待的死锁

3

线程/协程资源浪费

传统限流方式阻塞线程,进一步降低系统吞吐量

max_concurrency 的设计目标:在依赖层面直接控制\"同时能跑多少个这个依赖\",并且等待过程不占用工作线程

CHAPTER 03

03基本用法USAGE

从 FastAPI 0.163.0 开始,Depends 增加了 max_concurrency 参数:

python

from typing import Annotated

from fastapi import Depends

SessionDep = Annotated[

Session,

Depends(get\_session, max\_concurrency=5)

]

含义非常直观:

HOW IT WORKS

运行机制

1

同时最多 5 个请求

同时最多允许 5 个请求持有这个依赖(即打开 5 个 Session)

2

第 6 个请求等待

进入等待状态,直到有一个 Session 被释放

3

不占用 worker 线程

等待过程不会占用 worker 线程,其他请求仍可正常处理

如果依赖使用了 yield(常见于数据库会话),那么并发计数会一直持续到 yield 之后的清理代码执行完毕。

CHAPTER 04

04完整案例:保护数据库连接池BENCHMARK

下面通过一个完整可运行的例子,对比加入 max\_concurrency 前后在高并发下的表现差异。

01

基础代码准备

python

from typing import Annotated, Generator, Optional

from fastapi import Depends, FastAPI, HTTPException

from sqlmodel import SQLModel, Field, Session, create\_engine, select

import time

class Item(SQLModel, table=True):

id: Optional[int] = Field(default=None, primary\_key=True)

name: str

description: Optional[str] = None

故意把连接池设得很小,方便观察差异

engine = create\_engine(

\"sqlite:///./test.db\",

connect\_args={\"check\_same\_thread\": False},

pool\_size=5,          # 只允许 5 个连接

max\_overflow=0,       # 不允许额外溢出

pool\_timeout=3# 拿不到连接就快速超时

)

def create\_db\_and\_tables():

SQLModel.metadata.create\_all(engine)

def get\_session() -> Generator[Session, None, None]:

with Session(engine) as session:

模拟业务耗时,让并发冲突更明显

time.sleep(0.3)

yield session

02

版本 A:没有加 max\_concurrency

python

传统写法:没有任何并发限制

SessionDep\_NoLimit = Annotated[Session, Depends(get\_session)]

app\_no\_limit = FastAPI()

@app\_no\_limit.on\_event(\"startup\")

def on\_startup():

create\_db\_and\_tables()

@app\_no\_limit.get(\"/items/\")

def read\_items\_no\_limit(session: SessionDep\_NoLimit):

items = session.exec(select(Item)).all()

return {\"count\": len(items), \"status\": \"ok\"}

03

版本 B:加入 max\_concurrency=5

python

新写法:限制最多同时持有 5 个 Session

SessionDep\_WithLimit = Annotated[

Session,

Depends(get\_session, max\_concurrency=5)

]

app\_with\_limit = FastAPI()

@app\_with\_limit.on\_event(\"startup\")

def on\_startup():

create\_db\_and\_tables()

@app\_with\_limit.get(\"/items/\")

def read\_items\_with\_limit(session: SessionDep\_WithLimit):

items = session.exec(select(Item)).all()

return {\"count\": len(items), \"status\": \"ok\"}

04

高并发压测对比(30 个并发请求)

我们用 30 个并发请求同时打这两个接口(连接池大小只有 5),结果差异非常明显。

从图中可以清晰看到:

●未使用max_concurrency:只有 7 个请求成功,23 个请求失败或超时

●使用max_concurrency=5:全部 30 个请求均成功返回

●红色线(未限制):请求瞬间涌入,连接池被迅速打满到 5,后续请求大量失败

●绿色线(有限制):FastAPI 在依赖层就把并发控制在 5 个以内,多余请求在依赖解析阶段优雅排队,不会去抢数据库连接

从图中可以清晰看到:

●红色虚线(未限制):请求瞬间涌入,连接池被迅速打满到 5,后续请求大量失败。

●绿色实线(有限制):FastAPI 在依赖层就把并发控制在 5 个以内,多余请求在依赖解析阶段优雅排队,不会去抢数据库连接,也不会占用额外的 worker 线程。

指标 未使用 max\_concurrency 使用 max\_concurrency=5
成功请求数 7 30
失败请求数 23 0
峰值连接数 5(已打满) 5(受控)
系统稳定性评分 2 分 9 分

05

现象解读

BEFORE

没有加 max\_concurrency

  • 30 个请求几乎同时到达,全部尝试从连接池拿 Session

  • 连接池只有 5 个名额,后面的请求在 pool_timeout=3 后直接失败

  • 大量请求以异常结束,客户端看到超时或错误

  • 即使把 pool_timeout 调大,也只是把失败变成长时间阻塞,worker 线程被占满,整体吞吐量反而下降

AFTER

加入 max\_concurrency=5

  • FastAPI 在依赖解析阶段就限制了最多 5 个请求能同时进入 get_session

  • 其余请求在依赖层排队等待,不会去抢数据库连接

  • 等待过程不占用 worker 线程,其他接口依然能正常服务

  • 所有 30 个请求最终都能成功返回,只是后面的请求延迟会高一些(预期内的保护行为)

CHAPTER 05

05重要注意事项CAVEATS

CAVEATS

五大注意事项

1

必须复用同一个 Depends 对象

正确写法用 Annotated 定义一次复用;错误写法每个路由独立限制,总并发会成倍放大

2

限制按进程/事件循环隔离

多 worker 时每个 worker 有自己的限制,如 max\_concurrency=5 + 4 workers = 最多 20 个 Session

3

yield 依赖的生命周期

并发槽位会一直占用到退出代码执行完毕,可通过 scope 参数控制清理时机

4

避免同一请求内死锁

一个请求多次获取同一个受限依赖且 use\_cache=False 可能死锁,建议按固定顺序获取

5

与连接池大小的关系

max\_concurrency 应该 ≤ 数据库连接池可用连接数,并预留一部分给系统其他用途

WARNING

必须复用同一个 Depends 对象

Depends#复用#并发额度

错误写法会让每个路由各自拥有 5 个并发额度,总并发会成倍放大。务必用 Annotated 定义一次,全局复用。

01

✅复用同一个 Depends 对象

python

SessionDep = Annotated[Session, Depends(get\_session, max\_concurrency=5)]

02

❌每个路由独立限制

python

def read\_items(session: Session = Depends(get\_session, max\_concurrency=5)):

...

CHAPTER 06

06适用场景总结SCENARIOS

数据库 Session 保护外部 HTTP 客户端文件句柄/临时资源

纯 CPU 计算依赖无状态轻量依赖

场景 推荐使用 max\_concurrency
数据库 Session 保护 ✅ 强烈推荐
外部 HTTP 客户端(有限连接数) ✅ 推荐
文件句柄 / 临时资源 ✅ 可用
纯 CPU 计算依赖 一般不需要
无状态、轻量依赖 通常不需要

CHAPTER 07

07结语CONCLUSION

max_concurrency 的价值不在于\"让每个请求都更快\",而在于在资源有限时,用可控的排队换取系统的整体稳定性

对于已经使用 FastAPI 的团队来说,升级到 0.163.0 并给关键的资源依赖加上合理的并发限制,是成本极低、收益明显的优化手段。建议在生产环境中,针对数据库会话、第三方 API 客户端等资源,优先评估并加上 max_concurrency。

FastAPI 官方文档 - Limit dependency concurrency[1]

GET STARTED

准备好升级你的 FastAPI 项目了吗?

立即升级到 0.163.0

感谢你的阅读与支持!

如果有实际压测数据或遇到特殊场景,欢迎交流~ 💚

· 点赞 ·

喜欢就点个赞吧

· 转发 ·

分享给更多朋友

· 推荐 ·

推荐给身边的人

参考资料

[1]FastAPI 官方文档:https://fastapi.tiangolo.com/advanced/advanced-dependencies/#limit-dependency-concurrency

英国国家网络部队新总部揭幕:能力升级与“准备不足”警告并行 网络安全文章

英国国家网络部队新总部揭幕:能力升级与“准备不足”警告并行

英国国家网络部队新总部揭幕,展示网络能力建设进展,同时上议院委员会警告网络威胁准备不足。NCF成立旨在整合进攻性网络能力,支持军事行动和防范国家威胁。新总部在萨姆斯伯里,预计到2030年投入50亿英镑。然而,报告指出英国对网络威胁准备不足,政府需快速行动提升网络安全与韧性。
评论:0   参与:  0