08.6 阶段 5:数据层、缓存与任务队列
所属:全栈开发面试题库 / 学习路径 / 08 Python 全栈
本页目录
一、阶段定位
阶段 4 已经能用 FastAPI + SQLAlchemy 写出带校验的 CRUD,但那是单库、单进程、请求内同步完成的理想场景。本阶段把数据层做厚:关系库的事务隔离级别、连接池参数、Redis 缓存三兄弟(穿透/击穿/雪崩)、Celery 异步任务。核心认知是「数据库是唯一可信源,缓存是性能优化,任务队列是解耦手段」——三者各自的一致性边界必须讲清楚,否则线上会出现脏读、重复订单、连接耗尽。
与前后阶段的衔接:因为阶段 4 已理解 Session 生命周期,本阶段的连接池与长事务才有抓手;因为阶段 3 已理解异常与重试,本阶段的 acks_late 与幂等设计才有基础。跳过本阶段直接进阶段 6 的异步模型,会在「同步阻塞库污染事件循环」「缓存与数据库更新顺序」上反复踩坑。
原有卡点及判断依据:
- 缓存与数据库更新顺序不当导致脏读:判断现象是先更新数据库再删缓存,并发请求读到旧缓存。见 5.3。
- 队列重复消费产生重复订单或重复通知:判断现象是 Celery 任务重试后同一个订单创建了两次。见 5.6。
- 长事务与连接池配置不当导致连接耗尽:判断现象是压测时接口开始超时,数据库
SHOW PROCESSLIST全是空闲连接。见 5.2。 - 把同步阻塞库直接放进异步任务链路:判断现象是 FastAPI 异步端点里调用
requests.get,整个事件循环卡住。见 5.5 与阶段 6。
二、阶段目标与投入
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
| 能按业务选择事务隔离级别,解释 RR 与 RC 的差别 | 能复现幻读场景并说明 |
能配置连接池参数与 pool_pre_ping,压测下不泄漏 |
压测后连接数回到基线 |
| 能识别缓存穿透/击穿/雪崩,并用对应方案解决 | 高并发下缓存命中率稳定,数据库不被打垮 |
能写 Celery 任务、配置 broker、理解 acks_late |
任务重复投递不产生脏数据 |
| 能设计幂等消费逻辑,用唯一索引兜底 | 重复投递结果一致 |
| 能列出任务积压时的排查顺序 | worker 日志、broker 队列长度、消费速率 |
建议学时:
- 全职:2.5 周,约 75 小时。事务与连接池 20 小时、Redis 缓存 20 小时、Celery 30 小时、压测与监控 5 小时。
- 在职:6–7 周,约 85 小时。
学时分配建议:SQL 与事务 20%、连接池 10%、Redis 缓存 25%、分布式锁与限流 10%、Celery 25%、积压监控 10%。
三、先修自检
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| SQLAlchemy 2.0 | 能写模型与 Session | 08.5 阶段 4 |
| HTTP 与状态码 | 能说清状态码 | 08.1 阶段 0 |
| 异常与重试 | 能抛出自定义异常 | 08.2 阶段 1 |
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| 事务与隔离级别 | RC、RR、幻读、脏读、不可重复读 | 能讲清原理 | 05.1 关系型数据库通用能力 |
| 连接池 | pool_size、max_overflow、pool_pre_ping |
会用 | 05.1 关系型数据库通用能力 |
| Redis 缓存 | 数据结构、穿透/击穿/雪崩、更新策略 | 能讲清原理 | 09.3 缓存体系 |
| 分布式锁与限流 | Redlock、滑动窗口、漏桶/令牌桶 | 会用 | 09.3 缓存体系 |
| Celery | broker、结果后端、任务路由 | 会用 | 09.4 消息队列 |
| 重试与幂等 | acks_late、退避、幂等键、唯一索引 |
能讲清原理 | 09.4 消息队列 |
| worker 与积压 | 进程分离、队列长度、消费速率 | 会用 | 09.4 消息队列 |
进度管理建议:本阶段是线上事故高发区,建议每学一个概念都在本地用 Redis 与 Celery 复现一次。《知识点全清单》「任务调度」段是全量清单。
五、分模块精讲
5.1 SQLAlchemy 查询、事务与隔离级别
为什么需要它:默认隔离级别(MySQL RR、PostgreSQL RC)不一定满足业务需求。转账、库存扣减这类场景,必须说清隔离级别下会出现什么异常。
核心机制:
- 脏读:读到未提交数据;不可重复读:同一事务内两次读同一行结果不同;幻读:同一事务内两次范围查询结果集不同。
- 隔离级别:读未提交 < 读已提交(RC)< 可重复读(RR)< 串行化。
- MySQL 默认 RR,用 MVCC 解决不可重复读,间隙锁防幻读;PostgreSQL 默认 RC。
- SQLAlchemy 用
session.execute(text("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ"))或 engine 参数设置。
最小可运行示例:
from sqlalchemy import create_engine, text
engine = create_engine(
"postgresql+psycopg://user:pass@localhost/db",
isolation_level="REPEATABLE READ", # 引擎级默认
)
# 转账:必须在同一事务内扣减
with engine.begin() as conn:
conn.execute(
text("UPDATE accounts SET balance = balance - :amt WHERE id = :from"),
{"amt": 100, "from": 1},
)
conn.execute(
text("UPDATE accounts SET balance = balance + :amt WHERE id = :to"),
{"amt": 100, "to": 2},
)
# 出错自动 rollback
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 转账出现负余额 | 没在事务内检查余额 | 用 WHERE balance >= :amt 条件更新 |
| 幻读导致插入重复 | RR 下范围查询不可靠 | 加唯一索引或用间隙锁 |
面试考法:常问「RC 与 RR 的区别」。答「RC 每次语句开新快照,RR 事务内同一快照;RC 可能不可重复读,RR 解决幻读靠间隙锁」。
5.2 连接池参数与 pool_pre_ping
为什么需要它:数据库连接建立开销大,必须复用;但复用久了会被数据库或中间件断开,应用侧不知道,下次用就报错。连接池参数决定并发上限与稳定性。
核心机制:
pool_size:常驻连接数(默认 5);max_overflow:超出 pool_size 后可临时创建的连接数(默认 10)。- 总并发 =
pool_size + max_overflow;必须小于数据库max_connections。 pool_pre_ping=True:每次取连接前先发SELECT 1探活,断开的自动丢弃重建。pool_recycle:连接最大存活秒数,应小于数据库wait_timeout(MySQL 默认 8 小时)。
最小可运行示例:
engine = create_engine(
"postgresql+psycopg://user:pass@localhost/db",
pool_size=10,
max_overflow=20,
pool_pre_ping=True,
pool_recycle=3600, # 1 小时回收
)
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
SSL connection has been closed unexpectedly |
连接被数据库断开,应用不知道 | 开 pool_pre_ping |
| 压测后连接耗尽 | 总连接数超过数据库上限 | 调小 pool_size 或加数据库连接数 |
| 长事务占用连接 | 请求内做了耗时操作 | 把耗时操作移到 Celery |
面试考法:常问「连接池大小怎么设」。答「总并发 = pool_size + max_overflow;按数据库 max_connections 反推,不要超过 CPU 核数的 2–4 倍(IO 密集可调大)」。
5.3 Redis 缓存与缓存三兄弟
为什么需要它:热点数据全打数据库会被打垮。但缓存引入一致性问题,更新顺序不当会脏读;缓存失效瞬间并发请求会把数据库冲垮。
核心机制:
- 缓存穿透:查询不存在的数据,每次都打数据库;用布隆过滤器或空值缓存解决。
- 缓存击穿:热点 key 过期瞬间,大量并发同时查库;用互斥锁或逻辑过期解决。
- 缓存雪崩:大量 key 同时过期;过期时间加随机偏移解决。
- 更新策略:先更新数据库,再删缓存(Cache-Aside);不要先更新缓存。
最小可运行示例:
import redis
import time
r = redis.Redis(host="localhost", port=6379, decode_responses=True)
def get_user(uid: int) -> dict:
key = f"user:{uid}"
cached = r.get(key)
if cached:
return eval(cached) # 演示用,实际用 json
user = db.query(User).get(uid)
if not user:
r.setex(key, 60, "null") # 空值缓存防穿透
return None
r.setex(key, 300 + random.randint(0, 60), json.dumps(user.dict()))
return user
def update_user(uid: int, data: dict):
db.update(uid, data)
r.delete(f"user:{uid}") # 先更库,再删缓存
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 脏读:更新后仍返回旧数据 | 先更库再更缓存,缓存并发写冲突 | 先更库再删缓存,靠下次读重建 |
| 热点 key 过期瞬间 DB 被打垮 | 缓存击穿 | 互斥锁或逻辑过期 |
| 大量 key 同时过期 | 雪崩 | 过期时间加随机偏移 |
面试考法:常问「缓存与数据库一致性怎么保证」。答「Cache-Aside:先更库再删缓存;接受短暂不一致;强一致场景不用缓存」。
5.4 分布式锁与限流
为什么需要它:多实例部署时,本地锁管不了跨实例;限流是保护后端不被突发流量打垮。
核心机制:
- 分布式锁:
SET key value NX EX 10,释放时用 Lua 脚本保证「判断 value 再删」原子性。 - 限流:固定窗口(临界问题)、滑动窗口(平滑)、漏桶(恒定速率)、令牌桶(允许突发)。
- Redis 实现:
INCR key EXPIRE做固定窗口;Lua 脚本做滑动窗口。
最小可运行示例:
import time
import uuid
lock_key = "lock:order:123"
token = uuid.uuid4().hex
# 加锁:SET NX EX
if r.set(lock_key, token, nx=True, ex=10):
try:
# 业务逻辑
...
finally:
# 释放锁:Lua 脚本保证原子
r.eval(
"if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end",
1, lock_key, token,
)
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 锁超时业务还没做完 | 锁 TTL 太短 | 加看门狗续期(如 Redisson) |
| 误删别人的锁 | 释放时没判断 value | Lua 脚本判断 value 再删 |
面试考法:常问「Redlock 是什么、有什么争议」。答「多节点多数派加锁;Martin Kleppmann 质疑其时钟漂移问题,生产用单节点 Redis 锁 + 业务唯一键兜底更常见」。
5.5 Celery broker 与结果后端
为什么需要它:请求链路里发邮件、生成报表、调外部 API 会拖慢响应;把这些任务丢到队列,worker 异步处理,接口立即返回。
核心机制:
- broker:接收、存储、投递任务消息(Redis 或 RabbitMQ)。
- result backend:存储任务状态与返回值(Redis 或数据库)。
- worker:独立进程,从 broker 拉取任务执行。
- 任务用
@app.task装饰,task.delay(args)投递。
最小可运行示例:
# celery_app.py
from celery import Celery
app = Celery(
"tasks",
broker="redis://localhost:6379/0",
backend="redis://localhost:6379/1",
)
@app.task(acks_late=True)
def send_email(to: str, subject: str):
print(f"发送邮件到 {to}")
return "ok"
# 启动 worker
celery -A celery_app worker --loglevel=info
# 投递任务
python -c "from celery_app import send_email; send_email.delay('a@b.com', 'hi')"
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| worker 没消费任务 | broker 地址错或 worker 没起 | 看 worker 日志与 redis-cli LLEN |
| 任务结果丢失 | 没配 backend | 配 backend 或不需要结果时不配 |
面试考法:常问「broker 与 backend 的区别」。答「broker 存任务消息,backend 存执行结果;职责分离,可独立选择」。
5.6 任务重试、幂等与 acks_late
为什么需要它:网络抖动、外部 API 超时,任务失败必须重试;但重试可能重复执行,必须保证幂等。acks_late 决定任务执行完再确认,还是开始就确认。
核心机制:
acks_late=True:任务执行成功后才向 broker 确认;worker 崩溃时任务会重新投递。- 默认
acks_late=False:任务取出就确认,崩溃后任务丢失。 - 重试:
@app.task(autoretry_for=(Exception,), max_retries=3, retry_backoff=True)。 - 幂等:用唯一业务键(订单号)做去重;数据库唯一索引兜底。
最小可运行示例:
@app.task(
bind=True,
acks_late=True,
autoretry_for=(ConnectionError,),
max_retries=3,
retry_backoff=True,
)
def create_order(self, order_id: str, user_id: int):
# 幂等:先查是否已存在
if db.query(Order).filter_by(order_id=order_id).first():
return "already exists"
try:
db.create(Order(order_id=order_id, user_id=user_id))
except IntegrityError:
# 唯一索引兜底,说明重复投递
return "duplicate"
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 重复投递产生重复订单 | 消费逻辑不幂等 | 用唯一业务键 + 数据库唯一索引 |
| worker 崩溃任务丢失 | acks_late=False |
开 acks_late=True |
| 重试风暴 | 失败立即重试 | retry_backoff=True 指数退避 |
面试考法:常问「acks_late 的语义」。答「任务执行完再确认;worker 崩溃时任务重新投递,保证不丢,但可能重复执行,必须幂等」。
5.7 worker 分离与积压监控
为什么需要它:web 进程与 worker 进程资源需求不同,必须分离;任务积压时要能快速定位是 worker 不够还是任务本身慢。
核心机制:
- web 进程:跑 FastAPI/Django,CPU 与内存给接口;worker:跑 Celery,独立部署、独立扩缩。
- 队列长度:
redis-cli LLEN celery或 RabbitMQ 管理台看。 - 消费速率:worker 日志统计每秒完成任务数;积压 = 生产速率 - 消费速率。
- 任务卡死:worker 日志里看任务开始时间与结束时间;
celery -A app inspect active看正在跑的任务。
最小可运行示例:
# 查看正在执行的任务
celery -A celery_app inspect active
# 查看注册的任务
celery -A celery_app inspect registered
# 查看队列长度(Redis)
redis-cli -n 0 LLEN celery
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 队列长度持续增长 | 消费速率 < 生产速率 | 加 worker 或优化任务 |
| 任务卡住不动 | 任务里有死循环或阻塞调用 | inspect active 定位,超时 kill |
面试考法:常问「任务积压怎么排查」。答「看队列长度趋势、worker 日志、消费速率;区分是 worker 不够还是任务本身慢」。
六、分层练习
6.1 复现型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 事务隔离级别 | 复现 RC 与 RR 下两次读差异 | 能说清现象 | 2 小时 |
| 连接池配置 | 设 pool_size 与 pre_ping,压测后看连接数 | 连接数回到基线 | 1.5 小时 |
| 缓存三兄弟 | 本地复现穿透/击穿/雪崩 | 用对应方案解决 | 3 小时 |
| Celery hello | 起 worker,投递一个任务 | 任务被执行 | 1.5 小时 |
| 幂等消费 | 重复投递 create_order | 只创建一条 | 2 小时 |
6.2 改造型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 修缓存更新顺序 | 给定先更缓存后更库的代码 | 改成先更库再删缓存 | 1 小时 |
| 加分布式锁 | 给扣库存加 Redis 锁 | 并发不超卖 | 2 小时 |
| 加 acks_late | 给定默认 acks_late=False | 改成 True 并加幂等 | 1.5 小时 |
6.3 设计型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 订单系统 | 下单 + 扣库存 + 发邮件,用 Celery 解耦 | 接口立即返回,邮件异步发送 | 6 小时 |
| 缓存策略文档 | 写清哪些数据缓存、过期策略、更新方式 | 能解释一致性取舍 | 2 小时 |
| 积压排查手册 | 列出排查步骤与命令 | 可按手册操作 | 1 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
ssl connection has been closed |
连接被数据库断开 | 看错误时间 | 开 pool_pre_ping |
| 接口超时,连接数打满 | 长事务或连接池过小 | 看 SHOW PROCESSLIST |
调小 pool 或移耗时任务 |
| 脏读:更新后仍返回旧数据 | 缓存更新顺序错 | 看代码更新顺序 | 先更库再删缓存 |
| 热点 key 过期 DB 被打垮 | 缓存击穿 | 看监控 | 互斥锁或逻辑过期 |
| 重复订单 | 消费不幂等 | 看数据库唯一索引 | 用唯一键 + 索引 |
| worker 没消费任务 | broker 地址错或 worker 没起 | 看 worker 日志 | 检查 broker 与 worker |
acks_late 下任务重复执行 |
任务没写幂等 | 看业务键 | 加唯一索引 |
| 队列长度持续增长 | 消费速率 < 生产 | 看 worker 数与任务耗时 | 加 worker 或优化任务 |
八、出口条件
全部勾选后再进入 08.7 阶段 6:异步模型、高并发与性能。
- [ ] 能按业务选择隔离级别,解释 RR 与 RC 的差别
- [ ] 能配置连接池参数与
pool_pre_ping,压测下不泄漏 - [ ] 能识别缓存穿透/击穿/雪崩并解决
- [ ] 能写 Celery 任务、配置 broker、理解
acks_late - [ ] 能设计幂等消费逻辑,用唯一索引兜底
- [ ] 能列出任务积压时的排查顺序
- [ ] 能说清缓存与数据库的一致性取舍
自测题(先自己想,再看要点):
- RC 与 RR 的区别?
- 要点:RC 每次语句开新快照,RR 事务内同一快照;RC 可能不可重复读,RR 靠间隙锁防幻读。
pool_pre_ping解决什么问题?- 要点:连接被数据库断开但应用不知道,下次用报错;取连接前
SELECT 1探活。
- 要点:连接被数据库断开但应用不知道,下次用报错;取连接前
- 缓存穿透/击穿/雪崩的区别与对策?
- 要点:穿透是查不存在数据(布隆/空值缓存);击穿是热点 key 过期(互斥锁);雪崩是大量 key 同时过期(随机偏移)。
acks_late=True的语义?- 要点:任务执行完再确认;worker 崩溃会重新投递,必须幂等。
- 为什么先更库再删缓存,而不是先更缓存?
- 要点:先更缓存再更库,并发写会导致旧值覆盖新值;先更库再删缓存,下次读重建。
- 任务积压怎么排查?
- 要点:看队列长度趋势、worker 日志、消费速率;区分 worker 不够还是任务慢。
- 分布式锁为什么要用 Lua 脚本释放?
- 要点:「判断 value 再删」必须原子,否则会误删别人的锁。