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

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
  • [ ] 能设计幂等消费逻辑,用唯一索引兜底
  • [ ] 能列出任务积压时的排查顺序
  • [ ] 能说清缓存与数据库的一致性取舍

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

  1. RC 与 RR 的区别?
    • 要点:RC 每次语句开新快照,RR 事务内同一快照;RC 可能不可重复读,RR 靠间隙锁防幻读。
  2. pool_pre_ping 解决什么问题?
    • 要点:连接被数据库断开但应用不知道,下次用报错;取连接前 SELECT 1 探活。
  3. 缓存穿透/击穿/雪崩的区别与对策?
    • 要点:穿透是查不存在数据(布隆/空值缓存);击穿是热点 key 过期(互斥锁);雪崩是大量 key 同时过期(随机偏移)。
  4. acks_late=True 的语义?
    • 要点:任务执行完再确认;worker 崩溃会重新投递,必须幂等。
  5. 为什么先更库再删缓存,而不是先更缓存?
    • 要点:先更缓存再更库,并发写会导致旧值覆盖新值;先更库再删缓存,下次读重建。
  6. 任务积压怎么排查?
    • 要点:看队列长度趋势、worker 日志、消费速率;区分 worker 不够还是任务慢。
  7. 分布式锁为什么要用 Lua 脚本释放?
    • 要点:「判断 value 再删」必须原子,否则会误删别人的锁。