博客后端并发优化实录：从 SQLite 48 req/s 到 PostgreSQL 323 req/s

1334 字

7 分钟

博客后端并发优化实录：从 SQLite 48 req/s 到 PostgreSQL 323 req/s

2026-04-19

折腾

postgresql

/

linux

狛荷屋主站后端基于 FastAPI + SQLAlchemy 构建，之前的项目使用 SQLite 作为数据库、单 Worker 运行。主站评论功能引入递归 CTE 查询，考虑到后期的可扩展性, 构建时选用了PostgreSQL。本文记录了从 SQLite 迁移到 PostgreSQL，并发优化的完整过程。

起点：SQLite + 单 Worker#

最初的架构非常简单：

数据库：SQLite（文件型数据库）
运行方式：uvicorn main:app，单 Worker 单进程
压测结果：

1
wrk -t2 -c32 -d10s
2
Requests/sec: 48

SQLite 在并发写入时有全局锁，且不支持异步连接池，成为最大瓶颈。

第一步：迁移到 PostgreSQL#

将数据库从 SQLite 替换为 PostgreSQL，使用 asyncpg 驱动 + SQLAlchemy 异步引擎：

1
engine = create_async_engine(
2
    "postgresql+psycopg://user:pass@localhost:5432/blog",
3
    pool_size=10,
4
    max_overflow=20,
5
    pool_timeout=30,
6
    pool_pre_ping=True,
7
)

迁移后，单 Worker 压测：

1
wrk -t2 -c32 -d10s
2
Requests/sec: ~255

提升约 5.3 倍。PostgreSQL 原生支持并发连接和异步查询，递归 CTE 的执行效率也远优于 SQLite。

第二步：部署 Gunicorn 多 Worker#

生产环境使用 Gunicorn 启动 4 个 Uvicorn Worker：

1
gunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker

4 个 Worker = 4 个独立 Python 进程，每个进程有自己的事件循环，可以充分利用多核 CPU。

第三步：发现高并发瓶颈#

部署后用 wrk 进行压力测试，发现问题：

1
wrk -t4 -c2048 -d10s
2
  Latency     1.49s   302.09ms   2.00s
3
  Socket errors: timeout 481
4
Requests/sec: 285.63

低并发时响应约 10ms，高并发时飙升到 200ms+，还出现大量超时。于是开始排查。

瓶颈分析#

瓶颈一：日志线程池串行化（最致命）#

原始的日志函数：

1
log_executor = ThreadPoolExecutor(max_workers=1)  # 只有 1 个线程！
2

3
async def async_log(logger_obj, level, message):
4
    def _log():
5
        getattr(logger_obj, level)(message)
6
    loop = asyncio.get_event_loop()
7
    await loop.run_in_executor(log_executor, _log)  # await = 等日志写完

每个请求在中间件中调用 2 次 await async_log。await 意味着协程会挂起并排队等待日志写完。线程池只有 1 个线程时，2048 个请求的日志调用排成长队，所有协程都卡在 await 上。

这是延迟飙升的最主要原因。

瓶颈二：数据库连接池不足#

1
pool_size=10, max_overflow=20  # 最多 30 个并发 DB 连接

当 2048 个请求同时到达，大量请求在等待连接池释放，pool_timeout=30 导致超时前长时间挂起。

瓶颈三：请求日志中间件开销#

中间件对每个请求都执行：

读取并解析请求 body
序列化完整 headers + body 为 JSON
2 次阻塞式日志写入

高并发下叠加效果显著。

优化措施#

优化一：日志改为 Fire-and-Forget#

核心思路：日志提交到线程池后不等待完成，请求立即继续处理。

1
log_executor = ThreadPoolExecutor(max_workers=4)  # 1 → 4
2

3
def async_log(logger_obj, level, message):
4
    def _log():
5
        getattr(logger_obj, level)(message)
6
    try:
7
        loop = asyncio.get_running_loop()
8
        loop.run_in_executor(log_executor, _log)  # 不 await！
9
    except RuntimeError:
10
        _log()

关键区别：

之前：await run_in_executor → 协程挂起等日志写完 → 高并发下排队
之后：run_in_executor 不 await → 日志任务扔进线程池，请求立刻返回

优化二：增大数据库连接池#

1
engine = create_async_engine(
2
    DATABASE_URL,
3
    pool_size=20,       # 10 → 20
4
    max_overflow=40,    # 20 → 40
5
    pool_timeout=10,    # 30 → 10，避免长时间挂起
6
    pool_pre_ping=True,
7
)