高阶问题(AI 工程师)
Python 与 FastAPI 与后端 100 题
AI 工程师面试题库 · 第二批(题号 101–200):Python 语言核心、FastAPI、Python 后端进阶、MySQL、Redis、RabbitMQ 与消息队列、Elasticsearch。
- 面试
- AI 工程师
- Python
AI 工程师面试题库 · 第二批:Python、FastAPI、MySQL 深入、Redis 深入、RabbitMQ、Elasticsearch
目录
-
- 100. list、tuple、dict、set 的区别与选型?
- 101. 浅拷贝与深拷贝?
- 102. 装饰器的原理与常见实现?
- 103. 迭代器、生成器与可迭代对象?
- 104. GIL 是什么?对多线程的影响与绕过方案?
- 105. asyncio 的核心模型与常见坑?
- 106. Python 类型注解与 pydantic?
- 107. Python 异常处理与资源管理?
- 108. Python 内存管理与引用计数?
- 109. Python 的 MRO 与多继承?
- 110.
*args/**kwargs与函数参数的完整规则? - 111. Python 闭包与 LEGB 作用域?
- 112. Python 反射:
getattr/setattr与动态分发? - 113. Python 推导式与生成器表达式的性能?
- 114. walrus 运算符
:=与 match-case?
-
- 115. FastAPI 为什么”快”?async 路由与 def 路由的区别?
- 116. 请求校验:Query/Path/Body 与 pydantic 约束?
- 117. 依赖注入:Depends 的机制与应用?
- 118. 中间件、异常处理与统一响应?
- 119. 流式接口:SSE 在 FastAPI 的正确实现?
- 120. 后台任务与定时调度?
- 121. SQLAlchemy 2.0:异步引擎与 ORM 会话?
- 122. pytest:测试 FastAPI 应用?
- 123. Pydantic v2:校验、序列化与 Settings?
- 124. FastAPI + LLM:网关层的限流与计费?
-
- 125. Python 并发实战:线程池与进程池的选择?
- 126. Python 侧调用 LLM:超时、重试与降级?
- 127. Python 日志:logging 的正确配置?
- 128. Python 项目工程化:venv/依赖/项目结构?
- 129. Python 性能剖析:cProfile 与内存热点?
- 130. 同步阻塞库怎么在 asyncio 里用?
- 131. 数据库连接池在异步服务的正确姿势?
- 132. Python 侧的数据库迁移(Alembic)?
- 133. Python 的 uv 与依赖管理现代化?
- 134. Python 的 dataclass 与 @property 的工程用法?
- 135. Python 环境变量与 12-Factor 配置?
- 136. Python 的 IO 多路复用与 asyncio 的关系?
- 137. Python 的多进程通信与共享状态?
- 138. Python 的结构化并发与任务取消?
- 139. Python 服务的优雅停机与信号处理?
- 140. 类型注解进阶(Protocol/泛型/TypeVar)?
- 141. 描述符与属性查找链?
- 142. functools 与迭代工具箱?
- 143. 单例模式的 Pythonic 实现?
- 144. 上下文管理器进阶(ExitStack/async with)?
-
- 145. 索引的底层数据结构:B+ 树为什么赢?
- 146. 事务的 ACID 与隔离级别?
- 147. 锁机制:行锁、间隙锁与死锁排查?
- 148. MVCC 实现原理:ReadView 与版本链?
- 149. EXPLAIN 执行计划:慢查询调优的入口?
- 150. 大表 DDL: Online DDL 与 gh-ost?
- 151. 主从复制与读写分离?
- 152. 分库分表:什么时候分与怎么分?
- 153. 大表深分页优化?
- 154. 连接池与 MySQL 参数调优?
- 155. InnoDB 的 Change Buffer 与唯一索引选型?
- 156. 自增主键的空洞与 ID 生成策略?
- 157. COUNT(*)、ORDER BY 与 GROUP BY 的优化?
- 158. 慢查询系统化治理流程?
- 159. JSON 字段与生成列的实战?
- 160. InnoDB 的内存结构:Buffer Pool 与脏页刷新?
- 161. 二级索引与索引下推(ICP)?
- 162. MySQL 的 undo log 与长事务治理?
- 163. MySQL 分区表的使用与陷阱?
- 164. MySQL 的 redo log 与崩溃恢复?
-
- 165. Redis 的过期时间与内存碎片?
- 166. Redis 的 SCAN 与渐进遍历?
- 167. Redis 的 BITMAP 与 HyperLogLog?
- 168. Redis 的 GEO 与地理位置?
- 169. Redis 的慢查询与大命令排查?
- 170. Redis 数据结构与业务映射?
- 171. 缓存三大经典问题:穿透、击穿、雪崩?
- 172. 缓存与数据库一致性:Cache Aside 与延迟双删?
- 173. Redis 持久化:RDB 与 AOF?
- 174. Redis 高可用:主从、哨兵与集群?
- 175. Redis 的内存淘汰策略怎么选?
- 176. 热点 Key 与大 Key 的治理?
- 177. Redis 的发布订阅与 Stream?
- 178. Redis 的 Lua 脚本与事务( MULTI/EXEC)?
- 179. Redis 的 pipeline 与连接管理?
一、Python 语言核心(100–114)
本章 15 题:数据结构选型、深浅拷贝、装饰器、迭代器与生成器、GIL、asyncio、类型注解、异常与资源管理、内存管理、MRO、参数规则、闭包与 LEGB、反射、推导式性能、walrus 与 match-case。
100. list、tuple、dict、set 的区别与选型?
概念 list 可变有序序列;tuple 不可变有序序列;dict 哈希表键值对;set 无序唯一集合。
典型场景 需要按 key 快速查询(dict)、去重与集合运算(set)、固定结构数据(tuple)、日常列表操作(list)。
解决方案 分三步递进:先看复杂度对比 → 再看一个互相转换的实际例子 → 最后看不可变性的工程价值。
第一步:复杂度对比——选型的唯一依据
# 文件: complexity_demo.py
lst = [1, 2, 3]
dct = {"a": 1, "b": 2}
st = {1, 2, 3}
# list: 索引 O(1), 中间插入/删除 O(n), in 判断 O(n)
# dict/set: 查询/插入/删除平均 O(1)
# tuple: 不可变, 可哈希 → 能当 dict 的 key
print(1 in lst, 1 in st) # True True —— 但 st 是 O(1), lst 是 O(n)
第二步:实战转换——接口入参去重并保持顺序
# 文件: dedupe_order.py
def dedupe(ids: list[int]) -> list[int]:
seen = set() # set 做 O(1) 查重
result = []
for i in ids:
if i not in seen:
seen.add(i)
result.append(i) # list 保持顺序
return result
print(dedupe([3, 1, 3, 2, 1])) # [3, 1, 2]
第三步:tuple 的工程价值——固定结构 + 可哈希
# 文件: tuple-usage.py
point = (116.4, 39.9) # 坐标: 结构固定, 不该被改
locations = {point: "北京"} # tuple 可做 dict key, list 不行
print(locations[point])
总结:查询密集用 dict/set,保序用 list,固定结构用 tuple。复杂度表是选型的唯一依据。
追问1:list 和 tuple 能做 dict 的 key 吗? → list 不行(不可哈希),tuple 可以 追问2:set 和 dict 的关系? → dict 就是只有键没有值的 set,底层同为哈希表 追问3:为什么 dict 查询是 O(1)? → 哈希函数直接算出桶位置,无需遍历
101. 浅拷贝与深拷贝?
概念 浅拷贝(copy.copy)只复制最外层容器,内部嵌套对象共享引用;深拷贝(copy.deepcopy)递归复制所有层级。
典型场景 修改副本导致原数据被改(常见事故)、配置快照、回滚状态。
解决方案 三步递进:复现事故 → 一行修复 → deepcopy 的循环引用处理。
第一步:事故复现——浅拷贝的内层是共享的
# 文件: shallow_bug.py
import copy
config = {"db": {"host": "localhost"}, "retries": 3}
cfg2 = copy.copy(config) # 浅拷贝
cfg2["db"]["host"] = "prod-db"
print(config["db"]["host"]) # prod-db —— 原配置被改了!
第二步:一行修复——deepcopy 隔离所有层级
# 文件: deep_copy_fix.py
import copy
config = {"db": {"host": "localhost"}, "retries": 3}
cfg2 = copy.deepcopy(config)
cfg2["db"]["host"] = "prod-db"
print(config["db"]["host"]) # localhost —— 原配置安全
第三步:deepcopy 的循环引用——内部靠 memo 字典防死循环
# 文件: deep_copy_cycle.py
import copy
a = {"self": None}
a["self"] = a # 循环引用
b = copy.deepcopy(a)
print(b["self"] is b, b is not a) # True True —— 结构保留且独立
# deepcopy 内部用 memo 字典记录"已拷贝对象 → 副本"映射, 遇循环直接取副本
总结:嵌套可变结构一律 deepcopy;纯不可变/单层结构浅拷贝足够。性能敏感时只 deepcopy 需要隔离的子树。
追问1:deepcopy 和 JSON 序列化拷贝的区别? → deepcopy 保留对象类型(Date/自定义类),JSON 只支持纯数据且键必须为 str
追问2:什么场景浅拷贝反而是对的? → 大列表只需替换元素而非修改元素时,浅拷贝 O(n) 且省内存
追问3:b = a[:] 是深拷贝吗? → 不是,切片是浅拷贝,嵌套对象仍共享
102. 装饰器的原理与常见实现?
概念 装饰器是接收函数并返回新函数的高阶函数,在不修改原函数代码的前提下叠加行为。@dec 等价于 f = dec(f)。
典型场景 日志、耗时统计、重试、权限校验、缓存——所有”每个函数都要”的横切逻辑。
解决方案 四步递进:最小装饰器 → 带 functools.wraps → 带参数的装饰器(三层) → 实战:重试装饰器。
第一步:最小装饰器——看穿语法糖
# 文件: deco-basic.py
def timer(fn):
def wrapper(*args, **kwargs):
import time
start = time.time()
result = fn(*args, **kwargs) # 调用原函数
print(f"{fn.__name__} 耗时 {time.time()-start:.3f}s")
return result
return wrapper
@timer # 等价于 fetch = timer(fetch)
def fetch():
import time; time.sleep(0.5)
return "data"
fetch() # fetch 耗时 0.501s
第二步:functools.wraps——不写会丢什么
# 文件: deco-wraps.py
from functools import wraps
def timer(fn):
@wraps(fn) # 保留原函数的 __name__/__doc__/签名
def wrapper(*args, **kwargs):
return fn(*args, **kwargs)
return wrapper
@timer
def fetch(): "拉取数据"
print(fetch.__name__) # fetch(不加 wraps 会变成 'wrapper')
第三步:带参数的装饰器——三层嵌套
# 文件: deco-retry.py
import time, random
from functools import wraps
def retry(times=3, delay=1.0): # 第一层: 收装饰器参数
def decorator(fn): # 第二层: 收函数
@wraps(fn)
def wrapper(*args, **kwargs): # 第三层: 真正执行
for i in range(times):
try:
return fn(*args, **kwargs)
except Exception as e:
if i == times - 1:
raise
sleep_for = delay * (2 ** i) # 指数退避
print(f"第{i+1}次失败({e}), {sleep_for:.1f}s 后重试")
time.sleep(sleep_for)
return wrapper
return decorator
@retry(times=3, delay=0.5)
def call_api():
if random.random() < 0.7:
raise ConnectionError("超时")
return "ok"
print(call_api())
总结:装饰器 = f = dec(f) 的语法糖;写带参数的装饰器记住”三层收参数”;@wraps 必写,否则调试和框架反射全乱。
追问1:装饰器在什么时候执行? → import 时(定义阶段)执行装饰,调用时执行 wrapper
追问2:类装饰器怎么写? → 实现 __init__(self, fn) 和 __call__,实例可调用
追问3:多个装饰器的执行顺序? → 自下而上装饰、自上而下执行(@a @b def f 等价 f = a(b(f)))
103. 迭代器、生成器与可迭代对象?
概念 可迭代对象(Iterable)实现了 __iter__;迭代器(Iterator)额外实现 __next__;生成器(Generator)是 yield 函数的产物,天然是迭代器。
典型场景 大文件逐行读取、惰性分页、无限序列、自定义可遍历结构。
解决方案 三步递进:三者的关系判定 → 生成器的惰性价值 → 实战:逐块读取大文件。
第一步:关系判定——可迭代 ≠ 迭代器
# 文件: iter-types.py
lst = [1, 2, 3]
print(iter(lst)) # list_iterator —— 可迭代对象, iter() 后变迭代器
it = iter(lst)
print(next(it), next(it)) # 1 2 —— 迭代器才有 next
# 关系: for 循环 = iter(对象) + 反复 next() 直到 StopIteration
第二步:生成器的惰性价值——不取不算
# 文件: gen-lazy.py
def read_huge(path):
with open(path) as f:
for line in f: # 文件对象本身就是惰性迭代器, 逐行产出
yield line.strip()
# 对比: lines = f.readlines() 会一次性读入整文件(几个 GB 直接 OOM)
for line in read_huge("access.log"):
if "ERROR" in line:
print(line)
第三步:实战——生成分页参数序列
# 文件: gen-pages.py
def pages(total, size=100):
page = 0
while page * size < total:
yield {"page": page, "size": size}
page += 1
# 只在需要时生成下一页参数
for p in pages(10_000):
data = fetch_page(p) # fetch_page 为项目内函数
if not data:
break
总结:可迭代是”能被 for”,迭代器是”能被 next”,生成器是”写起来最省事的迭代器”。大数据处理一律惰性。
追问1:yield 和 return 的区别? → return 终止并返回;yield 暂停并交出值,下次从暂停处继续,函数状态保留
追问2:生成器能提前终止吗? → 可以,gen.close() 触发 GeneratorExit;或用 break 丢弃引用由 GC 处理
追问3:list comprehension 和 generator expression 怎么选? → [] 立即求值占内存,() 惰性;只需要遍历一次用 ()
104. GIL 是什么?对多线程的影响与绕过方案?
概念 GIL(全局解释器锁)保证同一时刻只有一个线程执行 Python 字节码。CPU 密集任务多线程无法并行;IO 密集任务在等待时释放 GIL,多线程仍然有效。
典型场景 批量调 LLM API(IO 密集,多线程有效)、本地图片批处理(CPU 密集,需多进程)。
解决方案 三步递进:实测 IO 多线程有效 → CPU 密集多线程无效 → multiprocessing 绕过 GIL。
第一步:IO 密集——多线程有效(GIL 在等待时释放)
# 文件: gil-io.py
import time, threading
import requests # 演示用; 项目内用 httpx
def fetch(i):
requests.get("https://httpbin.org/delay/1")
start = time.time()
threads = [threading.Thread(target=fetch, args=(i,)) for i in range(5)]
[t.start() for t in threads]
[t.join() for t in threads]
print(f"5 个并发请求耗时 {time.time()-start:.1f}s") # 约 1s(等待期不占 GIL)
第二步:CPU 密集——多线程无效(GIL 串行化)
# 文件: gil-cpu.py
import time, threading
def crunch():
sum(i * i for i in range(10_000_000))
start = time.time()
threads = [threading.Thread(target=crunch) for _ in range(2)]
[t.start() for t in threads]
[t.join() for t in threads]
print(f"双线程 CPU 任务耗时 {time.time()-start:.1f}s") # 约 2 倍单线程(串行化)
第三步:multiprocessing——每个进程独立解释器,真并行
# 文件: gil-process.py
from multiprocessing import Pool
import time
def crunch(n):
return sum(i * i for i in range(n))
if __name__ == "__main__": # Windows/macOS 必须, 防子进程递归 import
start = time.time()
with Pool(2) as pool:
results = pool.map(crunch, [10_000_000, 10_000_000])
print(f"双进程耗时 {time.time()-start:.1f}s") # 约 1 倍单进程(真并行)
总结:IO 密集用多线程/asyncio;CPU 密集用 multiprocessing;选型口令——“等网络就线程,算数字就进程”。
追问1:asyncio 和多线程怎么选? → 高并发网络 IO(千级连接)用 asyncio;少量阻塞库调用用线程池 追问2:GIL 会一直存在吗? → PEP 703:Python 3.13 起提供 free-threaded 构建实验版,3.14 持续完善 追问3:多进程的代价? → 进程启动开销、数据需序列化传递(pickle),不适合频繁小数据交互
105. asyncio 的核心模型与常见坑?
概念 asyncio 是单线程事件循环的协程方案:async def 定义协程,await 让出控制权。协程切换在用户态完成,没有线程切换开销,适合高并发 IO。
典型场景 LLM 网关并发转发、批量调用外部 API、WebSocket 长连接服务(FastAPI 的底层)。
解决方案 三步递进:并发收集 → 信号量限流 → 最经典的坑:事件循环里写同步阻塞。
第一步:gather 并发——先发起再统一等待
# 文件: asyncio-gather.py
import asyncio, httpx
async def fetch(client, url):
r = await client.get(url)
return r.status_code
async def main():
async with httpx.AsyncClient() as client:
tasks = [fetch(client, "https://httpbin.org/delay/1") for _ in range(5)]
codes = await asyncio.gather(*tasks) # 并发 5 个, 总耗时约 1s
print(codes)
asyncio.run(main())
第二步:Semaphore 限流——并发不等于无节制
# 文件: asyncio-semaphore.py
import asyncio, httpx
async def fetch(client, sem, url):
async with sem: # 最多 3 个并发
r = await client.get(url)
return r.status_code
async def main():
sem = asyncio.Semaphore(3)
async with httpx.AsyncClient() as client:
codes = await asyncio.gather(*(fetch(client, sem, "https://httpbin.org/delay/1") for _ in range(10)))
print(codes)
asyncio.run(main())
第三步:最经典的坑——事件循环里写同步阻塞
# 文件: asyncio-blocking.py
import asyncio, time
async def bad_handler():
time.sleep(5) # 同步 sleep 阻塞整个事件循环, 所有协程停摆
async def good_handler():
await asyncio.sleep(5) # await 让出控制权, 其他协程照常跑
async def main():
await asyncio.gather(good_handler(), ticker())
async def ticker():
for i in range(3):
await asyncio.sleep(1)
print(f"心跳 {i}") # good_handler 期间心跳正常; 换成 bad_handler 就断了
asyncio.run(main())
总结:asyncio 的铁律是”协程里不允许同步阻塞”——一个 time.sleep 或同步 DB 调用会冻结整个服务。遇到只有同步版本的库,用 run_in_executor 丢线程池。
追问1:await 到底让出了什么? → 把协程控制权交回事件循环,事件循环调度下一个就绪的协程
追问2:gather 里有任务抛异常怎么办? → 默认立即抛出(其余任务继续跑完);return_exceptions=True 把异常作为结果收集
追问3:FastAPI 的 async def 和 def 路由有什么区别? → async def 跑在事件循环(适合 IO);def 自动丢线程池(适合同步阻塞库)
106. Python 类型注解与 pydantic?
概念 类型注解是参数/返回值的类型标记(运行时默认不校验);pydantic 是基于注解的运行时校验库,校验通过后数据自动转为声明类型。
典型场景 FastAPI 的请求体校验(底层就是 pydantic)、配置对象校验、LLM 结构化输出解析。
解决方案 三步递进:注解只是标记 → pydantic 校验与转换 → 嵌套模型与自定义校验。
第一步:注解只是标记——运行时并不拦截
# 文件: annotation-only.py
def add(a: int, b: int) -> int:
return a + b
print(add(1, "2")) # TypeError(是字符串拼接失败, 不是类型检查报错)
# 注解是给 IDE/mypy/pydantic 看的, 解释器不校验
第二步:pydantic——运行时校验 + 自动转换
# 文件: pydantic-basic.py
from pydantic import BaseModel, ValidationError
class CreateUser(BaseModel):
name: str
age: int
u = CreateUser(name="小明", age="18") # 注意: 传的是字符串 "18"
print(u.age, type(u.age)) # 18 <class 'int'> —— 自动转换
try:
CreateUser(name="小明", age="abc") # 无法转换 → 报 ValidationError
except ValidationError as e:
print(e.errors()[0]["type"]) # int_parsing
第三步:嵌套与自定义校验——LLM 结构化输出的标配
# 文件: pydantic-nested.py
from pydantic import BaseModel, Field, field_validator
class Tag(BaseModel):
name: str = Field(description="标签名", min_length=1, max_length=20)
class ExtractResult(BaseModel):
tags: list[Tag] = Field(default_factory=list, description="提取的标签")
sentiment: str = Field(description="情感倾向")
@field_validator("sentiment")
@classmethod
def check_sentiment(cls, v: str) -> str:
if v not in ("pos", "neg", "neutral"):
raise ValueError(f"非法情感值: {v}") # LLM 输出的枚举约束在此兜底
return v
r = ExtractResult.model_validate({"tags": [{"name": "AI"}], "sentiment": "pos"})
print(r.tags[0].name, r.sentiment)
总结:注解给工具看,pydantic 给运行时用;LLM 结构化输出三层防线——schema 约束生成、pydantic 校验、枚举 field_validator 兜底。
追问1:BaseModel 和 dataclass 的区别? → pydantic 运行时校验+自动转换+序列化;dataclass 只是个带初始化的类,无校验 追问2:pydantic v2 快在哪? → 核心校验用 Rust 重写(pydantic-core),比 v1 快 5-50 倍 追问3:Field(description=…) 有什么用? → 生成 JSON Schema,直接喂给 LLM 的结构化输出/function calling
107. Python 异常处理与资源管理?
概念 try/except/else/finally 四段;上下文管理器(with)保证资源释放;异常链(raise … from …)保留原始因果。
典型场景 调 LLM API 的超时/限流分类处理、数据库连接与游标的成对释放、封装底层异常为业务异常。
解决方案 三步递进:精确捕获与 else/finally → with 的原理(__enter__/__exit__) → 异常链实战(LLM 网关)。
第一步:精确捕获——except 顺序从具体到一般
# 文件: exception-order.py
import httpx
def call_llm(prompt: str) -> str:
try:
r = httpx.post("https://api.example.com/v1/chat", json={"prompt": prompt}, timeout=30)
r.raise_for_status()
return r.json()["text"]
except httpx.TimeoutException:
raise RuntimeError("模型响应超时") # 分类处理: 超时
except httpx.HTTPStatusError as e:
if e.response.status_code == 429:
raise RuntimeError("触发限流") # 限流单独处理
raise # 其他状态码原样抛出
except httpx.RequestError as e:
raise RuntimeError(f"网络错误: {e}") from e # from 保留原始异常链
print(call_llm("你好"))
第二步:with 的原理——__enter__/__exit__ 成对协议
# 文件: context-manager.py
class LLMClient:
def __enter__(self):
print("建立连接")
return self # as 后面拿到的就是返回值
def __exit__(self, exc_type, exc, tb):
print("释放连接") # 无论是否异常都执行
return False # False=异常继续传播; True=吞掉异常
def chat(self, q): return f"回答: {q}"
with LLMClient() as c:
print(c.chat("你好"))
# 上下文管理器协议等价于 try/finally, 但把"开/关"封装在类型里, 调用方忘不掉
第三步:contextlib——用生成器三行写一个上下文管理器
# 文件: contextlib-timer.py
import time
from contextlib import contextmanager
@contextmanager
def timer(name: str):
start = time.time()
try:
yield # yield 之前= __enter__, 之后= __exit__
finally:
print(f"{name} 耗时 {time.time()-start:.3f}s")
with timer("推理"):
sum(i * i for i in range(1_000_000))
总结:except 从具体到一般;raise ... from e 保留异常链;资源管理一律 with(contextlib 让自定义成本降到三行)。
追问1:except Exception 和裸 except 的区别? → 裸 except 连 KeyboardInterrupt/SystemExit 都捕获,几乎总是错误
追问2:finally 里 return 会怎样? → 覆盖 try/except 的返回值并吞掉异常,极不推荐
追问3:怎么自定义业务异常基类? → class AppError(Exception) + code 字段,全局异常处理器按 code 映射响应
108. Python 内存管理与引用计数?
概念 主力是引用计数(计数归零立即回收),辅以标记清除+分代回收处理循环引用。sys.getrefcount 可观察计数(比真实值大 1,因为参数传入也计一次)。
典型场景 长驻服务内存上涨、大对象生命周期不明、面试官问”Python 有 GC 吗”。
解决方案 三步递进:观察引用计数 → 循环引用怎么被处理 → weakref 弱引用方案。
第一步:引用计数——归零即回收
# 文件: refcount.py
import sys
a = [1, 2, 3]
print(sys.getrefcount(a)) # 2(a 本身 + 函数参数)
b = a
print(sys.getrefcount(a)) # 3
del b
print(sys.getrefcount(a)) # 2 —— b 消失, 计数回落
del a # 计数归零, 对象立即回收(CPython)
第二步:循环引用——引用计数搞不定,分代 GC 来兜底
# 文件: cycle-gc.py
import gc
class Node:
def __init__(self): self.peer = None
a, b = Node(), Node()
a.peer, b.peer = b, a # 互相引用: 计数永不归零
del a, b
print(gc.collect()) # 返回本轮清理的循环引用对象数 —— 分代 GC 处理了它们
print(gc.get_threshold()) # (700, 10, 10): 0代700次分配触发/10次0代清空升1代...
第三步:weakref——不阻止回收的引用(同 JS 的 WeakMap 思想)
# 文件: weakref-demo.py
import weakref
class Cache:
pass
obj = Cache()
ref = weakref.ref(obj) # 弱引用: 不增加引用计数
print(ref() is obj) # True —— 还活着
del obj
print(ref()) # None —— 原对象已被回收, 弱引用自动失效
总结:CPython 主力引用计数(即时性),循环引用靠分代 GC 兜底;给”附属数据”挂对象用 weakref,别阻碍回收。
追问1:__del__ 方法可靠吗? → 不可靠:调用时机不确定,循环引用+__del__ 在旧版本甚至无法回收;资源释放用上下文管理器
追问2:sys.getrefcount 为什么差 1? → 传参本身产生一个临时引用
追问3:怎么排查内存上涨? → tracemalloc 对比快照找分配热点;objgraph 看引用链
109. Python 的 MRO 与多继承?
概念 MRO(Method Resolution Order,方法解析顺序)是多继承时属性查找的顺序,C3 线性化算法保证:子类在前、父类按声明顺序、且单调不重复。super() 按 MRO 找下一个,不是”找父类”。
典型场景 多继承/mixin 设计、super().__init__ 调用链、面试官问”super 是父类吗”。
解决方案 三步递进:看 MRO 顺序 → 协作式多继承(菱形结构) → mixin 实战。
第一步:查看 MRO——顺序由 C3 算出
# 文件: mro-basic.py
class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
print([c.__name__ for c in D.__mro__]) # ['D', 'B', 'C', 'A', 'object']
# B 在 C 前(声明顺序), A 只出现一次(C3 保证单调)
第二步:菱形继承——super() 按 MRO 协作而非重复调用
# 文件: mro-diamond.py
class Base:
def __init__(self, **kw):
print("Base init")
super().__init__(**kw) # 不是"调父类", 是"调 MRO 中的下一个"
class MixinA(Base):
def __init__(self, **kw):
print("A init")
super().__init__(**kw)
class MixinB(Base):
def __init__(self, **kw):
print("B init")
super().__init__(**kw)
class Impl(MixinA, MixinB):
def __init__(self):
print("Impl init")
super().__init__()
Impl()
# 输出: Impl → A → B → Base —— 每个 __init__ 只执行一次
# 若都在 __init__ 里硬编码调 Base.__init__, Base 会执行两次(经典 bug)
第三步:mixin 实战——横切能力的组合单元
# 文件: mro-mixin.py
import json
class JsonMixin:
def to_json(self) -> str:
return json.dumps(self.__dict__, ensure_ascii=False)
class LogMixin:
def log(self): print(f"[{type(self).__name__}] {self.__dict__}")
class User(JsonMixin, LogMixin):
def __init__(self, name, age):
self.name, self.age = name, age
u = User("小明", 18)
print(u.to_json()); u.log()
# mixin 只提供能力不含状态, 命名以 Mixin 结尾, 放在继承列表最前
总结:MRO 由 C3 线性化生成(Class.__mro__ 可查);super 是”沿 MRO 的下一个”而非父类;mixin 是无状态能力单元,组合优于深继承。
追问1:super().init() 忘了调会怎样? → MRO 链在当前类断裂,父类/后续 mixin 的初始化不执行 追问2:C3 解决了什么旧问题? → Python 2 经典类深度优先导致基类被重复访问、顺序不稳定 追问3:abc.ABC 和 mixin 的区别? → ABC 强制子类实现抽象方法(契约);mixin 是可选能力注入
110. *args/**kwargs 与函数参数的完整规则?
概念 位置参数 → *args(多余位置参数收成元组)→ 关键字仅限参数(* 后不可按位置传)→ **kwargs(多余关键字参数收成字典)。调用侧 f(*list) 解包、f(**dict) 解包关键字。
典型场景 写通用装饰器(透传任意参数)、封装转发函数、面试官问”参数顺序能不能乱”。
解决方案 三步递进:完整签名顺序 → 装饰器透传的标配 → 解包调用的实战。
第一步:完整签名顺序——五种参数的位置是死的
# 文件: params-order.py
def fn(pos_only, /, normal, *args, kw_only, **kwargs):
print(pos_only, normal, args, kw_only, kwargs)
fn(1, 2, 3, 4, kw_only=5, extra=6)
# 1 2 (3, 4) 5 {'extra': 6}
# / 之前只能按位置传; * 之后只能按关键字传
第二步:装饰器透传——*args, **kwargs 是万能签名
# 文件: params-deco.py
from functools import wraps
def logged(fn):
@wraps(fn)
def wrapper(*args, **kwargs): # 收下任意参数组合
print(f"调用 {fn.__name__}, args={args}, kwargs={kwargs}")
return fn(*args, **kwargs) # 原样转发
return wrapper
@logged
def transfer(amount, *, to, memo=None):
return f"{amount} → {to}"
print(transfer(100, to="bob", memo="工资"))
第三步:解包调用——把容器摊开成参数
# 文件: params-unpack.py
def create_user(name, age, *, city="北京", **extra):
print(name, age, city, extra)
info = {"name": "小明", "age": 18}
extra_info = {"vip": True, "source": "ad"}
create_user(**info, city="上海", **extra_info) # 字典解包 + 覆盖 + 收尾
# 小明 18 上海 {'vip': True, 'source': 'ad'}
总结:签名顺序”位置、/、常规、*args、仅关键字、**kwargs”;装饰器靠 *args, **kwargs 透传;调用侧 */** 解包。
追问1:可变默认参数的坑? → def f(x=[]) 的默认列表在多次调用间共享(函数对象创建时求值一次);正确写法 x=None + 函数内 x = x or []
追问2:* 单独出现是什么? → 关键字仅限参数的分隔符,之后的参数必须 name=value 传
追问3:强制关键字参数的好处? → 调用处自带语义(to="bob"),防止按位置传错——公共 API 推荐
111. Python 闭包与 LEGB 作用域?
概念 作用域查找顺序 LEGB:Local → Enclosing(外层函数)→ Global → Built-in。闭包=内层函数持有 Enclosing 层变量;nonlocal 改写外层变量,global 改写全局。
典型场景 计数器/累加器、回调状态保持、循环里闭包引用变量”值不对”。
解决方案 三步递进:LEGB 读规则 → 闭包写变量必须 nonlocal → 循环闭包的经典陷阱(对应 JS 的 var 陷阱)。
第一步:LEGB 读规则——由内向外找
# 文件: legb.py
x = "global"
def outer():
x = "enclosing"
def inner():
print(x) # enclosing —— 由内向外最近命中
inner()
outer()
第二步:闭包写变量——不声明 nonlocal 就会报错
# 文件: nonlocal.py
def make_counter():
count = 0
def add():
nonlocal count # 声明: 我要改写的是 Enclosing 层的 count
count += 1
return count
return add
c = make_counter()
print(c(), c(), c()) # 1 2 3
# 不写 nonlocal, count += 1 会被当作"在局部新建变量"→ UnboundLocalError
第三步:循环闭包陷阱——和 JS 的 var 陷阱同构
# 文件: closure-loop.py
handlers = []
for i in range(3):
handlers.append(lambda: print(i)) # 三个 lambda 共享同一个 i
for h in handlers: h()
# 输出 2 2 2 —— 循环结束后 i=2, 闭包引用的是变量本身而非值
# 解法: 用默认参数在绑定时刻固定值
handlers = [lambda i=i: print(i) for i in range(3)]
for h in handlers: h() # 0 1 2
总结:LEGB 定查找顺序;闭包改外层必须 nonlocal;循环里建闭包,默认参数 i=i 固定当前值(等价 JS 的 let)。
追问1:闭包变量存哪? → 存在函数对象的 __closure__ 属性(cell 对象),不随外层函数栈帧销毁
追问2:x += 1 为什么会 UnboundLocalError? → 赋值语句使 x 被解析为局部变量,读它时”局部 x 未初始化”
追问3:class 体内是独立作用域吗? → 是,但类体内定义的方法访问不到类体变量(需经由 self 或类名)
112. Python 反射:getattr/setattr 与动态分发?
概念 反射即运行时按字符串名取/设对象的属性与方法:getattr(obj, "name")、setattr(obj, "name", v)、hasattr 判断存在;__dict__ 存实例属性。
典型场景 按配置分发到不同处理函数(路由表)、插件注册、CLI 子命令映射。
解决方案 三步递进:基础 getattr → 字典分发(推荐)→ 基于命名约定的自动注册。
第一步:基础三件套
# 文件: reflect-basic.py
class Worker:
def run_job_a(self): return "A 完成"
def run_job_b(self): return "B 完成"
w = Worker()
method = getattr(w, "run_job_a") # 按字符串取方法
print(method()) # A 完成
print(hasattr(w, "run_job_c")) # False
第二步:字典分发——比反射更清晰的主流做法
# 文件: dispatch-dict.py
def job_a(x): return f"A: {x}"
def job_b(x): return f"B: {x}"
JOBS = {"a": job_a, "b": job_b} # 显式注册表: 查哪个函数一目了然
def run(kind: str, x: int):
fn = JOBS.get(kind)
if not fn:
raise ValueError(f"未知任务: {kind}")
return fn(x)
print(run("a", 42))
第三步:命名约定自动注册——插件式扩展
# 文件: dispatch-auto.py
class TaskRunner:
def __init__(self):
self._tasks = {}
for name in dir(self): # 扫描实例的全部属性
if name.startswith("task_"): # 约定: task_ 前缀即任务
self._tasks[name[5:]] = getattr(self, name)
def task_email(self, to): return f"发邮件给 {to}"
def task_sms(self, to): return f"发短信给 {to}"
r = TaskRunner()
print(r._tasks.keys()) # ['email', 'sms'] —— 自动注册
print(r._tasks["email"]("bob"))
总结:getattr/setattr 是反射三件套;能用字典分发就不用字符串反射(类型检查友好);命名约定自动注册适合插件场景。
追问1:反射对性能有影响吗? → getattr 比直接调用慢(经过查找协议),热点路径用分发字典预解析
追问2:__getattr__ 和 getattr 的区别? → __getattr__ 是钩子:常规查找失败才调用,可用于动态属性(如 ORM 字段)
追问3:怎么列出对象的所有方法? → dir(obj) 过滤下划线开头,或检查 callable(getattr(obj, name))
113. Python 推导式与生成器表达式的性能?
概念 列表推导 [f(x) for x in xs if cond] 立即求值生成完整列表;生成器表达式 (f(x) for x in xs) 惰性,遍历时才算。
典型场景 大数据集转换、只需遍历一次的中间结果、内存敏感场景。
解决方案 三步递进:推导式的完整形态 → 内存对比实测 → 实战选型。
第一步:完整形态——for + if + if-else 三种位置
# 文件: comprehension-forms.py
nums = range(10)
squares = [n * n for n in nums] # 纯转换
evens = [n for n in nums if n % 2 == 0] # 过滤(条件在后面)
labels = ["偶" if n % 2 == 0 else "奇" for n in nums] # 转换+分支(三目在前面)
print(evens[:4], labels[:4])
第二步:内存对比实测——[] 与 () 的差距
# 文件: comprehension-memory.py
import sys
lst = [x * 2 for x in range(1_000_000)] # 立即生成 100 万个元素
gen = (x * 2 for x in range(1_000_000)) # 只是一个表达式对象
print(sys.getsizeof(lst), sys.getsizeof(gen)) # 约 8MB vs 约 200B
print(sum(gen)) # 遍历时才逐个计算; 只遍历一次的场景用它
第三步:选型实战——词频统计
# 文件: comprehension-wordcount.py
from collections import Counter
tokens = ("hello world this is ai " * 50_000).split() # 50 万 token
counts = Counter(t for t in tokens if len(t) > 2) # 生成器喂给 Counter, 不建中间大列表
print(counts.most_common(3))
总结:一次性中间结果且要复用/索引 → 列表推导;单次消费、大数据、喂给 sum/any/Counter → 生成器表达式。
追问1:推导式里能用 try/except 吗? → 不能直接写,需抽成函数或用 walrus 运算符绕行
追问2:嵌套推导式的顺序? → 从左到右读,[x+y for x in xs for y in ys] 等价双重 for
追问3:字典/集合推导式? → {k: v for ...} 与 {x for ...},语法同列表推导
114. walrus 运算符 := 与 match-case?
概念 海象运算符 :=(3.8+)在表达式内赋值;match-case(3.10+)是结构化模式匹配——可匹配字面量、解构序列/字典、类型、守卫条件。
典型场景 “边算边判”(循环内计算并判断)、解析嵌套 JSON(LLM 工具调用的 arguments)、多分支消息分发。
解决方案 三步递进:walrus 两场景 → match-case 基础解构 → 实战:LLM 事件分发。
第一步:walrus——把赋值塞进表达式
# 文件: walrus.py
values = [1, 5, 12, 3, 20]
big = [n for n in values if (sq := n * n) > 20] # 边算平方边筛选, sq 复用不重算
print(big, sq) # [12*...]
# 循环场景: while (chunk := read()) 不必写两遍 read()
第二步:match-case 基础——解构与守卫
# 文件: match-basic.py
def handle(command: str):
match command.split():
case ["help"]:
return "命令列表: help / add <a> <b>"
case ["add", a, b]:
return f"结果: {int(a) + int(b)}" # 自动解构位置
case ["greet", name, *rest]:
return f"你好 {name}, extra={rest}"
case _:
return "未知命令"
print(handle("add 2 3"), handle("greet 小明 x y"))
第三步:实战——LLM 工具调用事件分发
# 文件: match-llm-events.py
import json
def dispatch(event: dict) -> str:
match event:
case {"type": "tool_call", "name": name, "args": args}:
return f"执行工具 {name}, 参数 {json.dumps(args, ensure_ascii=False)}"
case {"type": "done", "usage": {"total_tokens": tokens}}:
return f"完成, 消耗 {tokens} tokens" # 嵌套解构 + 字面量匹配
case {"type": "error", "message": msg} if "timeout" in msg:
return "超时错误: 建议重试" # 守卫条件
case {"type": t}:
return f"未知事件类型: {t}"
case _:
return "非法消息"
print(dispatch({"type": "done", "usage": {"total_tokens": 1024}}))
总结::= 消灭”算两遍”,循环和推导式最受益;match-case 替代 if-elif 长链,解构+守卫让消息分发一目了然。
追问1:match-case 和 switch 区别? → match 是结构匹配(可解构/守卫),不只是值比较;case _ 是兜底而非 default 语法
追问2:walrus 在推导式里的作用域? → 泄漏到包含作用域(3.8 起规范定义),命名避免与外层冲突
追问3:case 里能匹配类实例吗? → 可以,case Point(x=0, y=0) 按属性解构,配合 __match_args__ 支持位置匹配
二、FastAPI(115–124)
本章 10 题:async/def 路由差异、参数校验、Depends 依赖注入、中间件与异常、SSE 流式、后台任务、SQLAlchemy 异步、pytest、Pydantic v2、LLM 网关限流计费。
115. FastAPI 为什么”快”?async 路由与 def 路由的区别?
概念 FastAPI 基于 Starlette(ASGI,异步服务器网关)与 pydantic(校验)。“快”有两层:开发快(类型注解自动生成校验+文档)、性能快(异步非阻塞,可扛高并发 IO)。
典型场景 LLM 网关(高并发转发上游 SSE)、需要自动 OpenAPI 文档的团队协作、Python 侧替代 Flask 的新项目。
解决方案 三步递进:最小服务 → async 与 def 的调度差异 → 什么时候用哪个。
第一步:最小服务——类型注解即校验即文档
# 文件: fastapi-minimal.py
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class ChatRequest(BaseModel):
question: str
session_id: str
@app.post("/chat")
async def chat(req: ChatRequest) -> dict:
return {"answer": f"收到: {req.question}", "session": req.session_id}
# 运行: uvicorn fastapi-minimal:app --reload
# 自动文档: http://127.0.0.1:8000/docs (Swagger) / /redoc
第二步:async 与 def 的调度差异——框架替你选执行器
# 文件: fastapi-async-vs-def.py
import time, asyncio
from fastapi import FastAPI
app = FastAPI()
@app.get("/sync-block")
def sync_block(): # def: 丢到线程池执行, 阻塞不影响事件循环
time.sleep(2) # 同步库(time.sleep/同步 DB)只能这样
return {"ok": True}
@app.get("/async-good")
async def async_good(): # async def: 跑在事件循环, await 时让出
await asyncio.sleep(2) # 千级并发也不卡
return {"ok": True}
# 铁律: async def 里绝不能出现同步阻塞调用(time.sleep/requests.get)——会冻结整个服务
第三步:选型决策——一句话
纯 IO 且有异步库(httpx/asyncpg) → async def
必须用同步库(SQLAlchemy 旧版/重计算) → def(框架自动走线程池)
CPU 密集 → 两者都别用, 丢进程池或独立服务
总结:FastAPI 快在”注解即校验即文档”+ASGI 异步;async def 与 def 的本质区别是跑在事件循环还是线程池;异步路由里禁止同步阻塞。
追问1:uvicorn 和 gunicorn 的关系? → uvicorn 是 ASGI 服务器;生产用 gunicorn -k uvicorn.workers.UvicornWorker 多进程管理
追问2:FastAPI 依赖注入是什么? → Depends() 声明依赖(数据库会话/当前用户),框架自动解析并支持嵌套
追问3:和 Flask 迁移成本? → 路由装饰器风格接近,主要改造是请求体改 pydantic、同步视图逐步 async 化
116. 请求校验:Query/Path/Body 与 pydantic 约束?
概念 FastAPI 把函数签名翻译成校验规则:Query()/Path() 管查询与路径参数,pydantic 模型管请求体;Field/Annotated 添加长度、范围、正则约束。校验失败自动返回 422 与明细。
典型场景 分页参数越界、枚举值非法、LLM 请求体字段缺失——统一在框架层拦截而非业务代码里 if。
解决方案 三步递进:三类参数的声明 → 约束与错误响应 → 枚举与自定义校验。
第一步:三类参数——签名即文档即校验
# 文件: fastapi-params.py
from fastapi import FastAPI, Query, Path
from pydantic import BaseModel, Field
app = FastAPI()
class ChatBody(BaseModel):
question: str = Field(min_length=1, max_length=2000)
temperature: float = Field(default=0.7, ge=0, le=2) # 范围约束
@app.get("/items/{item_id}")
async def read_item(
item_id: int = Path(gt=0), # 路径参数必须正整数
q: str | None = Query(default=None, max_length=50), # 可选查询参数
):
return {"item_id": item_id, "q": q}
@app.post("/chat")
async def chat(body: ChatBody):
return {"temp": body.temperature}
# GET /items/-1 → 422; POST /chat {"temperature": 5} → 422, 响应含字段级错误明细
第二步:看 422 响应——前端拿到就能精确提示
GET /items/-1 →
{
"detail": [{
"type": "greater_than",
"loc": ["path", "item_id"],
"msg": "Input should be greater than 0"
}]
}
第三步:枚举参数——Literal 天然约束
# 文件: fastapi-enum.py
from typing import Literal
from fastapi import FastAPI
app = FastAPI()
@app.get("/search")
async def search(
sort: Literal["relevance", "time"] = "relevance", # 只接受这两个值
mode: Literal["keyword", "vector", "hybrid"] = "hybrid",
):
return {"sort": sort, "mode": mode}
# /search?sort=wrong → 422, 文档里自动呈现下拉选项
总结:参数声明即校验即文档;数值范围用 Field(ge/le),取值集合用 Literal;422 响应带字段级定位,前端直接可用。
追问1:怎么自定义校验错误格式? → 覆盖 app.exception_handler(RequestValidationError),统一成 {code, message, data}
追问2:多个请求模型怎么组合? → 单一 Body 用模型;Annotated[ModelA, Body(embed=True)] 支持多模型合并
追问3:文件上传怎么声明? → file: UploadFile = File(...),异步 await file.read(),大文件分块读
117. 依赖注入:Depends 的机制与应用?
概念 Depends(fn) 声明依赖,FastAPI 每次请求时解析并缓存(同请求内同依赖只执行一次);依赖可嵌套;yield 形式的依赖负责”请求前准备、请求后清理”。dependencies=[...] 可给路由挂”只执行不注入”的守卫。
典型场景 数据库会话按请求创建/关闭、当前用户鉴权、分页参数复用、限流。
解决方案 三步递进:yield 依赖管理会话生命周期 → 依赖嵌套(当前用户) → 路由级守卫数组。
第一步:yield 依赖——会话的建立与释放
# 文件: fastapi-dep-session.py
from fastapi import FastAPI, Depends
from sqlalchemy.orm import Session
app = FastAPI()
def get_db():
db = SessionLocal() # SessionLocal 为项目内 engine 绑定的 session 工厂
try:
yield db # yield 之前= 请求前准备; 之后= 请求后清理
finally:
db.close()
@app.get("/users/{uid}")
async def get_user(uid: int, db: Session = Depends(get_db)):
return {"uid": uid} # db 已就绪, 请求结束后自动 close
# 同一请求内多个路由参数都 Depends(get_db) 时, 复用同一个会话(框架缓存)
第二步:依赖嵌套——当前用户依赖会话
# 文件: fastapi-dep-auth.py
from fastapi import Depends, HTTPException, Header
def get_current_user(authorization: str = Header(), db=Depends(get_db)):
if not authorization.startswith("Bearer "):
raise HTTPException(status_code=401, detail="缺少凭证")
token = authorization[7:]
user = decode_token(token, db) # decode_token 为项目内函数
if user is None:
raise HTTPException(status_code=401, detail="凭证无效")
return user
@app.get("/me")
async def me(user=Depends(get_current_user)):
return {"id": user.id, "name": user.name} # 拿到的已是当前用户
第三步:路由守卫——只校验不注入
# 文件: fastapi-dep-guard.py
from fastapi import Depends
def verify_api_key(x_api_key: str = Header()):
if x_api_key != expected_key(): # expected_key 为项目内函数
raise HTTPException(status_code=403, detail="API Key 无效")
@app.post("/v1/chat", dependencies=[Depends(verify_api_key)]) # 只做拦截, 不需要拿返回值
async def chat(): ...
# 全局守卫: app = FastAPI(dependencies=[Depends(verify_api_key)])
总结:Depends 三用途——资源生命周期(yield)、业务依赖(嵌套解析)、路由守卫(dependencies 列表);同请求内依赖结果自动缓存。
追问1:依赖的缓存能关吗? → 能,Depends(fn, use_cache=False),每次引用都重新执行(如需独立事务)
追问2:类作为依赖? → Depends(Settings),框架实例化并把构造器参数当子依赖解析
追问3:全局异常怎么配合依赖? → 依赖里抛 HTTPException 由框架转响应;非 HTTP 异常注册 exception_handler 统一兜底
118. 中间件、异常处理与统一响应?
概念 中间件(@app.middleware)在每个请求前后执行(计时/日志/CORS);异常处理器(@app.exception_handler)把异常映射为响应;统一响应结构靠响应模型或包装拦截器。
典型场景 全链路 traceId、LLM 网关的统一错误格式 {code, message, data}、CORS 配置。
解决方案 三步递进:计时中间件 → 自定义业务异常与处理器 → CORS。
第一步:计时中间件——每个请求的耗时日志
# 文件: fastapi-middleware.py
import time, logging
from fastapi import FastAPI, Request
app = FastAPI()
logger = logging.getLogger("http")
@app.middleware("http")
async def timing(request: Request, call_next):
start = time.time()
response = await call_next(request) # 调用下游(路由/后续中间件)
cost_ms = (time.time() - start) * 1000
logger.info("%s %s %dms", request.method, request.url.path, cost_ms)
response.headers["X-Process-Time-Ms"] = f"{cost_ms:.1f}"
return response
第二步:业务异常——统一错误格式
# 文件: fastapi-exceptions.py
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
app = FastAPI()
class BizError(Exception):
def __init__(self, code: int, message: str):
self.code, self.message = code, message
@app.exception_handler(BizError)
async def biz_handler(request: Request, exc: BizError):
return JSONResponse(status_code=200, content={ # 业务错误 HTTP 200 + code 区分(团队约定可改)
"code": exc.code, "message": exc.message, "data": None,
})
@app.post("/llm/chat")
async def chat():
raise BizError(code=40001, message="余额不足")
# 响应: {"code": 40001, "message": "余额不足", "data": null} —— 前端按 code 分支
第三步:CORS——前端直连的必要配置
# 文件: fastapi-cors.py
from fastapi.middleware.cors import CORSMiddleware
app.add_middleware(
CORSMiddleware,
allow_origins=["https://memolab.cn", "http://localhost:5173"], # 带凭证时必须具体域名, 不能 *
allow_credentials=True,
allow_methods=["GET", "POST"],
allow_headers=["Authorization", "Content-Type"],
)
总结:中间件管横切(计时/日志),exception_handler 管异常到响应的映射,CORS 允许精确白名单。
追问1:中间件和依赖注入的执行顺序? → 中间件最外层;依赖在路由参数解析阶段执行(晚于中间件)
追问2:怎么给所有响应包统一壳? → 响应模型约定 + exception_handler 兜底;不建议中间件改 body(流式响应会破坏)
追问3:SSE 流式接口的异常怎么返回? → 响应头已发出无法改状态码,只能在流内以 data: {"error": ...} 事件吐出
119. 流式接口:SSE 在 FastAPI 的正确实现?
概念 SSE = text/event-stream 响应 + StreamingResponse 分块写出;每条消息 data: ...\n\n 结尾;LLM 场景上游也是流,要用 httpx 的 stream 逐块转发。
典型场景 聊天打字机效果、长任务进度推送——AI 前端全栈的核心接口形态。
解决方案 三步递进:静态流 → 转发上游 LLM 流 → 三个生产级细节(缓冲/断连/异常)。
第一步:静态流——理解 StreamingResponse 的生成器模型
# 文件: fastapi-sse-basic.py
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import asyncio
app = FastAPI()
async def event_gen():
for i in range(5):
yield f"data: 第{i}条消息\n\n" # yield 一段, 发一段
await asyncio.sleep(0.5)
@app.get("/stream")
async def stream():
return StreamingResponse(event_gen(), media_type="text/event-stream",
headers={"Cache-Control": "no-cache",
"X-Accel-Buffering": "no"}) # 关 Nginx 缓冲, 否则被攒成一坨
第二步:转发上游 LLM 流——网关的核心逻辑
# 文件: fastapi-sse-llm.py
import httpx
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
app = FastAPI()
UPSTREAM = "https://api.example.com/v1/chat/completions"
class ChatIn(BaseModel):
prompt: str
@app.post("/v1/chat")
async def chat(body: ChatIn):
async def gen():
try:
async with httpx.AsyncClient(timeout=None) as client: # 流式必须禁总超时
async with client.stream(
"POST", UPSTREAM,
json={"prompt": body.prompt, "stream": True},
headers={"Authorization": "Bearer ..."},
) as upstream:
async for chunk in upstream.aiter_text():
if chunk.strip():
yield f"data: {chunk.strip()}\n\n" # 转成 SSE 帧
yield "data: [DONE]\n\n"
except httpx.TimeoutException:
yield 'data: {"error": "上游超时"}\n\n' # 响应头已发, 异常只能流内吐
except Exception as e:
yield f'data: {{\"error\": \"{e}\"}}\n\n'
return StreamingResponse(gen(), media_type="text/event-stream")
第三步:断连感知——客户端关了页面要停掉上游调用
# 文件: fastapi-sse-disconnect.py
from fastapi import Request
@app.post("/v1/chat/stream")
async def chat_stream(body: ChatIn, request: Request):
async def gen():
async for chunk in upstream_iter(body.prompt):
if await request.is_disconnected(): # 客户端断开检测
break # 停止生成 → 上游连接随之关闭, 省钱
yield f"data: {chunk}\n\n"
return StreamingResponse(gen(), media_type="text/event-stream")
总结:SSE 三件套——media_type + X-Accel-Buffering: no + 生成器内异常兜底;上游也是流时必须 client.stream 逐块转发;断连检测能省真金白银的 token。
追问1:为什么不用 WebSocket? → 单向推送场景 SSE 更轻:基于 HTTP(复用鉴权/代理)、自动重连;双向才用 WS 追问2:EventSource 和 fetch 读流的区别? → EventSource 只支持 GET 且不能带自定义 header;POST+Authorization 必须前端 fetch + ReadableStream 解析 追问3:怎么压测流式接口? → wrk/k6 按长连接并发,关注首字延迟(TTFB)与总时长分布,而非仅 RPS
120. 后台任务与定时调度?
概念 FastAPI 内置 BackgroundTasks(响应后执行,进程内);真正的定时/重试/持久化队列用 Celery/APScheduler/RQ。“响应后”和”可靠异步”是两个需求。
典型场景 发送通知邮件(响应后即可,可丢)、生成报表(必须可靠,重试+持久化)、每日定时同步(调度器)。
解决方案 三步递进:BackgroundTasks 边界 → APScheduler 定时 → Celery 何时才需要。
第一步:BackgroundTasks——轻量但不可靠
# 文件: fastapi-background.py
from fastapi import FastAPI, BackgroundTasks
app = FastAPI()
def send_welcome_email(to: str):
... # SMTP 发送(允许失败)
@app.post("/register")
async def register(email: str, background: BackgroundTasks):
background.add_task(send_welcome_email, email) # 响应返回后执行
return {"ok": True}
# 特性: 跑在当前进程, 服务重启任务即丢 —— 只适合"可丢"的旁路动作
第二步:APScheduler——进程内定时任务
# 文件: fastapi-scheduler.py
from contextlib import asynccontextmanager
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from fastapi import FastAPI
scheduler = AsyncIOScheduler()
@scheduler.scheduled_job("cron", hour=3) # 每天凌晨 3 点
async def daily_sync():
await sync_data() # sync_data 为项目内协程
@asynccontextmanager
async def lifespan(app: FastAPI):
scheduler.start() # 应用启动时开调度
yield
scheduler.shutdown() # 优雅关闭
app = FastAPI(lifespan=lifespan)
# 多实例部署注意: 每个实例都会跑一遍 —— 需分布式锁(Redis SETNX)或指定单实例
第三步:Celery——什么时候才值得上
需求判断:
- 任务必须不丢(重试、持久化、失败入死信) → Celery + Redis/RabbitMQ broker
- 任务很重(转码/爬虫), 不能占 API 进程 → Celery 独立 worker 进程池
- 只是"响应后发个通知" → BackgroundTasks 足够, 别为杀鸡上牛刀
总结:后台任务三级——BackgroundTasks(可丢)/APScheduler(定时)/Celery(可靠+重活);多实例定时要分布式锁。
追问1:lifespan 是什么? → FastAPI 的应用生命周期钩子(替代 on_event),启动/关闭各执行一次,适合建连接池、开调度器 追问2:Celery 的 broker 和 backend? → broker 是任务队列(Redis/RabbitMQ);backend 存结果(可选) 追问3:定时任务集群怎么防重复? → Redis SETNX 抢锁,或调度中心单点 + 任务幂等兜底
121. SQLAlchemy 2.0:异步引擎与 ORM 会话?
概念 SQLAlchemy 2.0 原生 async:create_async_engine(驱动 asyncmy/asyncpg)+ async_sessionmaker + AsyncSession;2.0 风格查询统一 select()。
典型场景 FastAPI + MySQL/Postgres 的标准组合;老项目 1.x 的 query() 迁移。
解决方案 三步递进:建引擎与会话依赖 → 2.0 风格 CRUD → 事务与并发注意。
第一步:建引擎——异步会话依赖(配合 117 的 Depends)
# 文件: db/engine.py
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
engine = create_async_engine(
"mysql+asyncmy://user:pass@localhost:3306/aiapp", # 驱动 asyncmy(MySQL)/asyncpg(PG)
pool_size=10, max_overflow=20, pool_recycle=3600, # 连接池: 常驻10+峰值20, 1h回收防断连
echo=False,
)
SessionLocal = async_sessionmaker(engine, expire_on_commit=False)
async def get_db():
async with SessionLocal() as session:
yield session
第二步:2.0 风格 CRUD——统一 select()
# 文件: db/crud.py
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from db.engine import get_db
from fastapi import Depends
from db.models import Post # models: class Post(Base): id/title/user_id ...
async def list_posts(db: AsyncSession = Depends(get_db), page: int = 1):
stmt = (
select(Post)
.where(Post.user_id == 1)
.order_by(Post.id.desc())
.limit(20)
.offset((page - 1) * 20)
)
rows = (await db.execute(stmt)).scalars().all() # execute → scalars → all
return rows
async def create_post(db: AsyncSession, title: str, user_id: int):
post = Post(title=title, user_id=user_id)
db.add(post)
await db.commit() # 异步会话的提交也是 await
await db.refresh(post) # 回读自增 id 等数据库生成字段
return post
第三步:事务与关联——rollback 和 selectinload
# 文件: db/transaction.py
from sqlalchemy.orm import selectinload
async def transfer(db: AsyncSession, from_id: int, to_id: int):
try:
... # 多步写操作
await db.commit()
except Exception:
await db.rollback() # 任一步失败回滚
raise
async def list_with_author(db: AsyncSession):
stmt = select(Post).options(selectinload(Post.author)) # 预加载关联, 防 N+1
return (await db.execute(stmt)).scalars().all()
总结:2.0 异步三件套 create_async_engine / async_sessionmaker / AsyncSession;查询统一 select();N+1 用 selectinload 预加载;连接池参数要按并发配置。
追问1:同步 SQLAlchemy 能在 FastAPI 用吗? → 能,路由写 def(框架走线程池);混合时别在 async 路由里直接用同步引擎 追问2:expire_on_commit=False 的作用? → commit 后不过期属性,避免后续访问属性再次触发懒加载查询(异步下懒加载会报错) 追问3:连接池怎么调? → pool_size 按常驻并发,max_overflow 是峰值弹性;总连接数不得超过数据库 max_connections 配额
122. pytest:测试 FastAPI 应用?
概念 pytest + TestClient(基于 httpx)直接调用 ASGI app,无需起服务器;fixture 管理测试数据库生命周期;@pytest.mark.asyncio 测异步函数。
典型场景 Service 层单测(业务分支)、接口契约测试(状态码/结构/鉴权)、CI 门禁。
解决方案 三步递进:接口冒烟测试 → fixture 隔离测试库 → 依赖覆盖(mock 掉外部服务)。
第一步:接口冒烟——不起服务直接测
# 文件: tests/test_chat.py
from fastapi.testclient import TestClient
from fastapi_minimal import app # 115 的应用
client = TestClient(app)
def test_chat_ok():
r = client.post("/chat", json={"question": "你好", "session_id": "s1"})
assert r.status_code == 200
body = r.json()
assert body["session"] == "s1"
def test_chat_validation():
r = client.post("/chat", json={"question": ""}) # 缺 session_id
assert r.status_code == 422
assert any(e["loc"][-1] == "session_id" for e in r.json()["detail"])
第二步:fixture 隔离测试库——每个测试干净起步
# 文件: tests/conftest.py
import pytest
from httpx import AsyncClient, ASGITransport
from db.engine import engine
from db.models import Base
@pytest.fixture
async def client():
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.create_all) # 建表
async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as c:
yield c
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.drop_all) # 清理
# 文件: tests/test_users.py
import pytest
@pytest.mark.asyncio
async def test_create_user(client):
r = await client.post("/users", json={"name": "小明"})
assert r.status_code == 200
第三步:依赖覆盖——mock 掉 LLM 上游
# 文件: tests/test_chat_mock.py
from fastapi.testclient import TestClient
from fastapi_minimal import app, get_llm_client
def fake_llm():
class Fake:
def stream(self, prompt): yield "模拟回复"
return Fake()
app.dependency_overrides[get_llm_client] = fake_llm # 把真实 LLM 依赖换成假实现
def test_chat_with_mock():
r = TestClient(app).post("/v1/chat", json={"prompt": "hi"})
assert "模拟回复" in r.text
app.dependency_overrides.clear() # 清掉覆盖, 不影响其他测试
总结:TestClient 测契约(状态码/结构/422 校验),fixture 保证库隔离,dependency_overrides 把 LLM/支付等外部依赖换成假实现——单测不花钱也不抖。
追问1:pytest.fixture 的作用域? → function 默认(每测试一次);module/session 级共享昂贵资源(如引擎)
追问2:异步测试怎么跑? → pytest-asyncio 插件,@pytest.mark.asyncio 或配置 asyncio_mode=auto
追问3:覆盖率怎么进 CI? → pytest --cov=src --cov-fail-under=80,低于阈值 CI 失败
123. Pydantic v2:校验、序列化与 Settings?
概念 v2 核心在 Rust(pydantic-core):model_validate 入口校验、field_validator/model_validator 自定义、model_config 配置、BaseSettings(pydantic-settings 包)管理环境变量。
典型场景 LLM 响应的严格解析、配置中心加载(环境变量→强类型配置)、对外 API 的响应模型。
解决方案 三步递进:常用校验器 → 序列化控制 → Settings 配置管理。
第一步:常用校验器——字段级与模型级
# 文件: pydantic-validators.py
from pydantic import BaseModel, Field, field_validator, model_validator
class ChatConfig(BaseModel):
model: str = "glm-4-flash"
temperature: float = Field(default=0.7, ge=0, le=2)
stop_words: list[str] = []
@field_validator("temperature")
@classmethod
def round_temp(cls, v: float) -> float:
return round(v, 2) # 字段级: 单字段加工
@model_validator(mode="after")
def check_combo(self):
if self.model == "glm-4-flash" and self.temperature > 1:
raise ValueError("flash 模型温度建议 <=1") # 模型级: 跨字段约束
return self
第二步:序列化控制——对外暴露什么
# 文件: pydantic-serialization.py
from pydantic import BaseModel
class UserOut(BaseModel):
id: int
name: str
password: str = Field(exclude=True) # 序列化时剔除
u = UserOut(id=1, name="a", password="secret")
print(u.model_dump()) # {'id': 1, 'name': 'a'} —— 密码不出现
print(u.model_dump_json()) # '{"id":1,"name":"a"}'
# FastAPI 的 response_model 会在返回时自动走 model_dump 流程
第三步:Settings——环境变量到强类型配置
# 文件: config/settings.py
from pydantic_settings import BaseSettings
class Settings(BaseSettings):
glm_base_url: str
glm_api_key: str
glm_model_id: str = "glm-4-flash"
db_url: str
debug: bool = False
class Config:
env_file = ".env" # 从 .env 读取, 环境变量优先
settings = Settings() # import 时校验, 缺配置直接崩(fail-fast)
总结:v2 的三层校验(Field 约束/field_validator 加工/model_validator 跨字段);序列化用 model_dump 系;Settings 让配置错误在启动时暴露。
追问1:model_config = ConfigDict(strict=True) 干什么? → 严格模式:不自动转换(“18” 不再变 18),LLM 输出校验推荐开启防止隐性转换
追问2: computed_field 是什么? → 序列化时计算的只读字段(如 full_name)
追问3:嵌套模型部分更新(PATCH)怎么处理? → Model.model_dump(exclude_unset=True) 只取客户端显式传入的字段
124. FastAPI + LLM:网关层的限流与计费?
概念 AI 网关在应用与上游模型之间:鉴权→限流(按 token/请求数)→转发→计费(读 usage 上报)。限流算法用 Redis 令牌桶;计费读响应的 usage 字段异步落库。
典型场景 多团队共用一份模型 Key;对外售卖 API 配额;防止前端重试风暴烧穿额度。
解决方案 三步递进:Redis 令牌桶依赖 → usage 异步计费 → 全链组装。
第一步:令牌桶限流依赖
# 文件: gateway/ratelimit.py
import redis.asyncio as redis
from fastapi import HTTPException, Depends
rds = redis.Redis(host="localhost", decode_responses=True)
async def rate_limit(user_id: str):
key = f"rl:{user_id}:{int(time.time() // 60)}" # 按分钟窗口
allowed = await rds.eval(
LUA_TOKEN_BUCKET, 1, key, 10, 20, int(time.time() * 1000), 1 # 10 token/s, 桶容 20
)
if not allowed:
raise HTTPException(status_code=429, detail="请求过于频繁")
# LUA_TOKEN_BUCKET 见第一批 73 的令牌桶脚本
第二步:usage 异步计费——读响应尾巴
# 文件: gateway/billing.py
import json, time
from dataclasses import dataclass
@dataclass
class UsageRecord:
user_id: str; model: str
input_tokens: int = 0; output_tokens: int = 0
ts: float = 0.0
class Billing:
def __init__(self, redis_client):
self.redis = redis_client
def record(self, rec: UsageRecord):
key = f"usage:{rec.user_id}:{time.strftime('%Y%m%d', time.localtime(rec.ts))}"
payload = json.dumps(rec.__dict__)
self.redis.rpush(f"usage_queue", payload) # 推入队列, 消费端批量落库
第三步:网关路由组装——限流 → 转发 → 计费
# 文件: gateway/router.py
from fastapi import FastAPI, Depends
app = FastAPI()
@app.post("/v1/chat")
async def chat(
body: ChatIn,
user=Depends(auth_user), # 鉴权依赖(见 117)
_rl=Depends(rate_limit_for(user)), # 限流依赖
background: BackgroundTasks = None,
):
usage_rec = UsageRecord(user_id=user.id, model=body.model, ts=time.time())
async def on_finish(usage):
usage_rec.input_tokens = usage.input_tokens
usage_rec.output_tokens = usage.output_tokens
billing.record(usage_rec) # 流结束后异步记账, 不阻塞响应
background.add_task(on_finish, usage=...)
return StreamingResponse(gen(body, on_done=...), media_type="text/event-stream")
总结:网关 = 鉴权 → 令牌桶限流(Redis Lua 原子)→ 流式转发 → usage 异步计费;按分钟窗口+桶容量双层控制突发。
追问1:为什么限流用 Lua? → 取令牌-扣减-回写必须原子,否则并发下超发 追问2:usage 在流式响应里怎么拿? → OpenAI 兼容协议在最后一个 chunk 带 usage;非流式在响应体 usage 字段 追问3:限流维度怎么选? → 按用户+按 Key+按 IP 多维;token 级限流(而非请求数)对 LLM 更准
三、Python 后端进阶(125–144)
本章 20 题:Python 通用后端(并发实战/LLM 调用/日志/工程化/性能剖析)、同步库进 asyncio、异步连接池、Alembic 迁移、uv 依赖管理、dataclass、环境变量与 12-Factor 配置、IO 多路复用、多进程通信、结构化并发与任务取消、优雅停机、类型进阶(Protocol/泛型)、描述符、functools、单例、上下文管理器进阶。
125. Python 并发实战:线程池与进程池的选择?
概念 concurrent.futures 统一接口:ThreadPoolExecutor(IO 密集)与 ProcessPoolExecutor(CPU 密集);submit 返回 Future,map 保持顺序,as_completed 按完成顺序收。
典型场景 批量调同步 SDK(异步版不存在)、批量图片处理、批量文档解析(喂 RAG)。
解决方案 三步递进:线程池批量 IO → 进程池批量 CPU → as_completed 流式收集。
第一步:线程池——批量调用同步 LLM SDK
# 文件: pool-io.py
from concurrent.futures import ThreadPoolExecutor, as_completed
import zhipuai # 假设只有同步 SDK
client = zhipuai.ZhipuAI(api_key=KEY)
def ask(prompt: str) -> str:
return client.chat.completions.create(
model="glm-4-flash",
messages=[{"role": "user", "content": prompt}],
).choices[0].message.content
prompts = [f"问题{i}" for i in range(20)]
results = {}
with ThreadPoolExecutor(max_workers=5) as pool:
futures = {pool.submit(ask, p): p for p in prompts}
for fut in as_completed(futures): # 谁先完成先处理, 不按提交顺序阻塞
prompt = futures[fut]
results[prompt] = fut.result()
第二步:进程池——批量图片处理(CPU 密集)
# 文件: pool-cpu.py
from concurrent.futures import ProcessPoolExecutor
from PIL import Image
import os
def compress(path: str) -> str:
img = Image.open(path)
img.thumbnail((1920, 1920))
out = f"out_{os.path.basename(path)}"
img.save(out, quality=85)
return out
if __name__ == "__main__":
paths = ["a.jpg", "b.jpg", "c.jpg"]
with ProcessPoolExecutor(max_workers=4) as pool:
for out in pool.map(compress, paths): # map 保持提交顺序返回
print("完成:", out)
第三步:异常与超时——批量任务必须兜底
# 文件: pool-safe.py
from concurrent.futures import ThreadPoolExecutor, TimeoutError, as_completed
def run_all(jobs, timeout_each=30):
ok, failed = {}, {}
with ThreadPoolExecutor(max_workers=5) as pool:
futs = {pool.submit(fn, arg): arg for arg, fn in jobs}
for fut in as_completed(futs, timeout=len(futs) * timeout_each):
arg = futs[fut]
try:
ok[arg] = fut.result(timeout=timeout_each)
except TimeoutError:
failed[arg] = "超时"
except Exception as e:
failed[arg] = str(e) # 单个失败不拖垮整批
return ok, failed
总结:同步 SDK 批量调用用线程池(IO 等待释放 GIL),纯计算用进程池;as_completed 先到先处理,每个 Future 单独 try/except。
追问1:map 和 submit+as_completed 的区别? → map 按提交顺序阻塞取结果;as_completed 按完成顺序,先完成先处理 追问2:进程池里报错怎么传回来? → 异常对象 pickle 后在主进程重抛,自定义异常需可 pickle 追问3:线程数设多少? → IO 密集可远超 CPU 核数(10-50 看下游承压);CPU 密集 = 核数
126. Python 侧调用 LLM:超时、重试与降级?
概念 生产调用 LLM 必须三层防护:超时(连接/读取分离)、重试(指数退避+只重试幂等错误)、降级(主模型失败切备用模型或缓存)。
典型场景 上游 429/超时常态化;多模型路由(贵模型挂了切便宜模型);前端要求可用性优先。
解决方案 三步递进:httpx 超时与重试 → 装饰器级统一重试 → 双模型 fallback。
第一步:httpx 超时——连接和读取分开设
# 文件: llm-timeout.py
import httpx
timeout = httpx.Timeout(
connect=5.0, # 建连超时: 5s 拿不到连接就是上游挂了
read=120.0, # 读超时: LLM 生成慢, 读取要给足
write=10.0,
pool=5.0, # 从连接池拿连接的超时
)
client = httpx.Client(base_url=BASE_URL, timeout=timeout)
第二步:统一重试——只重试”值得重试”的错误
# 文件: llm-retry.py
import time, random, httpx
RETRY_STATUS = {429, 500, 502, 503, 504} # 401/400 重试无意义
def post_chat(payload: dict, tries: int = 3):
for attempt in range(tries):
try:
r = client.post("/chat/completions", json=payload)
if r.status_code in RETRY_STATUS:
raise httpx.HTTPStatusError("可重试状态", request=r.request, response=r)
r.raise_for_status()
return r.json()
except (httpx.TimeoutException, httpx.HTTPStatusError) as e:
retryable = not isinstance(e, httpx.HTTPStatusError) or e.response.status_code in RETRY_STATUS
if attempt == tries - 1 or not retryable:
raise
delay = (2 ** attempt) + random.random() # 指数退避 + 抖动防惊群
time.sleep(delay)
第三步:双模型 fallback——可用性优先
# 文件: llm-fallback.py
def chat_with_fallback(payload: dict) -> dict:
for model in ("glm-4-plus", "glm-4-flash"): # 主 → 备
p = {**payload, "model": model}
try:
return post_chat(p)
except Exception as e:
print(f"模型 {model} 失败({e}), 尝试备用")
raise RuntimeError("全部模型不可用")
总结:超时分 connect/read(生成慢,读取给足);重试只针对 429/5xx 且指数退避+抖动;双模型 fallback 保可用性,降级路径要有监控告警。
追问1:流式请求能重试吗? → 已吐出内容后不能重试(会重复);只在首字节前失败才安全重试 追问2:429 的 Retry-After 头? → 服务端建议等待秒数,优先用它而不是自己的退避计算 追问3:降级到便宜模型,答案质量下降怎么发现? → 记录 fallback 比例与命中模型,评测集双跑对比
127. Python 日志:logging 的正确配置?
概念 logging 四组件:Logger(入口)、Handler(输出目的地)、Formatter(格式)、Filter;层级 propagate。生产要求:结构化(JSON)、按级别、带 traceId、不用 print。
典型场景 FastAPI 服务接入 ELK/Loki;排查线上问题需要按 traceId 串联一次请求的所有日志。
解决方案 三步递进:标准配置 → JSON 结构化 → FastAPI 中间件注入 traceId。
第一步:标准配置——级别与格式
# 文件: logging-setup.py
import logging
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s %(levelname)s %(name)s %(message)s",
datefmt="%Y-%m-%d %H:%M:%S",
)
log = logging.getLogger("app.llm")
log.info("调用模型 %s", "glm-4-flash") # 用 %s 惰性格式化, 禁用 f-string(级别不够时不计算)
第二步:JSON 结构化——机器可采集
# 文件: logging-json.py
import logging, json
class JsonFormatter(logging.Formatter):
def format(self, record: logging.LogRecord) -> str:
payload = {
"ts": self.formatTime(record),
"level": record.levelname,
"logger": record.name,
"msg": record.getMessage(),
}
if record.exc_info:
payload["exc"] = self.formatException(record.exc_info)
return json.dumps(payload, ensure_ascii=False)
handler = logging.StreamHandler()
handler.setFormatter(JsonFormatter())
log = logging.getLogger("app")
log.addHandler(handler)
log.setLevel(logging.INFO)
log.info("结构化日志", extra={}) # ELK/Loki 直接按字段解析
第三步:traceId 注入——一次请求的日志全串起来
# 文件: logging-trace.py
import contextvars, uuid
trace_id_var = contextvars.ContextVar("trace_id", default="-")
class TraceFormatter(JsonFormatter):
def format(self, record):
record.trace_id = trace_id_var.get() # 从上下文取, 协程安全
return super().format(record)
# FastAPI 中间件里:
# trace_id_var.set(uuid.uuid4().hex[:12]) # 每个请求入口设置
# 同一请求的所有日志自动带同一 trace_id → ELK 里一条 grep 拉全链
总结:logging 四件套配置一次;生产用 JSON + contextvars 注入 traceId(协程安全);禁 print、禁 f-string 日志。
追问1:contextvars 和 threading.local 区别? → contextvars 协程安全(asyncio 每任务独立上下文);threading.local 在协程下会串
追问2:日志级别怎么动态调? → logging.getLogger(...).setLevel(...),配合配置中心热更
追问3:第三方库日志太吵? → logging.getLogger("httpx").setLevel(WARNING) 单独压级别
128. Python 项目工程化:venv/依赖/项目结构?
概念 虚拟环境隔离解释器与依赖(pyenv/uv 管理 Python 版本);依赖三件套 requirements.txt(锁版本)/pyproject.toml(现代标准);分层结构 router/service/schema/model 各归其位。
典型场景 新项目起手;多人协作”我这里能跑”;FastAPI 项目从单文件演进到多模块。
解决方案 三步递进:环境与依赖 → 标准项目结构 → 从单文件拆分的信号。
第一步:环境与依赖
# 文件: setup.sh
python -m venv .venv && source .venv/bin/activate
pip install fastapi "uvicorn[standard]" httpx pydantic-settings sqlalchemy[asyncio] asyncmy
pip freeze > requirements.txt # 锁定版本, CI/生产按此安装(pip install -r)
# 现代替代: uv venv && uv pip install ...(uv 用 Rust 实现, 安装快 10-100 倍)
第二步:标准项目结构
app/
├── main.py # FastAPI 实例与路由注册
├── config/settings.py # pydantic-settings(见 123)
├── api/routes/ # 路由层: 只做参数解析与调用 service
│ ├── chat.py
│ └── users.py
├── services/ # 业务层: 事务编排、外部调用
│ └── llm_service.py
├── schemas/ # pydantic 模型(请求/响应)
├── db/ # engine/crud/models
├── core/ # 中间件、异常、日志、安全
└── tests/
第三步:拆分信号——单文件什么时候该拆
- routes 超过 300 行 → 按资源拆 router
- 业务逻辑出现在路由函数里 → 下沉 service(路由只解析参数+调 service+包装响应)
- pydantic 模型重复出现 → 收敛到 schemas, 请求模型与响应模型分离
- 配置散落各处 → 统一 Settings 对象注入
总结:venv 隔离 + freeze 锁版本是底线;分层按 router→service→db 依赖单向;拆分由实际规模驱动,不过度设计。
追问1:uv 是什么? → Astral 出品的 Python 包管理器(Rust 实现),pip/venv 的超集替代,极快 追问2:pyproject.toml 相比 requirements.txt? → 项目元数据+依赖声明标准化(PEP 621),配合 poetry/uv 做锁文件 追问3:service 层怎么拿到数据库会话? → 会话由依赖注入到路由再传给 service;service 不自己建会话(便于测试替换)
129. Python 性能剖析:cProfile 与内存热点?
概念 cProfile 统计函数级耗时(累计时间/调用次数);timeit 测微基准;tracemalloc 追踪内存分配热点。优化第一步永远是测量。
典型场景 接口 P95 偏高但不知道慢在哪;批量脚本跑得慢;服务内存持续上涨(见 108)。
解决方案 三步递进:cProfile 定位函数热点 → 只优化真正的大头 → tracemalloc 查内存。
第一步:cProfile——找出耗时的 20% 函数
# 文件: profile_run.sh
python -m cProfile -s cumtime my_script.py # 按累计时间排序输出
# 或代码内:
# import cProfile; cProfile.run("main()", sort="cumtime")
第二步:解读输出——别优化错地方
ncalls tottime percall cumtime percall filename:lineno(function)
1000 8.2s 0.008 8.9s 0.009 llm.py:24(chat) ← 累计 8.9s(含等待)
5000 0.4s 0.000 0.5s 0.000 utils.py:11(parse)
# tottime: 函数自身耗时(不含子调用); cumtime: 含子调用
# LLM 调用 cumtime 高是"等上游", 优化方向是并发/缓存而非改代码
# 自身耗时高的纯计算函数才是代码优化对象
第三步:tracemalloc——内存分配在哪
# 文件: tracemalloc-demo.py
import tracemalloc
tracemalloc.start()
def load_docs():
return [open(f"doc_{i}.txt").read() for i in range(1000)] # 全部读入内存
snapshot = tracemalloc.take_snapshot()
for stat in snapshot.statistics("lineno")[:3]:
print(stat) # 按行号给出分配的字节数与次数 → 精确到行
# 修复: 改成生成器逐个产出(见 103 惰性读取)
总结:性能问题先 cProfile 看 tottime/cumtime 区分”计算慢”还是”等待慢”;内存热点用 tracemalloc 精确到行;不测量不优化。
追问1:cProfile 对 async 代码准吗? → 不完全准(协程切换使 cumtime 失真),异步栈用 py-spy 采样更可靠
追问2:py-spy 是什么? → 无侵入采样剖析器,py-spy top --pid <pid> 直接看线上进程热点,不用改代码
追问3:常见 Python 性能误区? → 微优化字符串拼接却无视 O(n²) 算法;过早优化;忽视 IO 等待才是大头
130. 同步阻塞库怎么在 asyncio 里用?
概念 只有同步版的 SDK(老版数据库驱动/内部工具)阻塞的是当前线程——在协程里直接调用会冻结整个事件循环。方案:loop.run_in_executor / asyncio.to_thread 丢线程池。
典型场景 内部 RPC SDK 只有同步版、同步 Redis 客户端、重 CPU 的解析函数混在异步链路里。
解决方案 两步递进:to_thread 一行救急 → 线程池隔离重活。
第一步:to_thread——同步函数丢线程池
# 文件: to-thread.py
import asyncio
def sync_heavy_query(keyword: str) -> list:
"""内部同步 SDK, 无法改成 async"""
import time
time.sleep(1) # 模拟同步阻塞
return [f"doc-{keyword}-{i}" for i in range(10)]
async def handler(keyword: str) -> list:
return await asyncio.to_thread(sync_heavy_query, keyword)
# 等价旧写法: loop.run_in_executor(None, sync_heavy_query, keyword)
# 丢线程池后事件循环继续服务其他请求 —— 5 个并发 handler 总耗时仍约 1s
第二步:专用线程池——隔离重活防挤占
# 文件: to-thread-pool.py
import asyncio, functools
from concurrent.futures import ThreadPoolExecutor
heavy_pool = ThreadPoolExecutor(max_workers=4, thread_name_prefix="heavy")
async def run_heavy(fn, *args):
loop = asyncio.get_running_loop()
return await loop.run_in_executor(heavy_pool, functools.partial(fn, *args))
# 默认池与重活共用会互相挤占 —— 重计算专用池, 限制并发上限
总结:同步库进协程的两条路——asyncio.to_thread(简单场景)与专用 executor(隔离重活);根本上还是要推动 SDK 异步化。
追问1:to_thread 和 run_in_executor 的区别? → to_thread 是 3.9+ 封装,内部用默认 executor;需要指定池/取消语义时用 run_in_executor
追问2:CPU 密集丢线程池行吗? → 不行,GIL 串行化;CPU 密集用 ProcessPoolExecutor 或独立服务
追问3:怎么发现协程里的同步阻塞? → loop.set_debug(True) + slow_callback_duration 阈值,日志会警告超时协程
131. 数据库连接池在异步服务的正确姿势?
概念 连接池参数决定并发上限:pool_size(常驻)+ max_overflow(峰值弹性);异步服务生命周期长,pool_recycle 防数据库断连;应用退出要显式 engine.dispose()。
典型场景 压测时大量 TimeoutError: queue pool limit;早高峰后偶发”MySQL server has gone away”;优雅停机时连接未释放。
解决方案 三步递进:池参数怎么算 → 断连怎么防 → 生命周期怎么收。
第一步:池参数——按并发与数据库配额倒推
# 文件: pool-sizing.py
"""
容量计算(经验公式):
应用侧总连接 = (pool_size + max_overflow) x 实例数, 不超过数据库 max_connections x 0.8
例: DB max_connections=500, 4 个实例 → 每实例 (pool_size+max_overflow) 不超过 100
设 pool_size=50, max_overflow=50 → 峰值 100/实例, 4 实例 400 < 400 安全
pool_recycle=3600: 空闲超 1 小时的连接回收 —— 防 MySQL wait_timeout 断连报错
pool_pre_ping=True: 取连接前 ping 一次, 坏连接自动重建(多一 RTT, 稳妥优先可开)
"""
第二步:断连与慢查询——两条防线
# 文件: pool-guards.py
engine = create_async_engine(
DB_URL,
pool_size=50, max_overflow=50,
pool_recycle=3600,
pool_pre_ping=True, # 断连防线
)
# 慢查询防线: 会话执行加语句级超时(MySQL: max_execution_time hint; PG: set_local statement_timeout)
STMT_TIMEOUT = "/*+ MAX_EXECUTION_TIME(3000) */" # MySQL 3s
# 或在会话建立时: await session.execute(text("SET SESSION max_execution_time=3000"))
第三步:优雅停机——dispose 释放连接池
# 文件: pool-lifespan.py
from contextlib import asynccontextmanager
from fastapi import FastAPI
@asynccontextmanager
async def lifespan(app: FastAPI):
yield
await engine.dispose() # 关闭全部池连接, K8s 滚动更新不残留
app = FastAPI(lifespan=lifespan)
总结:池容量按”实例数x上限 不超过 DB 配额x0.8”倒推;pool_recycle+pool_pre_ping 双防线防断连;停机时 engine.dispose()。
追问1:连接池耗尽什么症状? → 请求堆积,日志出现 queue pool limit reached,随后大量超时 追问2:pool_size=0 可以吗? → 可以(无限流模式,全走 overflow),失去常驻复用,仅低流量用 追问3:读写分离怎么配? → 两个 engine(写主/读从),service 层按操作类型选会话;或数据库中间件代理
132. Python 侧的数据库迁移(Alembic)?
概念 Alembic 是 SQLAlchemy 官方迁移工具:模型变更 → autogenerate 生成迁移脚本 → upgrade 执行;版本表记录历史,支持升级/回滚。
典型场景 ORM 模型加字段后同步线上库;多环境(dev/test/prod)schema 漂移;回滚一次危险变更。
解决方案 三步递进:初始化与生成 → 审查迁移脚本(自动生成的必看) → 回滚。
第一步:初始化与生成
# 文件: alembic-setup.sh
alembic init migrations
# alembic.ini: sqlalchemy.url = mysql+asyncmy://...
# migrations/env.py: target_metadata = Base.metadata(指向 ORM 元数据)
alembic revision --autogenerate -m "add posts table"
alembic upgrade head
第二步:审查脚本——autogenerate 不完美
# 文件: migrations/versions/a1b2_add_posts.py
def upgrade() -> None:
op.create_table(
"posts",
sa.Column("id", sa.Integer, primary_key=True),
sa.Column("title", sa.String(200), nullable=False),
sa.Column("user_id", sa.Integer, sa.ForeignKey("users.id")),
)
op.create_index("ix_posts_user_id", "posts", ["user_id"])
# 必审: autogenerate 检测不到改名(表名/列名会被识别为删+建, 数据丢失!)
# 大表加列: MySQL 8 无 INSTANT 算法时锁表, 生产低峰执行或用 pt-online-schema-change
def downgrade() -> None:
op.drop_table("posts")
第三步:回滚与漂移检查
# 文件: alembic-ops.sh
alembic downgrade -1 # 回滚一个版本
alembic history # 查看版本链
alembic check # 检测模型与迁移是否漂移(CI 里跑, 防止忘生成迁移)
总结:迁移流程 = 改模型 → autogenerate → 人工审查 → upgrade;改名类变更手写;CI 加 alembic check 防漂移。
追问1:autogenerate 检测不到什么? → 改名(表/列)、部分类型变更、服务端默认值——需手写迁移 追问2:大表加索引怎么不锁表? → MySQL 8 InnoDB 支持 ONLINE DDL(ALGORITHM=INPLACE);数据量极大用 gh-ost/pt-osc 追问3:多服务共用一个库,迁移怎么管? → 迁移脚本集中归一个服务/仓库所有,其余服务只读 schema;避免各自生成冲突版本
133. Python 的 uv 与依赖管理现代化?
概念 uv 是 Rust 实现的 Python 包管理器:安装快 10-100 倍,统一管理 Python 版本、虚拟环境、依赖锁(uv.lock);pyproject.toml(PEP 621)为项目元数据标准。
典型场景 pip 装大包(含编译依赖)巨慢;多项目 Python 版本不一;锁文件缺失导致”我这里能跑”。
解决方案 三步递进:uv 快速上手 → pyproject + lock → CI 与 Docker 里的用法。
第一步:uv 上手——三行起项目
# 文件: uv-setup.sh
uv init my-app && cd my-app # 生成 pyproject.toml
uv add fastapi uvicorn httpx # 安装依赖并写入 pyproject + 生成 uv.lock
uv run uvicorn app.main:app --reload # uv run 自动激活虚拟环境
uv python install 3.12 # 连 Python 解释器都帮你装
第二步:pyproject 与锁文件
# 文件: pyproject.toml
[project]
name = "ai-app"
requires-python = ">=3.11"
dependencies = [
"fastapi>=0.115",
"httpx>=0.27",
]
[dependency-groups]
dev = ["pytest>=8", "pytest-asyncio>=0.24"]
# 文件: uv-sync.sh
uv sync # 按 uv.lock 精确安装(等价 npm ci)—— 团队/CI 环境一致
uv add --dev pytest # dev 组依赖, 生产不装
第三步:Docker 里用 uv
# 文件: Dockerfile
FROM python:3.12-slim
COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
WORKDIR /app
COPY pyproject.toml uv.lock ./
RUN uv sync --frozen --no-dev # frozen: 严格按 lock 装, 不联网校验最新
COPY app ./app
CMD ["uv", "run", "uvicorn", "app.main:app", "--host", "0.0.0.0"]
总结:uv = Python 版本的 npx+lockfile 一体化;uv sync --frozen 保证环境一致;pyproject.toml 是声明,uv.lock 是精确快照。
追问1:uv.lock 要提交 git 吗? → 要,锁文件保证全团队/CI 二进制级一致
追问2:还能用 pip 吗? → 可以,uv pip install -r requirements.txt 兼容旧流程,渐进迁移
追问3:uv 和 poetry 的关系? → 目标重叠(依赖管理),uv 胜在速度与多版本 Python 管理;存量 poetry 项目不必强行迁移
134. Python 的 dataclass 与 @property 的工程用法?
概念 @dataclass 自动生成 __init__/__repr__/__eq__;frozen=True 不可变(可哈希);@property 把方法包装成只读属性,实现派生值与访问保护。
典型场景 配置对象、值对象(DTO 内部传递)、需要派生字段但不落库。
解决方案 三步递进:dataclass 基础与 frozen → property 派生值 → dataclass 与 pydantic 选型。
第一步:dataclass——三行换一个值对象
# 文件: dataclass-basic.py
from dataclasses import dataclass, field
@dataclass(frozen=True) # frozen: 不可变 → 可哈希, 能进 set/做 dict key
class PageRequest:
page: int = 1
size: int = 20
order_by: str = "id"
tags: list[str] = field(default_factory=list) # 可变默认必须用 default_factory
r = PageRequest(page=2)
print(r) # PageRequest(page=2, size=20, ...) —— 自带 repr
# r.page = 3 会抛 FrozenInstanceError —— 配置对象防误改
第二步:property——派生值与只读保护
# 文件: property-usage.py
class Conversation:
def __init__(self, messages: list[dict]):
self._messages = messages
@property
def total_tokens(self) -> int: # 派生值: 不存储, 实时计算
return sum(m.get("tokens", 0) for m in self._messages)
@property
def last_user_msg(self) -> str | None:
for m in reversed(self._messages):
if m.get("role") == "user":
return m["content"]
return None
conv = Conversation([{"role": "user", "content": "hi", "tokens": 10}])
print(conv.total_tokens) # 10 —— 像属性一样访问, 内部是计算
第三步:dataclass 与 pydantic 选型
内部值对象/配置, 边界可信 → dataclass(零开销, 纯标准库)
外部输入(请求体/LLM 输出), 边界不可信 → pydantic(运行时校验+转换)
原则: 校验发生在边界, 内部传递用轻量 dataclass
总结:dataclass 管值对象(frozen 防误改, default_factory 防共享可变默认);property 管派生值;边界校验交 pydantic,内部传递用 dataclass。
追问1:__post_init__ 是什么? → dataclass 初始化后的钩子,做字段加工/校验(如规范化字符串)
追问2:frozen 但含 list 字段会怎样? → 容器内容仍可变(frozen 只冻结属性绑定);要彻底不可变用 tuple
追问3:property 能有 setter 吗? → 可以,@total_tokens.setter 定义写入行为,写入时做校验/转换
135. Python 环境变量与 12-Factor 配置?
概念 12-Factor:配置全部来自环境变量,同一镜像跑多环境。Python 侧落地:pydantic-settings 强类型加载 + .env 本地开发 + CI/生产注入。
典型场景 本地/测试/生产的模型 Key 与地址不同;配置缺失在半夜才被发现;换环境要改代码。
解决方案 三步递进:Settings 单例 → 缺配置 fail-fast → 分环境加载。
第一步:Settings 单例——一处定义处处引用
# 文件: config/settings.py
from pydantic_settings import BaseSettings
class Settings(BaseSettings):
glm_base_url: str
glm_api_key: str
glm_model_id: str = "glm-4-flash"
db_url: str
redis_url: str = "redis://localhost:6379/0"
log_level: str = "INFO"
settings = Settings() # import 时校验: 缺 key 直接启动失败(fail-fast)
第二步:使用方只 import settings
# 文件: services/llm.py
from config.settings import settings
import httpx
def chat(prompt: str) -> str:
r = httpx.post(
f"{settings.glm_base_url}/chat/completions",
headers={"Authorization": f"Bearer {settings.glm_api_key}"},
json={"model": settings.glm_model_id, "messages": [{"role": "user", "content": prompt}]},
timeout=60,
)
return r.json()["choices"][0]["message"]["content"]
# 全服务零 os.environ 散落 —— 换配置不改代码
第三步:环境分层——.env 只属于本地
# 文件: .env(本地, gitignore 掉)
GLM_BASE_URL=https://open.bigmodel.cn/api/paas/v4
GLM_API_KEY=xxx
DB_URL=mysql+asyncmy://root:pass@localhost/aiapp
测试/生产: K8s Secret / CI 注入环境变量, 不落文件
.env.example 提交 git, 列出所有必需变量作为文档
总结:配置全部走环境变量(12-Factor);pydantic-settings 启动时校验缺失即崩;.env 只本地,example 进库当文档。
追问1:配置热更新怎么做? → pydantic-settings 本身不支持,配置中心(Nacos/Apollo)轮询或监听推送,重载 Settings 追问2:同一变量多来源优先级? → 环境变量 > .env > 默认值(显式指定优先级链) 追问3:敏感配置怎么进 CI? → CI 平台的加密变量(Secrets),日志里脱敏(mask 掉 Key 只露尾 4 位)
136. Python 的 IO 多路复用与 asyncio 的关系?
概念 asyncio 的底层是操作系统 IO 多路复用(Linux epoll/mac kqueue):单线程监听大量 socket,内核就绪通知后恢复对应协程。理解它才能回答”单线程凭什么扛高并发”。
典型场景 面试深挖”事件循环底层”;排查”为什么 asyncio 服务 CPU 100% 但吞吐低”(可能是高频小任务堆积而非阻塞)。
解决方案 三步递进:阻塞 IO 的问题 → 多路复用模型 → 与 asyncio 的对应关系。
第一步:阻塞 IO 的老路——一连接一线程
传统: 每个连接一个线程 → 1000 连接 = 1000 线程 → 内存与上下文切换开销爆炸
瓶颈: 线程在等待数据期间占着资源干等
第二步:多路复用——一个线程监听全部 socket
# 文件: epoll-model.py
# 概念示意(生产用 asyncio, 不手写 select)
import selectors, socket
sel = selectors.DefaultSelector() # Linux=epoll, mac=kqueue
server = socket.socket()
server.bind(("0.0.0.0", 8000))
server.listen()
server.setblocking(False)
sel.register(server, selectors.EVENT_READ) # 注册关注"可读"
while True:
events = sel.select(timeout=1) # 内核通知: 哪些 socket 就绪了
for key, _ in events:
if key.data is None: # 是监听 socket → 新连接
conn, addr = key.fileobj.accept()
conn.setblocking(False)
sel.register(conn, selectors.EVENT_READ, data=conn)
else: # 是已连接 socket → 有数据可读
data = key.fileobj.recv(1024)
if data:
key.data.sendall(data.upper())
else:
sel.unregister(key.fileobj); key.fileobj.close()
# 1 个线程 + 内核事件通知 = 同时服务上千连接
第三步:与 asyncio 的对应——事件循环就是上述 while True 的工业化封装
asyncio 事件循环 = selector(epoll) + 就绪回调表 + 协程调度
- socket 就绪 → 回调恢复对应协程(await 处继续)
- await asyncio.sleep → 注册定时器堆
- await loop.run_in_executor → 线程池完成后再通知事件循环
结论: asyncio 单线程不代表不能并发; 它把"等"的成本降为零, 只有 CPU 计算是串行的
总结:epoll 解决”一个线程看一堆 socket”;asyncio 在其上封装协程调度;单线程高并发的本质=内核就绪通知+用户态切换。
追问1:epoll 的 LT 和 ET 模式? → 水平触发(就绪就一直通知)与边缘触发(状态变化只通知一次,必须读到 EAGAIN);Python selectors 默认 LT 追问2:asyncio 服务 CPU 打满但没流量,查什么? → 高频小任务堆积(如每秒万次 sleep(0)),或 debug 模式未关 追问3:uvloop 是什么? → Cython 实现的高性能事件循环(libuv 移植),设置 EventLoopPolicy 后快 2-4 倍
137. Python 的多进程通信与共享状态?
概念 multiprocessing 各进程独立内存空间:数据交换靠序列化(Pickle)——Queue/Pipe 传消息、Manager 共享结构、shared_memory 共享字节块。进程间没有”免费”的共享变量。
典型场景 批量处理任务需要汇总结果、子进程要读主进程的大模型/大配置、CPU 并行分片计算。
解决方案 三步递进:Pool 返回值(最常用) → Queue 流水线 → 共享内存的边界。
第一步:Pool 的返回值——80% 场景够用
# 文件: mp-pool.py
from multiprocessing import Pool
def analyze(doc_id: int) -> dict:
... # 重计算: 解析+统计
return {"doc_id": doc_id, "tokens": 1024}
if __name__ == "__main__":
with Pool(4) as pool:
results = pool.map(analyze, range(100)) # 自动 pickle 传参/回传
total = sum(r["tokens"] for r in results)
第二步:Queue 流水线——生产消费解耦
# 文件: mp-queue.py
from multiprocessing import Process, Queue
def producer(q: Queue):
for i in range(10):
q.put(f"item-{i}")
q.put(None) # 结束哨兵
def consumer(q: Queue):
while True:
item = q.get()
if item is None:
break
print("消费", item)
if __name__ == "__main__":
q = Queue()
p1 = Process(target=producer, args=(q,))
p2 = Process(target=consumer, args=(q,))
p1.start(); p2.start(); p1.join(); p2.join()
第三步:大对象共享——能 pickle 就传,传不起就落盘
# 文件: mp-bigdata.py
"""
大模型/大索引对象无法 pickle → 三种选择:
1. 子进程各自加载(内存 x N, 最简单)
2. 落盘(npz/parquet/Redis), 子进程按需读
3. shared_memory 共享字节块(仅限 ndarray 等平坦结构, 需手动生命周期管理)
原则: 能用消息传递(Pool/Queue)就不要共享内存 —— 共享状态的并发 bug 代价远高于拷贝成本
"""
总结:进程通信靠序列化——Pool 返回值最常用,Queue 做流水线;大对象优先各自加载或落盘,共享内存是最后手段。
追问1:Pool.map 和 imap 的区别? → map 一次性收集(按序);imap 惰性按序产出,imap_unordered 按完成序
追问2:子进程能继承日志配置吗? → fork 模式可以继承;spawn(macOS/Win 默认)重新 import,需在子进程入口重新配置
追问3:if __name__ == "__main__" 为什么必须? → spawn 模式子进程重新 import 主模块,没有守卫会无限递归创建进程
138. Python 的结构化并发与任务取消?
概念 TaskGroup(3.11+)提供结构化并发:组内任务任一异常则全部取消并聚合抛出(ExceptionGroup);asyncio.wait_for/timeout 控制单任务超时;task.cancel() 协作式取消。
典型场景 一次请求并发调 3 个下游,“一个挂全取消”;LLM 调用整体超时;优雅取消后台批处理。
解决方案 三步递进:TaskGroup 全取消语义 → wait_for 单任务超时 → cancel 的协作性。
第一步:TaskGroup——一个挂,全取消
# 文件: taskgroup.py
import asyncio, httpx
async def fetch(url):
async with httpx.AsyncClient() as client:
r = await client.get(url)
return r.text[:50]
async def main():
async with asyncio.TaskGroup() as tg: # 3.11+
t1 = tg.create_task(fetch("https://httpbin.org/delay/1"))
t2 = tg.create_task(fetch("https://httpbin.org/status/500"))
# 走到这说明全部成功; 任一异常 → 抛 ExceptionGroup, 其余任务被取消
print(t1.result())
第二步:wait_for/timeout——单任务超时
# 文件: wait-for.py
import asyncio
async def slow_llm():
await asyncio.sleep(30)
return "太慢了"
async def main():
try:
result = await asyncio.wait_for(slow_llm(), timeout=5)
except TimeoutError: # 3.11+ 原生 TimeoutError
result = "降级响应: 默认提示" # 超时转降级
print(result)
# 3.11+ 也可用: async with asyncio.timeout(5): ...
第三步:cancel 是协作式的——协程要配合才能停
# 文件: cancel-coop.py
import asyncio
async def worker():
try:
while True:
await asyncio.sleep(1) # 取消只在 await 点生效
print("working")
except asyncio.CancelledError:
print("清理资源")
raise # 规范: 清理后重新抛出, 不要吞掉
async def main():
t = asyncio.create_task(worker())
await asyncio.sleep(3)
t.cancel()
try:
await t # 观察取消结果
except asyncio.CancelledError:
print("任务已取消")
总结:TaskGroup 提供”全有全无”语义(适合并行调下游);wait_for 提供单任务超时;取消是协作式的——只在 await 点生效,清理后必须重新抛出。
追问1:ExceptionGroup 怎么拆? → except* TimeoutError(3.11+)按类型分别捕获组内异常
追问2:同步代码里 cancel 有效吗? → 无效——没有 await 点就永远到不了取消检查;这就是异步路由禁止同步阻塞的深层原因
追问3:TaskGroup 里需要部分失败容忍怎么办? → 别用 TaskGroup,改 gather(…, return_exceptions=True) 自行过滤
139. Python 服务的优雅停机与信号处理?
概念 停机信号(SIGTERM)到达时:停止接新请求 → 等待在途请求完成(超时强杀)→ 释放连接池/队列。asyncio 侧注意:后台任务要纳入生命周期统一取消等待。
典型场景 K8s 滚动更新(不优雅=在途请求被掐断)、发版时 LLM 流式响应被截断、进程退出时报错一片。
解决方案 三步递进:lifespan 捕获停机 → 后台任务统一管理 → 超时强制。
第一步:lifespan——停机钩子
# 文件: graceful-lifespan.py
import asyncio
from contextlib import asynccontextmanager
from fastapi import FastAPI
background_tasks: set[asyncio.Task] = set()
@asynccontextmanager
async def lifespan(app: FastAPI):
# 启动: 建池/开调度
yield
# 停机: 取消全部后台任务并等待完成
for t in background_tasks:
t.cancel()
await asyncio.gather(*background_tasks, return_exceptions=True)
await engine.dispose()
app = FastAPI(lifespan=lifespan)
第二步:后台任务登记——可追踪才可取消
# 文件: tracked-task.py
import asyncio
def spawn(coro) -> asyncio.Task:
t = asyncio.create_task(coro)
background_tasks.add(t)
t.add_done_callback(background_tasks.discard) # 完成后自动移出集合
return t
# SSE 转发任务/计费落库任务都经 spawn 创建 → 停机时一个不漏
第三步:K8s 侧配合——两个参数决定停机体验
terminationGracePeriodSeconds: 30 # 给 SIGTERM 后的收尾时间
preStop sleep 5 # 与负载均衡摘流量重叠, 避免断流
应用侧: uvicorn 收到 SIGTERM 自动停止接新请求并等在途请求(默认无超时, 建议应用层兜底)
总结:优雅停机 = 停流量 → 等在途(超时强杀)→ 取消后台任务 → 释放资源;后台任务必须登记在集合里才可取消。
追问1:SIGTERM 和 SIGKILL 区别? → SIGTERM 可捕获可清理;SIGKILL 立即终止无任何钩子——所以收尾逻辑必须在宽限期内完成 追问2:在途 SSE 长连接停机怎么办? → 无法等全部完成,策略:通知客户端重连(带 session 续传)或宽限期到强制断 追问3:怎么验证优雅停机生效? → 压测中滚动发版,观察错误率曲线无尖刺;日志确认处理完最后一个请求后退出
140. 类型注解进阶(Protocol/泛型/TypeVar)?
概念 Protocol(结构化鸭子类型的静态版):有对应方法即匹配,无需继承;TypeVar/泛型让容器与函数保持类型流动;typing 常用工具(Cast/Final/overload)补齐动态语言的静态表达。
典型场景 依赖倒置(接口约束而不强求继承);通用工具函数保留类型;SDK/库的类型设计。
解决方案 三步递进:Protocol 结构化匹配 → 泛型工具函数 → 常用 typing 工具。
第一步:Protocol——按结构匹配的”接口”
# 文件: protocol-demo.py
from typing import Protocol
class LLMClient(Protocol): # 只描述形状, 不要求继承
def complete(self, prompt: str) -> str: ...
class FakeLLM: # 没继承 Protocol, 但结构匹配
def complete(self, prompt: str) -> str:
return "fake"
def run(client: LLMClient, q: str) -> str: # FakeLLM 也能传(结构满足)
return client.complete(q)
print(run(FakeLLM(), "hi")) # 类型检查通过 —— 鸭子类型的静态版
第二步:泛型——类型在容器/函数中流动
# 文件: generics-demo.py
from typing import TypeVar, Generic
T = TypeVar("T")
def first(items: list[T]) -> T: # 入参 list[str] → 返回 str(类型流动)
return items[0]
class Box(Generic[T]): # 泛型容器
def __init__(self, item: T): self.item = item
def get(self) -> T: return self.item
s: str = first(["a", "b"]) # 推导为 str
b: Box[int] = Box(42)
第三步:常用 typing 工具
# 文件: typing-tools.py
from typing import cast, Final, overload
MAX_RETRY: Final[int] = 3 # Final: 常量声明(重赋值报错)
@overload # overload: 按参数类型给不同签名
def parse(x: int) -> str: ...
@overload
def parse(x: str) -> int: ...
def parse(x): # 实现体
return str(x) if isinstance(x, int) else int(x)
raw: object = json.loads('{"a":1}') # 第三方无类型返回
data = cast(dict, raw) # cast: 断言(运行时零开销)
总结:Protocol 按结构匹配(解耦不靠继承);TypeVar/泛型保持类型流动;cast/Final/overload 补齐静态表达。类型系统是大型 Python 项目的可维护性地基。
追问1:Protocol 和 ABC 的区别? → ABC 要求显式继承(名义类型);Protocol 看结构(结构类型)——第三方类无法改继承时 Protocol 唯一可行
追问2:泛型约束怎么写? → T = TypeVar("T", bound=Comparable) 限定必须有比较能力
追问3:python -m mypy 怎么进 CI? → mypy --strict src/,渐进式:新代码 strict、旧代码逐步迁移
141. 描述符与属性查找链?
概念 描述符协议(__get__/__set__/__delete__):定义在类上的对象,接管属性访问。数据描述符(含 __set__)优先于实例 __dict__,非数据描述符反之。property/classmethod/ORM 字段都是描述符。
典型场景 理解 property 的底层;ORM 字段(Flask-SQLAlchemy)原理;面试深挖”Python 属性查找顺序”。
解决方案 三步递进:最小描述符 → 查找链完整版 → property 的描述符本质。
第一步:最小描述符——一个可复用的属性逻辑
# 文件: descriptor-basic.py
class Positive:
def __set__(self, instance, value): # 拦截赋值
if value <= 0:
raise ValueError("必须为正数")
instance.__dict__[self.name] = value # 存到实例字典
def __set_name__(self, owner, name):
self.name = name # 3.6+: 自动获知属性名
class Order:
amount = Positive() # 每个用到的地方一行复用
o = Order()
o.amount = 100 # 走 Positive.__set__
# o.amount = -1 → ValueError
第二步:完整的属性查找链
obj.attr 的查找顺序:
1. 数据描述符(定义了 __set__/__delete__ 的类属性) ← 优先级最高
2. 实例 __dict__['attr']
3. 非数据描述符(只定义 __get__: 函数/property 的一部分形态)
4. 类 __dict__['attr'] 的普通值
5. __getattr__(attr)(以上全落空时的钩子)
property 是数据描述符 → 类上定义 property 后实例同名属性无法覆盖(第 1 步拦截)
第三步:property 的描述符本质
# 文件: property-essence.py
# property() 返回的就是一个数据描述符对象:
class Celsius:
def __get__(self, obj, objtype=None): return (obj._f - 32) * 5 / 9
def __set__(self, obj, value): obj._f = value * 9 / 5 + 32
class Temp:
c = Celsius() # 手写等价于 @property + @setter
t = Temp()
t.c = 25 # __set__: 换算存 _f
print(t._f) # 77.0 —— property 只是描述符的语法糖
总结:描述符是 Python 属性机制的底层协议;查找链”数据描述符 > 实例字典 > 非数据描述符”;property/classmethod/ORM 字段全靠它——面试答出这层就是深水区。
追问1:函数为什么是描述符? → 函数有 __get__(返回绑定方法)——这就是方法自动绑定 self 的机制
追问2:__getattr__ 和 __getattribute__ 区别? → 后者拦截所有访问(慎用,易递归);前者只在常规查找失败后调用
追问3:slots 与描述符的关系? → __slots__ 干掉实例 __dict__(查找链第 2 步消失)省内存;slot 本身是描述符
142. functools 与迭代工具箱?
概念 functools 高频件:lru_cache(缓存)/partial(偏函数)/reduce/cached_property;迭代工具 itertools:groupby(分组)/islice(切片)/chain(拼接)/pairwise(相邻对)——把循环写成声明式。
典型场景 递归/纯函数结果缓存;固定部分参数的回调;日志按时间窗口分组。
解决方案 三步递进:lru_cache → partial → itertools 实战。
第一步:lru_cache——纯函数的免费提速
# 文件: functools-cache.py
from functools import lru_cache
import time
@lru_cache(maxsize=1024) # LRU 缓存, 线程安全
def fib(n: int) -> int:
return n if n < 2 else fib(n-1) + fib(n-2)
start = time.time()
print(fib(300), f"{time.time()-start:.4f}s") # 瞬间(无缓存是天文数字)
# 陷阱: 参数必须可哈希; 有副作用的函数(写库)禁用; 缓存不失效(maxsize 淘汰)
# CPython 3.9+ 另有 @cache = lru_cache(maxsize=None)
第二步:partial——偏函数固定参数
# 文件: functools-partial.py
from functools import partial
def request(method: str, url: str, timeout: int = 30) -> str:
return f"{method} {url} (timeout={timeout})"
get = partial(request, "GET") # 固定 method
get_api = partial(get, "https://api.example.com") # 再固定 url
print(get_api()) # GET https://api.example.com (timeout=30)
print(get_api(timeout=5)) # 剩余参数仍可覆盖
# 典型用途: 给回调/线程池预绑定参数
第三步:itertools——声明式数据处理
# 文件: itertools-demo.py
from itertools import groupby, islice, chain, pairwise
logs = [ # 时间递增的日志
{"ts": 1, "level": "INFO"}, {"ts": 2, "level": "INFO"},
{"ts": 3, "level": "ERROR"}, {"ts": 4, "level": "ERROR"}, {"ts": 5, "level": "INFO"},
]
# groupby: 连续分组(先按 key 排序!)
for level, group in groupby(logs, key=lambda x: x["level"]):
print(level, len(list(group))) # INFO 2 / ERROR 2 / INFO 1
print(list(islice(range(100), 5, 8))) # [5, 6, 7] 惰性切片(迭代器无 [5:8])
print(list(chain([1, 2], [3, 4]))) # [1, 2, 3, 4] 拼接
print(list(pairwise("ABCD"))) # 相邻对: [('A','B'),('B','C'),('C','D')]
总结:lru_cache 只给纯函数(可哈希参数+无副作用);partial 固定参数生成定制回调;itertools 把循环变声明式(groupby 记得先排序)。
追问1:lru_cache 怎么主动失效? → fib.cache_clear() 全清;按 key 失效要自己维护或用 cachetools 的 TTLCache
追问2:groupby 不排序会怎样? → 只分组”连续相同段”——乱序数据产出大量小组,这是最常踩的坑
追问3:islice 和切片的区别? → 迭代器没有下标,[5:8] 报错;islice 惰性跳过前 5 个,大流安全
143. 单例模式的 Pythonic 实现?
概念 Python 的单例不写 getInstance,常用:模块(天然单例)、__new__ 控制、装饰器、metaclass;进程模型下还要考虑”每 worker 一个”的语义与跨进程单例(分布式锁/Redis)。
典型场景 配置对象、连接池管理器、全局缓存;面试官问”Python 怎么写单例”。
解决方案 三步递进:模块级(最 Pythonic)→ __new__/装饰器 → 多进程下的”伪单例”。
第一步:模块级——最 Pythonic 的答案
# 文件: config_singleton.py
# config.py 模块本身就是单例: import 机制缓存模块对象(sys.modules)
class Settings: ...
settings = Settings() # 模块顶层实例化
# 使用方:
from config import settings # 所有 import 拿到同一个对象
# 这就是为什么 全库的 Settings 单例(见 135)直接这么写
第二步:new 与装饰器实现
# 文件: singleton-impl.py
class Singleton:
_instance = None
def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
a, b = Singleton(), Singleton()
print(a is b) # True(注意: __init__ 仍会每次执行!)
# 装饰器版(免侵入):
def singleton(cls):
instances = {}
@wraps(cls, updated=[])
def get(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return get
@singleton
class Pool: ...
第三步:多进程下的”伪单例”
gunicorn/uvicorn 多 worker: 每个 worker 进程各一个"单例"
- 连接池: 每 worker 一份是合理的(见 131 的池容量按实例数核算)
- 真全局唯一(定时任务/分布式锁): 用 Redis(见 148)或外部协调
- asyncio 任务级唯一: 模块级对象 + 事件循环内共享即可
结论: 先问"单例的作用域是什么"(进程/机器/集群), 再选实现
总结:Python 单例首选模块级(import 缓存);__new__/装饰器适合类库;多进程下模块单例=每 worker 一个,集群唯一要靠 Redis 协调。
追问1:new 单例的 init 陷阱? → 每次实例化都执行 __init__(状态被重置)——需要在 __init__ 里判断已初始化
追问2:metaclass 单例什么时候用? → 框架层需要”所有子类各自单例”等批量语义时;业务代码用不上
追问3:线程安全的懒加载单例? → 模块级(加载时锁定)天然安全;懒加载需 threading.Lock 双重检查
144. 上下文管理器进阶(ExitStack/async with)?
概念 contextlib.ExitStack 动态管理多个上下文(数量运行时决定);async with 异步上下文(__aenter__/__aexit__)——异步资源的获取释放;contextlib.asynccontextmanager 用异步生成器三行写一个。
典型场景 动态打开数量不定的文件/连接;异步数据库会话管理;批量资源的统一清理。
解决方案 三步递进:ExitStack 劾态资源 → async with 协议 → asynccontextmanager 实战。
第一步:ExitStack——数量不定的资源
# 文件: exitstack-demo.py
from contextlib import ExitStack
def merge_files(paths: list[str], out_path: str):
with ExitStack() as stack: # 统一登记, 离开时逆序关闭
files = [stack.enter_context(open(p)) for p in paths] # 动态数量
with open(out_path, "w") as out:
for f in files:
out.write(f.read())
# 任一 open 失败: 已打开的自动关闭(不用手写嵌套 try/finally)
第二步:async with——异步上下文协议
# 文件: async-context.py
class AsyncDB:
async def __aenter__(self):
self.conn = await create_conn() # 异步建连
return self
async def __aexit__(self, exc_type, exc, tb):
await self.conn.close() # 异步关闭
return False
async def work():
async with AsyncDB() as db: # async with: await aenter/aexit
return await db.query("SELECT 1")
第三步:asynccontextmanager——异步版三行神器
# 文件: async-contextmanager-demo.py
from contextlib import asynccontextmanager
@asynccontextmanager
async def session_scope():
session = SessionLocal() # 前半= aenter
try:
yield session
await session.commit() # 正常路径提交
except Exception:
await session.rollback() # 异常回滚
finally:
await session.close()
async def handler():
async with session_scope() as s: # FastAPI 依赖的底层形态(见 117)
return await s.execute(...)
总结:ExitStack 管动态数量的资源;async with 是异步资源的 with(asynccontextmanager 三行封装);FastAPI 的 yield 依赖正是 asynccontextmanager 思想。
追问1:ExitStack 的关闭顺序? → 逆序(后进先出)——与嵌套 with 的语义一致
追问2:callback 能登记进 ExitStack 吗? → stack.callback(fn, *args),退出时执行(免写上下文类)
追问3:同步 with 套异步资源行不行? → 不行——连接的建立/关闭是 await 的,同步 __exit__ 里无法等待;必须 async with
四、MySQL(145–164)
本章 20 题:存储引擎内核(B+ 树/事务 ACID/锁与死锁/MVCC/Buffer Pool/undo/redo/Change Buffer)、执行计划与调优(EXPLAIN/慢查询治理/COUNT 与排序分组)、运维与架构(Online DDL/主从复制/分库分表/深分页/分区表/JSON 字段/自增主键)。
145. 索引的底层数据结构:B+ 树为什么赢?
概念 InnoDB 索引是 B+ 树:非叶子节点只存键(一页可存上千指针,树高 3 层撑千万行);叶子节点存数据并用双向链表串联(支持范围扫描)。对比 Hash(不支持范围/排序)、红黑树(树高过大,磁盘 IO 多)。
典型场景 查询慢要加索引;面试官问”为什么不用哈希表”;设计索引时估算树高。
解决方案 三步递进:主键索引与二级索引的区别 → 回表的代价 → 覆盖索引优化。
第一步:聚簇索引 vs 二级索引——回表的由来
主键索引(聚簇): 叶子节点存整行数据
SELECT * FROM users WHERE id = 1 → 一次 B+ 树查找直接拿到整行
二级索引(如 name): 叶子节点存 (name, 主键id)
SELECT * FROM users WHERE name = 'tom' → ①在 name 索引树找到 id
→ ②拿 id 回主键索引树查整行(回表)
结论: 回表 = 多一次树查找; 大量回表的查询要优化
第二步:覆盖索引——不回表的查询
-- 文件: covering-index.sql
-- 建联合索引: ALTER TABLE users ADD INDEX idx_name_age (name, age);
SELECT id, name, age FROM users WHERE name = 'tom';
-- 查询的列(id/name/age)全在索引里 → 不回表, Extra 显示 Using index
-- 大分页深分页优化也靠它:
SELECT * FROM users u
JOIN (SELECT id FROM users WHERE created_at > '2026-01-01' LIMIT 100000, 20) t ON u.id = t.id;
-- 子查询只走索引拿 id(无回表), 再按 id 取整行 —— 深分页从数秒到毫秒
第三步:最左前缀——联合索引的排列法则
-- 文件: leftmost-prefix.sql
-- 联合索引 (a, b, c) 相当于建立了 (a), (a,b), (a,b,c) 三个索引
-- 能走索引: WHERE a=1 / WHERE a=1 AND b=2 / WHERE a=1 AND b=2 AND c=3
-- 能部分走: WHERE a=1 AND c=3(只用到 a, c 断层)
-- 不能走: WHERE b=2 / WHERE c=3(缺最左列)
-- 范围列放最后: WHERE a=1 AND b>10 AND c=5 → b 是范围后 c 无法再用索引
-- 排列原则: 等值列在前, 范围列在后, 区分度高的优先
总结:B+ 树=矮胖(3 层千万行)+叶子链表(范围扫);二级索引查非索引列要回表;覆盖索引与联合索引最左前缀是日常调优的两把钥匙。
追问1:为什么推荐自增主键? → 插入按序追加不分裂页;UUID 随机插入导致页分裂与碎片 追问2:索引下推(ICP)是什么? → 5.6+:联合索引中无法走索引的列条件在存储引擎层先过滤,减少回表次数 追问3:什么时候索引会失效? → 对索引列做函数/运算、隐式类型转换(字符串列传数字)、前导模糊 LIKE ‘%x’、OR 连接非索引列
146. 事务的 ACID 与隔离级别?
概念 ACID:原子性(undo log 回滚)、一致性(三者共同保证)、隔离性(锁+MVCC)、持久性(redo log);隔离级别从 READ UNCOMMITTED 到 SERIALIZABLE,InnoDB 默认 REPEATABLE READ(用 MVCC+间隙锁实现,还防幻读)。
典型场景 脏读/不可重复读/幻读的辨析;“RR 级别怎么防幻读”的高频追问;选隔离级别。
解决方案 三步递进:三类读问题 → 四个隔离级别的对照 → RR 级别的幻读防线。
第一步:三类读问题——逐级递进的脏
脏读: 读到别的事务未提交的数据(回滚了就白读) → RU 有
不可重复读: 同一事务两次读同一行, 值被别的事务改了(针对 UPDATE) → RC 有
幻读: 同一事务两次同一范围查询, 行数变了(针对 INSERT) → RR 用 MVCC+间隙锁防
第二步:四个级别对照表
READ UNCOMMITTED 读未提交 → 脏读/不可重复读/幻读 都可能
READ COMMITTED 读已提交 → 不可重复读/幻读可能(每条语句生成新 ReadView)
REPEATABLE READ(默认)可重复读 → 快照读无幻读(事务首查生成 ReadView); 当前读用临键锁
SERIALIZABLE 串行化 → 全部避免(读加锁, 并发最差)
第三步:RR 级别的幻读防线——快照读与当前读
-- 文件: rr-phantom.sql
-- 快照读(普通 SELECT): MVCC, 读的是事务开始时的快照, 别人插入你看不见 → 无幻读
SELECT * FROM orders WHERE user_id = 1;
-- 当前读(SELECT FOR UPDATE / UPDATE / DELETE): 读最新版本, 用临键锁(Next-Key = 行锁+间隙锁)锁住范围
-- 别的事务想在范围内 INSERT 会被间隙锁阻塞 → 当前读也无幻读
-- 例外: 事务内先快照读后当前读, 会看到新插入的行(RR 幻读的边界情况)
总结:ACID 各自有实现载体(undo/redo/锁+MVCC);RC 与 RR 的本质区别是 ReadView 生成时机(每语句 vs 每事务);RR 防幻读=快照读 MVCC+当前读临键锁。
追问1:MVCC 的实现原理? → 隐藏列(trx_id/roll_pointer)+undo log 版本链+ReadView(活跃事务列表)判断版本可见性 追问2:RC 和 RR 怎么选? → 互联网多数用 RC(锁冲突少, 死锁少);需要事务内多次读一致(对账)用 RR 追问3:间隙锁什么时候会退化? → 唯一索引等值命中退化为行锁;未命中退化为间隙锁;非唯一索引才是完整临键锁
147. 锁机制:行锁、间隙锁与死锁排查?
概念 InnoDB 锁粒度:行锁(记录锁)、间隙锁(锁索引区间防插入)、临键锁(行+间隙,RR 默认);两阶段锁协议(事务中锁逐步加,提交才释放)→ 死锁可能。
典型场景 Deadlock found when trying to get lock;批量更新顺序不一致引发死锁;热点行更新阻塞。
解决方案 三步递进:死锁现场复现 → 排查手段 → 预防规则。
第一步:死锁复现——两个事务交叉持锁
-- 文件: deadlock-demo.sql
-- 事务 A: UPDATE accounts SET balance = balance - 1 WHERE id = 1; (持有 id=1 行锁)
-- 事务 B: UPDATE accounts SET balance = balance - 1 WHERE id = 2; (持有 id=2 行锁)
-- 事务 A: UPDATE ... WHERE id = 2; (等 B 释放 id=2)
-- 事务 B: UPDATE ... WHERE id = 1; (等 A 释放 id=1) → 死锁, InnoDB 检测并回滚代价小的事务
第二步:排查——现场与日志
-- 文件: deadlock-diagnose.sql
SHOW ENGINE INNODB STATUS; -- LATEST DETECTED DEADLOCK 段: 双方持有与等待的锁
SELECT * FROM performance_schema.data_locks; -- 8.0: 当前锁持有情况
SELECT * FROM performance_schema.data_lock_waits; -- 等待关系
-- information_schema.innodb_lock_waits (5.7)
第三步:预防——四条工程规则
-- 文件: deadlock-prevent.sql
-- 1. 批量操作按同一顺序加锁(如都按 id 升序) —— 消除交叉
-- 2. 事务尽量短(拆大事务), 减少持锁时间窗口
-- 3. 合理索引: 无索引的 UPDATE 会升级为表锁(全表扫描锁全部行)
-- 4. 高并发热点用队列串行化(消息队列削峰)或应用层合并写
总结:死锁=交叉持锁+互相等待;InnoDB 自动检测回滚小事务;排查看 SHOW ENGINE INNODB STATUS 与 data_locks;预防靠顺序一致+短事务+索引有效。
追问1:行锁锁的是行还是索引? → 锁的是索引记录——无索引可用时全表扫描会锁所有行(近似表锁) 追问2:共享锁和排他锁? → S 锁(SELECT … LOCK IN SHARE MODE)读读兼容;X 锁(FOR UPDATE/DML)写写互斥 追问3:innodb_lock_wait_timeout? → 锁等待超时(默认 50s)超时报错不回滚事务;死锁检测(innodb_deadlock_detect)是另一机制
148. MVCC 实现原理:ReadView 与版本链?
概念 MVCC(多版本并发控制)= 隐藏列(DB_TRX_ID 事务号/DB_ROLL_PTR 回滚指针)+ undo log 版本链 + ReadView(事务快照)。读时用 ReadView 判断版本链上哪个版本对当前事务可见。
典型场景 面试深挖 RC/RR 的实现差异;“为什么 RR 下普通 SELECT 不加锁也能一致”;长事务的影响。
解决方案 三步递进:版本链怎么串 → ReadView 四要素与可见性判断 → RC/RR 的差异点。
第一步:版本链——每次修改留一条 undo
行数据(最新) ──roll_ptr──> undo log v2 ──roll_ptr──> undo log v1 ──> NULL
每个版本的 DB_TRX_ID 记录"是哪个事务改的"
第二步:ReadView 四要素与可见性算法
ReadView: [m_ids 活跃事务列表, min_trx_id, max_trx_id, creator_trx_id]
可见性判断(对版本链从新到旧逐个检查):
trx_id < min_trx_id → 已提交, 可见
trx_id >= max_trx_id → ReadView 之后开启的, 不可见
min <= trx_id < max:
在 m_ids 中(还活跃) → 不可见
不在(已提交) → 可见
不可见就沿 roll_ptr 找上一版本, 直到找到可见版本
第三步:RC 与 RR 的唯一差异——ReadView 生成时机
RC: 每条 SELECT 生成新 ReadView → 能看到别的事务刚提交的 → 不可重复读
RR: 事务第一条 SELECT 生成一次, 全程复用 → 始终看事务开始时的世界 → 可重复读
这就是同一套 MVCC, 一个参数(生成时机)决定两个隔离级别的行为
总结:MVCC = 版本链 + ReadView 可见性规则;RC/RR 差异仅在 ReadView 生成时机;长事务会让 undo log 无法清理(版本链变长)——监控 information_schema.innodb_trx。
追问1:删除操作在 MVCC 里怎么表示? → 打删除标记位(delete flag),ReadView 判断可见则不显示;真正清理由 purge 线程做 追问2:为什么长事务有害? → 它的 ReadView 让旧版本无法 purge,undo 膨胀;且持锁时间长 追问3:SELECT 和 UPDATE 在 RR 下的可见性差异? → SELECT 快照读(事务开始的世界);UPDATE/DELETE 当前读(最新版本),所以可能更新到”看不见的新行”
149. EXPLAIN 执行计划:慢查询调优的入口?
概念 EXPLAIN 展示 SQL 执行计划:type(访问类型,system>const>eq_ref>ref>range>index>ALL)、key(实际用的索引)、rows(预估扫描行数)、Extra(附加信息:Using index/filesort/temporary)。
典型场景 慢查询日志里的 SQL 要优化;上线前评审 SQL;想知道索引有没有生效。
解决方案 三步递进:读 EXPLAIN 输出 → 常见坏计划与修复 → 慢查询日志定位。
第一步:读懂输出——重点四列
-- 文件: explain-demo.sql
EXPLAIN SELECT * FROM orders WHERE user_id = 1 AND status = 'paid' ORDER BY created_at DESC LIMIT 20;
-- type: ref(走了 user_id 索引) → 看是否可优化为 range/const
-- key: idx_user_status(实际用的索引)
-- rows: 320(预估扫描行数, 越小越好)
-- Extra: Using filesort ← 红灯: 排序没走索引, 内存/磁盘排序
第二步:常见坏计划与药方
type=ALL(全表扫描) → 加索引或改写查询
Using filesort → ORDER BY 列加入联合索引(与 WHERE 列组合, 注意最左前缀)
Using temporary → GROUP BY/DISTINCT 用临时表 → 让分组列进索引
rows 远大于结果集 → 索引区分度低(如 status 只有 3 个值), 换高区分度列建索引或联合
Using index → 好事: 覆盖索引不回表
第三步:慢查询日志——找到该优化的 SQL
-- 文件: slow-log.sql
SET GLOBAL slow_query_log = ON;
SET GLOBAL long_query_time = 1; -- 超 1 秒记录
SET GLOBAL log_queries_not_using_indexes = ON;
-- 分析工具: pt-query-digest / mysqldumpslow, 按总耗时排序找出 TOP SQL
总结:调优入口是 EXPLAIN 四列(type/key/rows/Extra);filesort 与 temporary 是红灯;慢查询日志+pt-query-digest 找目标,别凭感觉优化。
追问1:type 的级别排序? → system > const(主键/唯一等值) > eq_ref(连接主键) > ref(普通索引等值) > range(范围) > index(全索引扫) > ALL(全表) 追问2:ORDER BY 怎么走索引? → 排序列与 WHERE 列组成联合索引且方向一致;混用 ASC/DESC 8.0 支持降序索引 追问3:COUNT(*) 为什么慢? → 无任何条件也要遍历最小索引树;大表计数用汇总表/Redis 计数器/EXPLAIN 估算
150. 大表 DDL: Online DDL 与 gh-ost?
概念 大表(千万行+)加列/改索引直接 ALTER 有锁表与主从延迟风险。方案:MySQL 8 Online DDL(ALGORITHM=INPLACE, 部分操作不锁 DML)或 gh-ost/pt-online-schema-change(影子表+增量同步+原子改名)。
典型场景 亿级订单表加字段;线上高峰期必须变更;从库延迟导致应用读到旧数据。
解决方案 三步递进:Online DDL 的能力边界 → gh-ost 原理与使用 → 变更 Checklist。
第一步:Online DDL——哪些操作不锁
-- 文件: online-ddl.sql
-- 加列(8.0.12+ 可 INSTANT, 秒级仅改元数据):
ALTER TABLE orders ADD COLUMN remark VARCHAR(255) DEFAULT NULL, ALGORITHM=INSTANT;
-- 加索引(INPLACE, 允许并发 DML, 耗时看数据量):
ALTER TABLE orders ADD INDEX idx_created (created_at), ALGORITHM=INPLACE, LOCK=NONE;
-- 改列类型(多数 COPY, 锁写): 避免 —— 用新列+迁移数据+改名三步走
第二步:gh-ost 原理——影子表方案
1. 按目标 schema 建影子表(_orders_ghost)
2. 拉取原表 binlog, 把变更同步到影子表(期间原表可正常读写)
3. 数据追平后原子 RENAME 交换表名(瞬间完成)
优势: 可限流(控制同步速度保护主库)、可暂停、可回滚、不改变原表锁行为
gh-ost 执行: gh-ost --host=... --table=orders --alter="ADD COLUMN remark VARCHAR(255)" --max-load=Threads_running=50 --allow-on-master
第三步:变更 Checklist
□ 评估表行数(explain 估算)与高峰时段
□ ALGORITHM=INPLACE/INSTANT 先试, 明确不支持再 gh-ost
□ 主从延迟监控: 大变更后从库追平才放流量
□ 迁移脚本进版本库(Alembic/Flyway), 与应用代码兼容性确认(新旧版本共存的字段默认值)
□ 回滚预案: gh-ost 可中止(RENAME 未执行前原表未动)
总结:MySQL 8 INSTANT/INPLACE 覆盖大部分变更;超大规模或需限流用 gh-ost(影子表+binlog 同步+原子改名);大表 DDL 必须有 Checklist。
追问1:INSTANT 加列的原理? → 8.0.13+:列信息只记在元数据,行数据物理上仍按旧格式存,读取时按元数据补默认值——所以秒级 追问2:为什么改名要原子 RENAME? → 影子表同步期间原表仍在写入,RENAME 是唯一不丢数据的切换点(毫秒级锁) 追问3:主从延迟怎么应对? → 变更放低峰、gh-ost 限流、读库延迟监控超阈值告警;关键读走主库
151. 主从复制与读写分离?
概念 主库写 binlog → 从库 IO 线程拉取写 relay log → SQL 线程重放,实现异步复制。读写分离:写走主库,读走从库(负载分摊+读扩展);代价是主从延迟带来的不一致窗口。
典型场景 读 QPS 远超写(报表/列表);单库容量到顶;用户改完数据立刻读发现没变(延迟事故)。
解决方案 三步递进:复制原理与延迟监控 → 读写分离的三个一致性问题 → 半同步/组复制。
第一步:复制链路与延迟监控
-- 文件: replication-check.sql
SHOW SLAVE STATUS\G
-- 关键: Seconds_Behind_Master(延迟秒数) / Slave_IO_Running / Slave_SQL_Running
-- 监控: 延迟 > 阈值(如 5s) 告警; 应用侧从库健康检查
第二步:读写分离的一致性问题——三种场景三种对策
场景 1: 写后立刻读(下单后跳详情页)
对策: 关键读强制走主库(会话标记/注释路由 /* master */)
场景 2: 写后短暂内多次读(支付状态轮询)
对策: 按业务 key 的一致性路由(同一 user_id 短时间走主库)
场景 3: 报表/列表等容忍延迟的读
对策: 正常走从库, 分摊负载
实现: 中间件(ShardingSphere/ProxySQL)或 ORM 层路由(见 131 的读写分离 engine)
第三步:升级方案——半同步与组复制
异步复制: 主提交即返回 → 延迟窗口大, 可能丢数据(主挂)
半同步复制: 至少 1 个从库收到 binlog 才确认 → 丢数据风险大降, 写入延迟略增
MGR 组复制: 多主/单主模式, Paxos 冲突检测, 强一致 —— 金融场景
选型: 普通业务异步+关键读走主; 资金类半同步起步
总结:复制链路 binlog→relay log→重放;读写分离的核心难题是写后读一致性(强制主库路由/业务 key 路由);资金类升级半同步。
追问1:主从延迟的原因? → 单线程重放(5.7 前 main SQL 线程,8.0 按 库/写集合 并行重放改善)、大事务、从库机器差
追问2:binlog 三种格式? → STATEMENT(语句,可能不一致)、ROW(行变更,推荐,binlog 大)、MIXED;ROW 支持闪回与精确重放
追问3:怎么定位延迟大事务? → binlog 里查事务大小;监控 SHOW SLAVE STATUS 的 Retrieved_Gtid_Set 与 Executed_Gtid_Set 差值
152. 分库分表:什么时候分与怎么分?
概念 单表数据量/写入量超过单机能力(经验:行数千万级、B+ 树层高增加、DDL 变慢)才考虑分库分表。水平拆分按 shard key(如 user_id hash)路由;跨分片查询靠冗余表/二级索引服务(如 ES)。
典型场景 单表 5000 万+ 查询开始慢且索引优化无效;写入 TPS 到单库上限;想引入但被”先分页后过滤”的查询卡住。
解决方案 三步递进:先穷尽单库优化 → 分片键选择 → 跨分片查询的代价与对策。
第一步:分库分表前的清单——大部分场景不需要分
□ 索引是否已优化到位(EXPLAIN 逐条过)
□ 冷热分离: 3 年前的订单归档到历史库, 热表只剩 10%
□ 读写分离: 读压力先分摊
□ 缓存: 热点数据 Redis 挡掉读流量
□ 大字段拆出: 详情 TEXT 拆到扩展表, 主表只留查询字段
以上做完仍单表瓶颈(写入 TPS 上限/DDL 不可承受) → 才进入分库分表
第二步:分片键选择——决定一切查询形态
按 user_id hash: 用户维度查询完美路由(我的订单); 缺点: 商家/运营按时间查询要扫全分片
按时间 range: 时间范围查询友好; 缺点: 热点集中在最新分片
按 snowflake id hash: 均匀但无业务维度
实践: 主表按最高频查询维度(user_id); 运营侧查询需求交给 ES/数仓(异构索引)
第三步:跨分片查询——两种正规解法
1. 异构索引: binlog → Canal/MQ → 同步到 ES(运营查询/多维检索)或 Hive(分析)
2. 冗余表: 按商家维度再存一份"商家订单表"(与用户维度并存, 以空间换路由)
写入双写(本地消息表保证最终一致), 查询单表无跨片
反面教材: 跨分片 JOIN/分页聚合 → 中间件归并, 性能极差且功能受限 —— 设计期避免
总结:分库分表是最后手段(先归档/缓存/读写分离);分片键按最高频查询选;跨分片查询用异构索引(ES)或冗余表,不要依赖中间件归并。
追问1:分多少合适? → 预留 3-5 年容量再翻倍空间;一次性分足,二次扩容(翻倍扩容法/一致性 hash)成本高 追问2:全局唯一 ID 怎么生成? → 雪花算法(时间戳+机器+序列)或号段模式(Leaf),不用自增(分片冲突) 追问3:不停机迁移怎么做? → 双写(新旧库)+存量迁移+校验对账+灰度切读+切写,回滚预案全程可用
153. 大表深分页优化?
概念 LIMIT 1000000, 20 要扫描并丢弃前 100 万行(回表百万次);本质是 OFFSET 的代价。解法:游标分页(记住上一页末尾 id)、覆盖索引延迟关联、或产品侧限制跳页。
典型场景 运营后台翻到 5000 页卡死;导出任务慢查询;ES 同步的全量拉取。
解决方案 三步递进:游标分页(最优) → 延迟关联(兼容跳页) → 产品侧约束。
第一步:游标分页——WHERE id > last_id
-- 文件: cursor-pagination.sql
-- 上一页返回末尾的 id 作为游标, 下页从游标之后取:
SELECT * FROM orders WHERE user_id = 1 AND id < 990000 ORDER BY id DESC LIMIT 20;
-- 每页固定扫描 20 行 + 索引定位, 与页深无关
-- 前端: 不提供"跳到第 N 页", 用"下一页"传游标(朋友圈/Feed 流同款)
第二步:延迟关联——必须跳页时的优化
-- 文件: late-row-lookup.sql
SELECT o.* FROM orders o
JOIN (SELECT id FROM orders WHERE user_id = 1 ORDER BY id DESC LIMIT 100000, 20) t
ON o.id = t.id;
-- 子查询走覆盖索引只取 id(百万级扫描但无回表), 回表只做 20 次
-- 仍随页深线性变慢, 但比裸 LIMIT 快一个数量级
第三步:产品侧约束——跳页本身就是伪需求
- 搜索引擎(Google/淘宝)都不提供深跳页 → 用户习惯已养成
- 后台报表需求 → 导出异步任务(游标拉全量)而非页面翻
- 必须随机访问(如抽奖) → 预计算结果集存 Redis, 分页在内存做
总结:深分页首选游标分页(与页深无关);必须跳页用延迟关联(覆盖索引子查询);根本上用产品约束消灭深跳页。
追问1:游标分页怎么排序第二字段? → WHERE (sort_col, id) < (last_sort, last_id) 行值比较,或 sort_col 范围+id 兜底 追问2:COUNT(*) 总数怎么算? → 大表不精确 count:Redis 缓存计数/EXPLAIN 估算/展示”约 N 条” 追问3:ES 的 deep pagination? → from+size 有 10000 限制;用 search_after(游标)或 scroll(全量导出)
154. 连接池与 MySQL 参数调优?
概念 应用侧连接池(pool_size)与 MySQL 侧 max_connections 的配比;InnoDB 核心参数:innodb_buffer_pool_size(数据缓存,最核心)、innodb_flush_log_at_trx_commit(redo 刷盘策略)、sync_binlog(binlog 刷盘)。
典型场景 压测 TPS 上不去;新集群初始化参数;主从切换后性能差异。
解决方案 三步递进:连接数配比 → 内存三巨头 → 刷盘策略与安全的取舍。
第一步:连接数配比
公式: sum(各实例 pool_size + max_overflow) <= max_connections x 0.8
MySQL max_connections 默认 151 → 生产改 1000+ (每连接内存约 256KB-10MB, 注意机器内存)
应用侧: IO 密集服务 pool_size ≈ 常驻并发 x 1.5; 过大反而增加上下文切换
监控: Threads_connected / Max_used_connections / Threads_running(并发执行中)
第二步:内存三巨头
# 文件: my.cnf
innodb_buffer_pool_size = 物理内存的 60-70% # 数据页缓存, 命中率 99%+ 是目标
innodb_log_file_size = 1-4G # redo 大小: 大了崩溃恢复慢但写入平滑
innodb_flush_log_at_trx_commit = 1 # 1: 每次提交刷盘(最安全) / 2: 每秒刷(宕机丢 1s) / 0
sync_binlog = 1 # 1: 每次提交刷 binlog / 100 或 0(性能优先场景)
# 双 1(redo=1 + binlog=1)是资金类默认; 普通业务可 redo=2 换性能
第三步:验证与监控
-- 文件: mysql-monitor.sql
SHOW GLOBAL STATUS LIKE 'Innodb_buffer_pool_read%';
-- 命中率 = 1 - Innodb_buffer_pool_reads(物理读) / Innodb_buffer_pool_read_requests(逻辑读)
SHOW VARIABLES LIKE 'max_connections';
SELECT * FROM sys.metrics WHERE variable_name LIKE 'innodb_buffer%';
总结:连接数按配额倒推(别超 DB 上限 80%);buffer_pool 占内存 60-70% 是第一优化;刷盘”双 1”保安全、放弃部分持久性换性能要业务拍板。
追问1:Buffer pool 命中率低怎么办? → 加内存/减全表扫描(冷数据归档);命中率 99% 以下说明热点数据超过缓存容量 追问2:慢的一定是参数吗? → 80% 的慢 SQL 是索引问题,参数调优是最后一步 追问3:pt-query-digest 和慢日志的关系? → 慢日志是数据源,pt-query-digest 聚合分析出 TOP SQL 与指纹
155. InnoDB 的 Change Buffer 与唯一索引选型?
概念 Change Buffer 是二级索引页不在 Buffer Pool 时的写缓冲:INSERT/UPDATE 先记变更,读页时合并,减少随机读 IO。唯一索引不适用(必须读页判重)。因此”尽量普通索引”的性能依据就在这里。
典型场景 写多读少的表(日志/埋点)索引选型;面试官问”唯一索引和普通索引怎么选”。
解决方案 三步递进:Change Buffer 工作过程 → 唯一 vs 普通索引的写路径对比 → 选型结论。
第一步:Change Buffer 工作过程
普通索引写入, 目标页不在 Buffer Pool:
1. 把变更缓存在 Change Buffer(内存, 会落盘 ibdata)
2. 语句即返回(不需要先读磁盘上的索引页)
3. 后续该页被读取时 → 读入内存 + 合并 Change Buffer 中的变更
收益: 省掉一次磁盘随机读; 写多读少场景放大
第二步:唯一索引为什么用不了
唯一索引写入必须判重 → 必须把索引页读进内存 → Change Buffer 无意义
写路径对比(页不在内存时):
普通索引: 写 Change Buffer 即返回(1 次内存操作)
唯一索引: 读页(磁盘 IO)+ 判重 + 写(慢一个量级)
第三步:选型结论
业务侧保证唯一(代码查重/唯一逻辑在应用层) → 用普通索引(吃 Change Buffer 红利)
必须数据库保证唯一(资金/账户) → 唯一索引(正确性优先, 性能让位)
读写均衡或读多写少 → 两者差距缩小, 按约束需求选
总结:Change Buffer 是写多读少场景的二级索引优化;唯一索引判重必须读页用不上它——“唯一性交给谁保证”是索引选型的分水岭。
追问1:Change Buffer 什么时候合并? → 该页被读取、后台定期、数据库关闭前三种时机 追问2:innodb_change_buffering 参数? → 控制缓冲的操作类型(all/inserts/deletes/none),默认 all 追问3:Change Buffer 会丢数据吗? → 不会,变更会落盘(ibdata),崩溃恢复时重放
156. 自增主键的空洞与 ID 生成策略?
概念 自增 ID 在 8.0 前的回滚/重启会造成空洞(已分配不回收);分布式场景自增不适用,常用雪花算法(时间戳+机器+序列,趋势递增)或号段模式(批量取号)。
典型场景 面试官问”为什么自增 ID 不连续”;分库分表后主键生成;INSERT 后拿 ID 的姿势。
解决方案 三步递进:空洞的成因 → 雪花算法结构 → 应用侧取 ID。
第一步:空洞的成因
1. 事务回滚: 分配的 auto_increment 不回收(65536 之前的值直接跳过)
2. INSERT ... ON DUPLICATE KEY UPDATE: 可能一次消耗多个值
3. 8.0 前重启: 计数器取 max(id) 重建, 中间未提交的空洞消失(8.0 起持久化, 行为一致)
结论: 自增 ID 保证"唯一+趋势递增", 不保证连续 —— 业务上别依赖连续性
第二步:雪花算法结构(64 位)
# 文件: snowflake-demo.py
# 1 位符号 + 41 位毫秒时间戳(约 69 年) + 10 位机器(1024 节点) + 12 位序列(每毫秒 4096 个)
# 特点: 趋势递增(对 B+ 树友好)、分布式不冲突、不依赖数据库
# 注意: 机器时钟回拨会产生重复 ID → 实现需处理(等待/告警/备用位)
第三步:应用侧取 ID
-- 文件: get-id.sql
-- 单库: INSERT 后取自增值(同一连接)
INSERT INTO orders (...) VALUES (...);
SELECT LAST_INSERT_ID(); -- 每连接独立, 并发安全
-- ORM: SQLAlchemy 的 flush 后对象自动回填主键(见 121 的 refresh)
-- 分库分表: 雪花 ID 应用层生成, 直接作为主键 INSERT
总结:自增 ID 只保证唯一与趋势递增;分库分表用雪花(注意时钟回拨);取自增 ID 用 LAST_INSERT_ID()(连接级隔离)。
追问1:为什么主键要趋势递增? → InnoDB 数据按主键聚簇,随机主键(UUID)导致页分裂与碎片,写入性能下降明显 追问2:号段模式是什么? → 数据库批量发号(一次取 1000 个缓存应用侧),减少 DB 压力——Leaf 的方案 追问3:雪花 ID 排序等于时间排序吗? → 趋势上是(高位时间戳),同毫秒内按序列——业务排序别精确依赖
157. COUNT(*)、ORDER BY 与 GROUP BY 的优化?
概念 COUNT(*) 有索引就遍历最小索引树(MyISAM 存了总数例外);ORDER BY 走索引需排序列与 WHERE 列组成联合索引且方向一致;GROUP BY 先排序再分组(与 ORDER BY 同规则),无法走索引时用临时表+filesort。
典型场景 大表计数慢;分页列表的排序优化;报表 GROUP BY 出现 Using temporary。
解决方案 三步递进:COUNT 的真相 → ORDER BY 索引规则 → GROUP BY 优化。
第一步:COUNT 的真相
-- 文件: count-optimize.sql
-- InnoDB 的 COUNT(*) 要遍历(事务隔离下不同会话看到的行数不同, 无法缓存总数)
-- 优化器会选最小的索引树遍历
SELECT COUNT(*) FROM orders; -- 千万级全扫, 秒级
-- 大表精确计数的替代:
SELECT * FROM information_schema.tables WHERE table_name='orders'; -- 统计信息估算(不精确)
-- 业务方案: Redis 计数器(增减维护)/汇总表(定时统计)/显示"约 N 条"
第二步:ORDER BY 走索引的规则
-- 文件: orderby-index.sql
-- 联合索引 (a, b, c):
SELECT * FROM t WHERE a=1 ORDER BY b, c; -- 走索引(a 等值后 b,c 连续排序)
SELECT * FROM t WHERE a>1 ORDER BY b; -- 不走(a 是范围, b 断层) → filesort
SELECT * FROM t ORDER BY a ASC, b DESC; -- 8.0 前不走(方向混合); 8.0 降序索引支持
-- 目标: Extra 不出现 "Using filesort"
第三步:GROUP BY 优化
-- 文件: groupby-optimize.sql
-- GROUP BY 隐含排序(8.0 前): 无索引时 Using temporary; Using filesort 双红灯
SELECT dept, COUNT(*) FROM emp GROUP BY dept; -- 临时表
ALTER TABLE emp ADD INDEX idx_dept (dept);
SELECT dept, COUNT(*) FROM emp GROUP BY dept; -- 走索引, 临时表消失
-- 松散索引扫描(Loose Index Scan): GROUP BY 列有索引时跳组扫描, COUNT(DISTINCT) 提速明显
-- 8.0: GROUP BY 不再隐含排序, 需要 ORDER BY 显式写
总结:COUNT(*) 靠最小索引树+业务侧替代(Redis/汇总表);ORDER BY 走索引要”WHERE 等值列+排序列”连续且方向一致;GROUP BY 让分组列进索引消临时表。
追问1:COUNT(1)、COUNT(*)、COUNT(列) 区别? → COUNT(*) 与 COUNT(1) 等价(统计行数);COUNT(列) 跳过 NULL——语义不同按需选 追问2:filesort 一定是坏事吗? → 内存排序小结果集可接受;数据量大(超 sort_buffer)才落盘变慢——看 rows 与 buffer 追问3:深分页 + 排序组合怎么优化? → 游标用排序列组合值(WHERE (sort_col,id) < 上页末尾),见 163
158. 慢查询系统化治理流程?
概念 慢查询治理不是”看到慢就加索引”,而是流水线:慢日志采集 → pt-query-digest 聚合排序 → TOP SQL 分析(EXPLAIN)→ 索引/改写/架构分层治理 → 验证与防复发(上线评审门禁)。
典型场景 数据库整体变慢要系统性排查;治理了一轮又反复(缺防复发机制);团队要建立 SQL 质量规范。
解决方案 三步递进:采集聚合 → TOP SQL 分析方法 → 分层治理与门禁。
第一步:采集与聚合
# 文件: slow-query-pipeline.sh
# 开启慢日志(动态):
mysql -e "SET GLOBAL slow_query_log=ON; SET GLOBAL long_query_time=1;"
# 聚合分析(指纹化: 相似 SQL 归并统计):
pt-query-digest /var/lib/mysql/slow.log --order-by t --limit 10 > top10.txt
# 输出按总耗时排序的 TOP 10 SQL 指纹 + 每条的样例/执行计划提示
第二步:TOP SQL 分析方法
对每条 TOP SQL 按 checklist 过:
1. EXPLAIN: type=ALL? Extra 有 filesort/temporary?
2. 索引: WHERE/ORDER BY/GROUP BY 列有没有联合索引覆盖(最左前缀)?
3. 改写: SELECT * → 需要的列(覆盖索引机会); 隐式类型转换(字符串列传数字);
子查询改 JOIN; OR 改 UNION ALL
4. 数据量: 返回行数 vs 扫描行数(rows 远大于结果 → 过滤性差)
5. 架构: 该不该走缓存/该不该实时查(改汇总表)
第三步:分层治理与门禁
治理优先级(成本从低到高):
L1 加索引(零代码改动) → L2 改写 SQL(小改动) → L3 缓存/汇总(架构介入) → L4 分库分表(最后手段)
防复发:
- CI 集成 SQL 审查(止损: 全表扫描/无 WHERE 的 UPDATE 告警)
- 慢日志常态化监控(新增慢 SQL 告警, 不只看存量)
- 每月 slow report 例会(TOP 5 跟进状态)
总结:慢查询治理=采集(pt-digest 指纹聚合)→分析(EXPLAIN checklist)→分层治理(索引→改写→架构)→门禁防复发;不是一次性运动而是流水线。
追问1:long_query_time 设多少? → 按业务 P95 目标定(接口目标 500ms 则设 1s 抓重点);太低产生噪音 追问2:pt-query-digest 的指纹是什么? → 把常量替换为占位符归并同类 SQL(VALUES(1) 与 VALUES(2) 是同一指纹),统计才有意义 追问3:线上加索引的风险? → 大表 8.0 INSTANT/INPLACE 可在线加(见 160);仍要低峰执行+看主从延迟
159. JSON 字段与生成列的实战?
概念 MySQL 5.7+ 的 JSON 类型(二进制存储,支持路径查询/修改函数);生成列(Generated Column)可从 JSON 表达式建虚拟列并加索引——JSON 灵活性与索引性能的结合点。
典型场景 表结构中动态属性(商品 SKU 的规格)、日志的扩展字段、半结构化数据入库。
解决方案 三步递进:JSON 基础操作 → JSON 查询慢的问题 → 生成列+索引解决。
第一步:JSON 基础操作
-- 文件: json-basic.sql
CREATE TABLE products (
id INT PRIMARY KEY,
name VARCHAR(100),
specs JSON -- 动态规格: {"color":"红","size":"XL"}
);
INSERT INTO products VALUES (1, 'T恤', '{"color": "红", "size": "XL"}');
SELECT specs->>'$.color' AS color FROM products WHERE id = 1; -- 提取(->> 去引号)
UPDATE products SET specs = JSON_SET(specs, '$.stock', 100); -- 修改
第二步:JSON 查询慢的问题
-- 文件: json-slow.sql
SELECT * FROM products WHERE specs->>'$.color' = '红';
-- JSON 函数无法走普通索引 → 全表扫描逐行解析
-- 函数套在列上 = 索引失效(同 WHERE DATE(created_at)=... 的坑)
第三步:生成列+索引
-- 文件: json-generated.sql
ALTER TABLE products
ADD COLUMN color VARCHAR(20)
GENERATED ALWAYS AS (specs->>'$.color') STORED, -- 从 JSON 提取的物理列
ADD INDEX idx_color (color);
SELECT * FROM products WHERE color = '红'; -- 走索引
-- VIRTUAL(不占空间, 索引时计算) vs STORED(占空间, 读快)——查询频繁用 STORED
总结:JSON 类型适合动态属性;直接对 JSON 路径做条件查询走不了索引;生成列把 JSON 表达式物化成可索引的列——灵活与性能兼得。
追问1:JSON 字段做 WHERE 条件还有别的方法吗? → 8.0.17+ 支持函数索引(直接对表达式建索引,免生成列),效果等价 追问2:JSON 字段的弊端? → 无法外键约束、统计信息差(优化器难估)、过度使用变成”文档数据库滥用”——高频查询字段仍应常规列化 追问3:什么时候该拆表而不是 JSON? → 结构稳定(不经常加属性)+需要约束/JOIN → 拆列或拆表;探索期/长尾属性用 JSON
160. InnoDB 的内存结构:Buffer Pool 与脏页刷新?
概念 Buffer Pool 是 InnoDB 的内存缓存池(数据页/索引页/Change Buffer/自适应哈希),读走缓存、写先改内存页(脏页)再异步刷盘。脏页刷新由后台线程(page cleaner)按策略执行,redo log 写满或脏页比例过高会强制刷脏(此时写入抖动)。
典型场景 写入流量高峰期间歇性卡顿(刷脏风暴)、Innodb_buffer_pool_wait_free 指标增长、Redo log 写满报错。
解决方案 三步递进:Buffer Pool 的读路径 → 脏页与刷盘时机 → 参数调优。
第一步:读路径——为什么缓存命中是生命线
查询 → 先查 Buffer Pool(内存, 纳秒级):
命中 → 直接返回(逻辑读)
未命中 → 从磁盘读页入缓存(物理读, 毫秒级, 慢 1 万倍)
监控: Innodb_buffer_pool_read_requests(逻辑读) vs Innodb_buffer_pool_reads(物理读)
命中率 = 1 - 物理读/逻辑读, 目标 >99%(见 164 的监控 SQL)
第二步:脏页与刷盘——写入的真实路径
写入流程: 改 Buffer Pool 中的页(变脏页) → 写 redo log(顺序写, 快) → 返回成功
脏页什么时候刷回磁盘(随机写, 慢):
1. Redo log 写满 → 强制推进 checkpoint(此时所有写入阻塞, 表现为间歇卡顿)
2. 脏页占比 > innodb_max_dirty_pages_pct(默认 75%) → 后台加速刷
3. LRU 淘汰到脏页 → 先刷再淘汰
4. 正常空闲刷(page cleaner 持续小批量)
第三步:参数调优——给刷脏留余地
# 文件: my.cnf
innodb_buffer_pool_size = 物理内存的 60-70% # 第一优先级(见 164)
innodb_log_file_size = 4G # redo 加大 → 写满周期变长, 刷脏更从容
innodb_max_dirty_pages_pct = 60 # 脏页上限压低, 留缓冲
innodb_io_capacity = 2000 # 告知磁盘真实 IOPS(SSD 调高), 刷脏速度依据
innodb_io_capacity_max = 4000 # 突发上限
# 症状对照: 写高峰卡顿+redo 等待 → 加大 log_file_size; 命中率低 → 加内存
总结:Buffer Pool 命中率决定读性能,脏页刷新节奏决定写稳定性;redo log 大小与 io_capacity 是刷脏风暴的两大调节阀。
追问1:Change Buffer 是什么? → 二级索引页不在缓存时的写缓冲(先记变更,读页时合并),写多读少场景提升明显;唯一索引不适用(需读页判重) 追问2:自适应哈希索引(AHI)? → InnoDB 自动为热点页建哈希索引(等值查询加速),竞争激烈时可关闭(innodb_adaptive_hash_index=off) 追问3:预读(read ahead)? → 线性预读(连续 56 页触发)与随机预读;乱序扫描大表的预读会污染缓存,可按需关闭
161. 二级索引与索引下推(ICP)?
概念 二级索引查询的完整路径:索引树找主键 → 回表取整行;索引下推(Index Condition Pushdown, 5.6+)把 WHERE 中该索引能覆盖的条件下推到存储引擎层,在回表前先过滤,减少回表次数。
典型场景 联合索引 (name, age) 查 name LIKE '张%' AND age > 18:无 ICP 时所有”张”姓行全部回表再过滤;ICP 在索引层就用 age 过滤。
解决方案 三步递进:回表的代价 → ICP 的优化过程 → EXPLAIN 验证。
第一步:回表的代价
索引 (name, age), 查询: SELECT * FROM users WHERE name LIKE '张%' AND age > 18
无 ICP 流程:
1. 索引树定位所有 name LIKE '张%' 的条目(如 1 万条, 索引里有 name 和 age)
2. 逐条回表(1 万次主键树查找!)取整行
3. Server 层再用 age > 18 过滤 → 剩 100 行
浪费: 9900 次回表是无用的 —— age 明明就在索引里, 却没用上
第二步:ICP 的优化过程
有 ICP 流程(5.6+ 默认开启):
1. 索引树定位 name LIKE '张%' 的条目
2. 存储引擎层直接用索引中的 age > 18 过滤 → 剩 100 条
3. 只对这 100 条回表
回表次数: 10000 → 100, 差 100 倍
本质: 把 Server 层的过滤条件下推到存储引擎层, 用索引列提前过滤
第三步:EXPLAIN 验证
-- 文件: icp-demo.sql
EXPLAIN SELECT * FROM users WHERE name LIKE '张%' AND age > 18;
-- Extra 列出现 "Using index condition" = ICP 生效
-- 出现 "Using where" = Server 层过滤(索引无法下推, 如条件列不在该索引)
-- 关闭对比: SET optimizer_switch='index_condition_pushdown=off';
总结:二级索引查询=索引定位+回表;ICP 把索引可判断的条件下推到引擎层,回表前过滤,是”能用索引就别回表”思想的自动版。
追问1:覆盖索引和 ICP 的关系? → 覆盖索引彻底消灭回表(更优);ICP 是回表不可避免时的减损——优先设计覆盖索引 追问2:哪些条件能下推? → 条件列在该索引中且索引可判断(范围/前缀匹配);JOIN 条件、子查询不能下推 追问3:MRR 是什么? → Multi-Range Read:把回表的主键排序后批量读(随机 IO 转顺序),与 ICP 同属回表优化家族
162. MySQL 的 undo log 与长事务治理?
概念 undo log 记录反向操作(用于回滚与 MVCC 版本链),事务提交后不立即删除(可能被其他事务的 ReadView 引用),由 purge 线程清理。长事务持有旧 ReadView,导致 undo 无法清理持续膨胀,同时持锁时间长,是生产事故高发源。
典型场景 信息 schema 里 history list length 持续增长;忘记提交的会话(连接断开但事务未结束);大批量 DML 单事务。
解决方案 三步递进:undo 的两个用途 → 长事务的危害链 → 监控与治理。
第一步:undo 的两个用途
1. 回滚: 事务失败时按 undo 反向执行(INSERT 的 undo 是 DELETE)
2. MVCC: 旧版本数据在 undo 版本链上(见 158), 支持 RC/RR 的快照读
清理时机: 该 undo 版本不被任何活跃事务的 ReadView 需要 → purge 线程删除
第二步:长事务的危害链
长事务(如跑了几小时未提交)
→ 它的 ReadView 钉住旧版本
→ 之后所有更新的 undo 都不能清理
→ undo 表空间膨胀( ibdata 或独立 undo 表空间)
→ 版本链变长 → 所有快照读遍历更长链 → 全局查询变慢
同时: 持有的锁一直不释放 → 阻塞其他事务 → 连锁等待
第三步:监控与治理
-- 文件: long-txn-monitor.sql
-- 活跃超过 60s 的事务
SELECT * FROM information_schema.innodb_trx
WHERE TIME_TO_SEC(TIMEDIFF(NOW(), trx_started)) > 60;
-- undo 积压(History list length, 越高越危险)
SHOW ENGINE INNODB STATUS\G -- TRANSACTIONS 段
-- 治理手段:
-- 1. 应用侧: 事务内禁外部 IO(见 145 追问), 大批量拆小事务(每 1000 条提交)
-- 2. 会话侧: autocommit=1 确认; 空闲连接的意外事务(kill)
-- 3. 参数: innodb_undo_tablespaces 独立 undo 表空间(可 truncate 回收)
总结:undo 服务于回滚与 MVCC,清理被 ReadView 钳制;长事务=undo 膨胀+锁持有,监控 innodb_trx 与 history list,应用侧拆小事务是根治。
追问1:怎么发现”忘记提交”的会话? → information_schema.innodb_trx 的 trx_started 与 processlist 对照,长时间活跃且无 SQL 执行的即嫌疑
追问2:undo 表空间膨胀了怎么回收? → 8.0:innodb_undo_log_truncate 自动收缩;紧急情况需停库(5.7)重建
追问3:只读查询需要开事务吗? → 一致性多次读才需要(RR 快照);普通单条查询 autocommit 即可,别滥用 BEGIN
163. MySQL 分区表的使用与陷阱?
概念 分区表把一张逻辑表按规则(RANGE/LIST/HASH/KEY)物理分片存储,查询带分区键时只扫相关分区(分区裁剪)。适合海量历史数据归档场景;但限制多:分区键必须含在主键/唯一键里、跨分区查询与 DDL 有额外成本,多数”分库分表前的尝试”。
典型场景 日志/订单按月分区(冷数据 DROP PARTITION 秒级清理);单表 5 亿行不想立刻分库分表。
解决方案 三步递进:RANGE 分区实战 → 分区裁剪与限制 → 归档场景的收益。
第一步:RANGE 分区——按时间的标准玩法
-- 文件: partition-range.sql
CREATE TABLE access_log (
id BIGINT AUTO_INCREMENT,
created_at DATETIME NOT NULL,
PRIMARY KEY (id, created_at), -- 分区键必须进主键!
KEY idx_created (created_at)
) PARTITION BY RANGE (TO_DAYS(created_at)) (
PARTITION p202610 VALUES LESS THAN (TO_DAYS('2026-11-01')),
PARTITION p202611 VALUES LESS THAN (TO_DAYS('2026-12-01')),
PARTITION pmax VALUES LESS THAN MAXVALUE
);
-- 新增月份: ALTER TABLE access_log ADD PARTITION (...) -- 原地, 秒级
-- 注意 pmax 会挡住 ADD, 实际用 REORGANIZE PARTITION pmax INTO (新月份, pmax)
第二步:分区裁剪与失效场景
-- 文件: partition-prune.sql
-- 裁剪生效: 只扫一个分区
EXPLAIN SELECT COUNT(*) FROM access_log WHERE created_at >= '2026-10-01' AND created_at < '2026-11-01';
-- partitions 列显示 p202610
-- 裁剪失效(全分区扫描!):
SELECT * FROM access_log WHERE id = 123; -- 不带分区键 → 扫全部分区
SELECT * FROM access_log WHERE DATE(created_at) = '2026-10-15'; -- 分区键套函数 → 无法裁剪
-- 结论: 查询必须带裸的分区键条件, 且主键查询反而变慢(可能扫多分区)
第三步:归档场景的收益与边界
-- 文件: partition-archive.sql
-- 传统 DELETE 大量历史: 巨型事务+锁+binlog 风暴
-- 分区版: 整分区秒删
ALTER TABLE access_log DROP PARTITION p202501; -- 秒级, 不产生行级 binlog
-- 边界(为什么不无脑用分区):
-- 1. 分区键必须在唯一键中 → 唯一约束被分区键稀释(全局唯一变分区内唯一)
-- 2. 查询不带分区键时性能更差(多分区并发扫)
-- 3. 单机瓶颈(磁盘/CPU/连接)分区解决不了 → 那是分库分表的事
总结:分区表=单表内的物理分片,分区裁剪是性能来源,DROP PARTITION 是归档利器;分区键必须进主键、查询必须带分区键,超出单机容量仍是分库分表。
追问1:HASH 分区适用什么? → 无明显时间维度但想分散热点(按用户 ID HASH 均摊);裁剪只对等值条件有效 追问2:分区数有上限吗? → 8.0 单表最多 8192 个分区;但几百个以上运维与优化器开销明显,控制在几十 追问3:分区表和分库分表怎么选? → 同实例内按时间归档/单表过大先用分区;跨实例容量/写入扩展才分库分表(见 162)
164. MySQL 的 redo log 与崩溃恢复?
概念 redo log(WAL,Write-Ahead Logging)记录物理页修改,先写日志后刷数据页,保证宕机后已提交事务不丢(durability)。三个关键值:write pos(写入位置)、check point(刷盘位置)、两者之间为可覆盖区。innodb_flush_log_at_trx_commit 控制 redo 的刷盘策略。
典型场景 面试必问”为什么改内存+写日志就敢返回成功”;参数双 1 的取舍;异常宕机后的恢复时间。
解决方案 三步递进:WAL 的原理 → 双 1 参数 → 崩溃恢复过程。
第一步:WAL——顺序写代替随机写
不用 WAL 的写: 每次修改直接刷对应数据页(随机位置磁盘写, 极慢)
WAL 的写:
1. 修改 Buffer Pool 中的页(内存)
2. 追加写 redo log(顺序写, 快百倍)
3. 返回客户端"成功"
4. 数据页由后台异步刷盘(此时 redo 里已有完整修改记录)
崩溃时: 重放 redo 中已提交部分 → 数据恢复 → 已提交的绝不丢
第二步:双 1 参数——安全与性能的开关
# 文件: my.cnf
innodb_flush_log_at_trx_commit = 1 # 每次提交 fsync redo(最安全, 宕机不丢)
# = 2: 提交写 OS cache, 每秒 fsync(宕机丢 1s)
# = 0: 每秒才写+刷(丢 1s, 最快)
sync_binlog = 1 # binlog 每次提交 fsync(与 redo 组成"双 1")
# 双 1: 金融/订单默认; 日志类业务可 redo=2 换 30%+ 写吞吐, 业务接受秒级丢失
第三步:崩溃恢复过程
宕机重启 → InnoDB 自动恢复:
1. 扫描 redo log, 找到 checkpoint
2. 重放 checkpoint 之后的全部 redo(物理页级恢复)
3. 结合 undo log: 未提交事务回滚(见 167 的 undo 用途)
恢复时间 ∝ redo 积压量 → 突发断电前若刷脏滞后, 恢复可能十几分钟(大实例)
这正是 innodb_log_file_size 要够大的原因之一: 太小 → 频繁 checkpoint 强制刷脏
总结:redo log(WAL)用顺序写保证持久性——先日志后数据页;双 1 是安全底线,可按业务降档换性能;崩溃恢复=重放 redo+回滚未提交,恢复时长取决于 redo 积压。
追问1:redo 和 binlog 的区别? → redo 是 InnoDB 物理页日志(崩溃恢复);binlog 是 Server 层逻辑日志(复制/归档);两阶段提交保证一致 追问2:组提交(group commit)? → 多个事务的 fsync 合并成一次,是双 1 下高并发的主要优化手段(自动) 追问3:什么是两阶段提交? → redo prepare → 写 binlog → redo commit;保证 redo 与 binlog 的原子性(宕机时按 binlog 是否完整决定提交或回滚)
本章基础 5 题(数据结构/缓存三问/一致性/持久化/高可用)接深入 5 题(淘汰策略/热点大 Key/Stream/Lua/pipeline),题号 176–185。
基础 5 题(数据结构/缓存三问/一致性/持久化/高可用)接深入 5 题(淘汰/热点大 Key/Stream/Lua/pipeline)。
五、Redis(165–179)
本章 15 题:数据结构与扩展(过期与碎片/SCAN/BITMAP 与 HLL/GEO/慢查询)、缓存经典问题(穿透击穿雪崩/一致性)、持久化 RDB 与 AOF、高可用(主从/哨兵/集群)、淘汰策略、热点与大 Key、发布订阅与 Stream、Lua 脚本、pipeline 与连接管理。
165. Redis 的过期时间与内存碎片?
概念 EXPIRE 设置 TTL(键级过期,精度秒/毫秒);删除时机=惰性+定期(见淘汰题);内存碎片率 = used_memory_rss / used_memory,高于 1.5 说明碎片严重(频繁修改不同长度的 value 所致)。
典型场景 缓存 TTL 设计;activedefrag 碎片整理;内存涨但数据量没涨的排查。
解决方案 三步递进:TTL 的正确姿势 → 碎片率诊断 → 主动碎片整理。
第一步:TTL 的正确姿势
# 文件: redis-ttl.py
r.set("session:abc", data, ex=3600) # 设置时带过期(原子, 优于先 set 再 expire)
r.set("counter", 1) # 不带 TTL = 永久(缓存要显式设!)
r.expire("counter", 60) # 补设
print(r.ttl("counter")) # 剩余秒数; -1 永久; -2 不存在
# TTL 设计: 基础值 + 随机抖动(防同刻过期雪崩, 见缓存三问)
import random
ttl = 3600 + random.randint(0, 600)
# 分布式锁的 TTL: 略大于业务最坏耗时(见 Lua 脚本题)
第二步:碎片率诊断
INFO memory 关键指标:
used_memory: 数据实际占用(逻辑)
used_memory_rss: 操作系统视角(物理)
mem_fragmentation_ratio = rss / used_memory
< 1: 用了 swap(内存不足, 危险!)
1~1.5: 健康
> 1.5: 碎片严重(30%+ 浪费)
碎片成因: value 长度频繁变化(改短后旧空间不还给 OS)
+ allocator 分配粒度 jemalloc
第三步:主动碎片整理
# 文件: redis.conf
activedefrag yes # 4.0+ 自动碎片整理(边运行边回收)
active-defrag-ignore-all no
# 触发条件(默认): 碎片率 > 1.1 且 used > 100MB 时启动
# 代价: 整理占用 CPU(限速可调), 高负载实例低峰开启
# 最后手段: 重启(冷启动重新分配, 碎片归零——主从切换滚动做)
总结:TTL 在 set 时原子设置并带抖动;碎片率 1~1.5 健康,高于 1.5 用 activedefrag 或滚动重启;swap 比碎片更危险(优先扩容)。
追问1:PERSIST 去掉 TTL? → 是,键变永久——缓存误用 PERSIST 是内存涨的常见原因 追问2:子键能单独过期吗? → 不能(Hash 的 field 无独立 TTL;Redis 7.4 前都不支持)——需要时拆成独立 String 键 追问3:碎片率低于 1 一定是 swap 吗? → 大概率是;确认看 INFO stats 的 swap 相关与系统层面 vmstat
166. Redis 的 SCAN 与渐进遍历?
概念 KEYS pattern 一次性全量遍历(阻塞主线程,生产禁用);SCAN 游标分批遍历(每次 O(1) 起步,可中途处理其他命令)。保证:遍历开始到结束存在的键一定被返回;期间被修改的键不保证。
典型场景 按前缀批量删除(缓存清理);全库扫描统计;在线迁移的数据遍历。
解决方案 三步递进:SCAN 基本用法 → COUNT 与误区的坑 → 按 pattern 批量删除实战。
第一步:SCAN 基本用法
# 文件: redis-scan.py
cursor = 0
total = 0
while True:
cursor, keys = r.scan(cursor=cursor, match="session:*", count=500)
total += len(keys)
if cursor == 0: # 游标归 0 = 遍历结束
break
print("session 键总数:", total)
第二步:COUNT 与重复的坑
COUNT 只是"每次扫描的提示值"(底层槽位启发式), 不是精确批大小
SCAN 可能返回重复键(rehash 期间遍历会重叠) → 需要幂等处理(集合去重/删除天然幂等)
遍历期间增删的键: 新增可能漏(可接受), 删除可能仍返回(处理时判存在)
替代专用命令: HSCAN/SSCAN/ZSCAN(集合类的渐进遍历)
第三步:按 pattern 批量删除实战
# 文件: redis-scan-delete.py
def delete_by_pattern(pattern: str, batch: int = 500) -> int:
cursor, deleted = 0, 0
pipe = r.pipeline(transaction=False)
while True:
cursor, keys = r.scan(cursor=cursor, match=pattern, count=batch)
if keys:
pipe.delete(*keys) # 批量删(重复键再删一次无副作用=幂等)
deleted += len(keys)
if cursor == 0:
break
pipe.execute()
return deleted
print(delete_by_pattern("temp:*")) # 千万级键分批删, 不阻塞线上
# KEYS temp:* + DEL: 一把梭 = 主线程阻塞数秒 = 生产事故
总结:SCAN 是 KEYS 的生产替代(游标分批+不阻塞);COUNT 是提示值且可能有重复(靠幂等消化);批量清理用 SCAN+pipeline 批删。
追问1:为什么 rehash 期间会重复? → 字典扩容后新旧两表都要遍历,交界处的键可能被扫两遍——设计上的取舍 追问2:SCAN 会漏键吗? → 遍历期间全程存在的键保证返回;遍历中新增的键不保证(业务上一般可接受) 追问3:集群下 SCAN? → 每个节点各自 SCAN(客户端按节点遍历聚合);redis-cli —scan —pattern 自动处理
167. Redis 的 BITMAP 与 HyperLogLog?
概念 BITMAP:位操作(SETBIT/BITCOUNT)的 String,1 亿用户日活只占 ~12MB;HyperLogLog(HLL):基数估算(PFADD/PFCOUNT),标准误 0.81%,固定 12KB——海量去重计数不用存明细。
典型场景 签到/日活/在线状态(BITMAP);UV 统计(HLL);面试”1 亿用户日活怎么存”。
解决方案 三步递进:BITMAP 签到实战 → BITOP 统计留存 → HLL 的 UV。
第一步:BITMAP 签到
# 文件: bitmap-checkin.py
def check_in(user_id: int, date): # date: 20261017
r.setbit(f"checkin:{date}", user_id, 1) # 第 user_id 位 = 1
def is_checked_in(user_id: int, date) -> bool:
return bool(r.getbit(f"checkin:{date}", user_id))
def daily_active_count(date) -> int:
return r.bitcount(f"checkin:{date}") # 当天签到总数
# key 按天分(一年 365 个 key);单 key 12MB(1 亿位)上下
第二步:BITOP 统计连续签到与留存
# 文件: bitmap-ops.py
# 连续 7 天签到: 7 天的 bitmap 按位 AND(全 1 才 1)
r.bitop("AND", "week:all", *[f"checkin:{20261011+i}" for i in range(7)])
print(r.bitcount("week:all")) # 连续签到人数
# 留存(今天且昨天都活跃):
r.bitop("AND", "retain", "checkin:20261017", "checkin:20261016")
print(r.bitcount("retain"))
# 注意: BITOP 是 O(N) 操作(整 key 计算), 大 key 放低峰
第三步:HyperLogLog 的 UV
# 文件: hll-uv.py
def record_uv(date, user_id: int):
r.pfadd(f"uv:{date}", user_id) # 去重计入(不存明细)
def get_uv(date) -> int:
return r.pfcount(f"uv:{date}") # 估算值(误差 0.81%)
# 月度 UV 合并:
r.pfmerge("uv:2026-10", *[f"uv:{20261001+i}" for i in range(31)])
print(r.pfcount("uv:2026-10"))
# 对比: SET 存 1 亿 user_id 约 1GB; HLL 永远 12KB —— 用精度(±0.81%)换空间
总结:BITMAP 管”谁在不在”(位级随机访问+位运算统计);HLL 管”有多少个不同”(12KB 固定+0.81% 误差);精确去重计数才用 SET。
追问1:BITMAP 的 offset 是什么? → 位的偏移(0 起)——直接用 user_id 当 offset,要求 ID 是连续整数(稀疏 ID 浪费空间) 追问2:HLL 能取出明细吗? → 不能(概率结构只给计数)——要明细就 SET/分片存储 追问3:签到月历怎么查某用户整月? → key 按月存(date 当 offset)或 30 天 getbit 聚合;月 key 更省往返
168. Redis 的 GEO 与地理位置?
概念 GEO 基于 ZSet(经纬度 geohash 编码为 score):GEOADD 存点、GEORADIUS/GEOSEARCH 查半径内的点、GEODIST 算距离。适合”附近的人/门店”这类轻量 LBS;重地理场景(路径/多边形)用 PostGIS。
典型场景 附近门店查询;骑手/司机位置上报;距离排序。
解决方案 三步递进:存点与半径查询 → 距离与排序 → 方案边界。
第一步:存点与半径查询
# 文件: geo-nearby.py
# 存门店(经度, 纬度, 成员)
r.geoadd("stores:bj", (116.48105, 39.99679, "store_1"),
(116.43441, 39.91279, "store_2"))
# 找 5km 内的门店(以某坐标为圆心)
nearby = r.geosearch("stores:bj", longitude=116.45, latitude=39.95,
radius=5, unit="km",
withdist=True, sort="ASC") # 带距离+由近到远
for member, dist in nearby:
print(member, f"{dist:.2f}km")
# geosearch 是 6.2+ 的命令(georadius 已标记废弃)
第二步:两点距离与成员坐标
# 文件: geo-dist.py
print(r.geodist("stores:bj", "store_1", "store_2", unit="km")) # 两点距离
pos = r.geopos("stores:bj", "store_1") # 取回经纬度
# 底层: ZSet 的 score = geohash(52bit 整数) → 半径查询 = score 范围 + 精筛
第三步:方案边界
适合: "附近 N 米的点+按距离排序"(半径查询是它的舒适区)
数据量: 单 key 十万级点轻松, 百万级按城市分 key
不适合: 多边形范围内搜索 / 路径规划 / 地图匹配 → PostGIS/es geo_shape
注意: geohash 精度 vs 边界效应(编码边界附近的点可能被切到相邻格) ——
半径查询建议略放大再精筛(geosearch 内部已处理, 自实现 geohash 才要注意)
总结:GEO=ZSet+geohash 的 LBS 封装;半径查询(GEOSEARCH 带距离排序)是核心用法;复杂地理计算交给 PostGIS。
追问1:为什么 GEO 基于 ZSet? → geohash 一维化后,“附近”变成 score 区间问题——复用 ZSet 的范围查询能力 追问2:位置频繁更新怎么办? → GEOADD 同成员重复添加=覆盖更新(ZSet 成员唯一);司机位置上报即重加 追问3:数据倾斜(北上广点多)? → 按城市分 key(stores:bj / stores:sh),查询先定城市再 GEORADIUS
169. Redis 的慢查询与大命令排查?
概念 Redis 慢查询日志(SLOWLOG)记录超时命令(阀值 slowlog-log-slower-than,微秒);“慢”不止是复杂命令——大 key 的读写(序列化/网络)同样致命。LATENCY/INFO 配合定位。
典型场景 Redis 周期性卡顿;某接口偶发超时;上线一个 O(N) 命令后整体变慢。
解决方案 三步递进:SLOWLOG 使用 → 大命令的定位 → 常见慢命令清单。
第一步:SLOWLOG 使用
# 文件: slowlog-check.sh
# 配置(动态):
redis-cli CONFIG SET slowlog-log-slower-than 10000 # 10ms 以上记录
redis-cli CONFIG SET slowlog-max-len 256 # 最多保留 256 条
redis-cli SLOWLOG GET 10 # 最近 10 条慢命令
# 输出: 命令/耗时微秒/客户端/时间点 —— 定位到具体命令与来源
redis-cli SLOWLOG RESET # 清空(排查后)
第二步:大命令的定位
# 文件: big-cmd-check.sh
redis-cli MONITOR | head -1000 # 低峰采样真实命令流(生产慎用, 本身有开销)
# 看每条命令的字节数: 大 value 的 GET/HGETALL/SMEMBERS 是隐形杀手
# 结合 --bigkeys(采样)与 memory usage key(精确)定位大 key(见热点大 Key 题)
# latency 框架(事件级延迟采样):
redis-cli LATENCY HISTORY event
第三步:常见慢命令清单(生产慎用/禁用)
O(N) 系: KEYS *(禁) / SMEMBERS / HGETALL 大 hash / LRANGE 0 -1 大 list
O(N) 计算: SUNION/SDIFF 大集合 / SORT / BITOP 大 bitmap
删除: DEL 大 key(用 UNLINK 异步)
风险写法: FLUSHALL(误用=灾难, 用 SCAN+批量)
替代: 全部有渐进/分批版本(SCAN 系/HSCAN/UNLINK, 见 SCAN 题)
总结:SLOWLOG(10ms 阈值)抓慢命令;慢≠复杂命令,大 key 的序列化与网络同样慢;O(N) 命令清单化,评审时对照。
追问1:慢查询日志会丢吗? → 固定长度队列(max-len),满了挤掉旧的——排查要趁早看 追问2:MONITOR 为什么危险? → 每条命令都推送给客户端,本身增加显著开销——只在低峰短时采样 追问3:pipeline 里的慢命令? → 批量执行放大耗时(一次 pipeline 里多个 O(N))——pipeline 也要审命令内容
170. Redis 数据结构与业务映射?
概念 五大结构:String(缓存/计数器)、Hash(对象字段)、List(队列/时间线)、Set(去重/关系)、ZSet(排行榜/延迟队列);底层编码随数据形态自动切换(如 listpack/ziplist 省内存)。
典型场景 缓存设计、排行榜、签到、共同好友、延迟任务——Redis 八股的”选型”层。
解决方案 五步递进,每个结构配一个 AI 场景:
String:LLM 输出缓存与限流计数
# 文件: redis-string.py
import redis
r = redis.Redis(decode_responses=True)
# 1. 结果缓存: 相同问题短窗内直接回(见第一批 47)
key = f"llm:cache:{hash(normalize(question))}"
if (hit := r.get(key)):
return hit
# ...调用 LLM 后:
r.set(key, answer, ex=3600)
# 2. 计数器: 用户日调用次数(INCR 原子)
cnt = r.incr(f"quota:{user_id}:{day}")
r.expire(f"quota:{user_id}:{day}", 86400)
if cnt > 100: raise QuotaExceeded()
Hash:会话上下文管理
# 文件: redis-hash.py
key = f"session:{session_id}"
r.hset(key, mapping={"messages": json.dumps(msgs), "updated": now})
r.expire(key, 7 * 86400) # 会话 7 天过期
msgs = json.loads(r.hget(key, "messages"))
# Hash 优势: 单独读写一个字段(messages), 不用整取整存
ZSet:Token 用量排行榜与延迟队列
# 文件: redis-zset.py
# 排行榜: 按日 token 消耗排序
r.zincrby("usage:rank:20261017", 1024, user_id) # 原子累加分数
top = r.zrevrange("usage:rank:20261017", 0, 9, withscores=True)
# 延迟队列: score 存执行时间戳
r.zadd("delay:queue", {json.dumps(task): time.time() + delay})
tasks = r.zrangebyscore("delay:queue", 0, time.time()) # 到期的任务
Set:共同关注与抽奖去重
# 文件: redis-set.py
r.sadd("follow:alice", "bob", "carol")
common = r.sinter("follow:alice", "follow:bob") # 共同关注
r.sadd("lucky:drawn", user_id)
if r.sismember("lucky:drawn", user_id): ... # 抽奖去重
List:简单任务队列
# 文件: redis-list.py
r.lpush("task:queue", json.dumps(job))
job = r.rpop("task:queue") # FIFO; 生产环境多消费者建议用 Streams 或 BLPOP 阻塞取
总结:String 计数/缓存、Hash 对象字段、List 队列、Set 关系去重、ZSet 排行/延迟——按访问模式选结构,别什么都 String JSON。
追问1:ZSet 底层实现? → 元素少用 listpack,多了转 skiplist(跳表,范围查询 O(logN))+dict(双结构同时支持按成员查与按分数排) 追问2:跳表为什么替代红黑树? → 实现简单、范围查询天然链表遍历、并发实现更容易 追问3:大 Key 危害? → 单 value 过大(如 10MB String/百万成员 ZSet)阻塞单线程、网络放大;拆分或用 SCAN 分批
171. 缓存三大经典问题:穿透、击穿、雪崩?
概念 穿透:查不存在的数据,缓存与 DB 都没有,恶意请求全打 DB;击穿:热点 key 过期瞬间,海量并发直击 DB;雪崩:大批 key 同时过期或 Redis 宕机,DB 被瞬时流量冲垮。
典型场景 上线缓存后的第一批事故;恶意扫描不存在的 ID;整点活动大量缓存同时到期。
解决方案 三组方案,各配代码:
穿透:缓存空值 + 布隆过滤器
# 文件: cache-penetration.py
def get_user(uid: int):
key = f"user:{uid}"
if (v := r.get(key)) is not None:
return None if v == "" else json.loads(v) # 空字符串=空值缓存(短 TTL)
user = db.query(uid)
if user is None:
r.set(key, "", ex=60) # 不存在也缓存 60s, 挡住重复穿透
return None
r.set(key, json.dumps(user), ex=3600)
return user
# 布隆过滤器: 把全量合法 uid 放进 Bloom Filter, 不在的直接拒绝(内存换概率型误判)
击穿:互斥锁 + 逻辑过期
# 文件: cache-breakdown.py
import time
def get_hot(key, loader):
val = r.get(key)
if val:
data = json.loads(val)
if data["expire_at"] > time.time(): # 逻辑过期判断
return data["value"]
# 逻辑过期: 只有一个线程拿到锁去刷新, 其余返回旧数据(可用性优先)
lock = r.set(f"lock:{key}", 1, nx=True, ex=10)
if lock:
fresh = loader()
r.set(key, json.dumps({"value": fresh, "expire_at": time.time() + 3600}))
r.delete(f"lock:{key}")
return data["value"] # 未抢到锁的线程返回旧值, 不打 DB
return loader() # 首次无缓存
# 对比互斥锁方案(setnx 等 DB 结果): 一致性更好但其余线程阻塞; 按业务取舍
雪崩:过期时间打散 + 多级缓存
# 文件: cache-avalanche.py
import random
def cache_with_jitter(key, value, base_ttl=3600):
ttl = base_ttl + random.randint(0, 600) # 随机抖动, 避免 Key 同时到期
r.set(key, value, ex=ttl)
# 多级防线: 本地缓存(Caffeine/进程内 LRU) → Redis → DB
# Redis 高可用: 哨兵/集群, 宕机时本地缓存还能顶一阵(熔断降级)
总结:穿透=空值缓存+布隆过滤器;击穿=互斥锁或逻辑过期;雪崩=TTL 打散+多级缓存+Redis 高可用。三者共同本质:缓存失效瞬间别让流量直冲 DB。
追问1:布隆过滤器误判怎么办? → 误判率可调(哈希函数个数/位数组大小);误判只是多查一次 DB,不会漏 追问2:逻辑过期的旧数据能接受吗? → 看业务:展示类可接受(可用性优先);余额类不可接受(用互斥锁,一致性优先) 追问3:缓存与 DB 双写一致性? → 先更新 DB 再删缓存(Cache Aside)+延迟双删兜底;强一致做不到,只追求最终一致
172. 缓存与数据库一致性:Cache Aside 与延迟双删?
概念 标准模式 Cache Aside:读→先缓存后 DB 并回填;写→先更新 DB 再删除缓存(而非更新缓存)。残留不一致的窗口靠”延迟双删”与过期时间兜底。
典型场景 改了名字列表页没变;缓存中的旧数据比 DB 新(并发写时序);设计缓存更新策略。
解决方案 三步递进:为什么”删缓存”而非”更新缓存” → 并发写的时序漏洞 → 延迟双删与兜底。
第一步:为什么删除而不是更新缓存
更新缓存的问题:
1. 并发写时序错乱: 写 A(旧值) 后写 B(新值), 但 A 的缓存更新后到 → 缓存是旧值
2. 浪费: 缓存的值可能要再加工(关联查询), 更新了却没人读
删除缓存: 下次读时回填最新值, 天然幂等 → 推荐
第二步:先更新 DB 再删缓存——仍有微小窗口
时序: 线程1 更新DB → 线程2 读缓存(旧) → 线程2 读DB(旧, 未提交前) → 线程1 删缓存 → 线程2 回填旧值
概率极低(要求读发生在写后且回填晚于删), 但存在
第三步:延迟双删+过期兜底
# 文件: cache-consistency.py
import asyncio
async def update_user(uid: int, data: dict):
await db.update_user(uid, data) # 1. 先更新 DB
await r.delete(f"user:{uid}") # 2. 删缓存
asyncio.get_event_loop().call_later( # 3. 延迟再删一次(清掉窗口期回填的旧值)
0.5, lambda: r.delete(f"user:{uid}")
)
# 4. 最终兜底: 缓存设 TTL(如 1h), 就算以上全失败, 最多 1 小时后自然一致
总结:Cache Aside(先 DB 后删缓存)是标准;并发窗口用延迟双删缩小;TTL 是最终一致的兜底——缓存一致性只有”最终一致”没有”强一致”。
追问1:为什么先更新 DB 再删缓存,不反过来? → 先删缓存:删除后读请求把旧 DB 值回填的概率更高;先 DB 后删的坏窗口更小 追问2:强一致怎么办? → 分布式锁串行化读写(性能大降),或干脆不用缓存读主库;通常业务接受秒级最终一致 追问3:订阅 binlog 删缓存? → Canal 监听变更发 MQ,消费者删缓存——把一致性职责从业务代码剥离,双删的工程化版本
173. Redis 持久化:RDB 与 AOF?
概念 RDB:定时快照(fork 子进程全量落盘,文件小恢复快,可能丢最后一段);AOF:追加写命令日志(appendfsync everysec,丢失最多 1 秒,文件大恢复慢);4.0 混合持久化(RDB 头+AOF 尾)。
典型场景 Redis 重启数据丢失范围评估;内存翻倍报警(fork 的写时复制);开启 AOF 后性能下降。
解决方案 三步递进:两种机制对比 → 生产配置推荐 → fork 的隐患。
第一步:机制对比
RDB: save 900 1 / bgsave → fork 子进程全量快照
优点: 文件紧凑恢复快 缺点: 两次快照间的数据会丢
AOF: appendonly yes → 每条写命令追加
appendfsync everysec → 每秒 fsync(最多丢 1s); always 最安全最慢
优点: 丢数据少 缺点: 文件大、恢复慢; 靠 AOF 重写(bgrewriteaof)压缩
第二步:生产配置推荐
# 文件: redis.conf
appendonly yes
appendfsync everysec # 性能与安全的平衡点
# 4.0+ 混合持久化: 重写时 RDB 全量打底 + 之后增量 AOF, 恢复快且丢得少
aof-use-rdb-preamble yes
# 内存充足时 RDB 也开(备份/主从全量同步用):
save 3600 1 # 放宽条件, 主要靠 AOF
第三步:fork 的隐患——主进程内存翻倍时刻
bgsave/bgrewriteaof 都要 fork 子进程:
- fork 瞬间主进程页表复制(内存越大越慢, 10GB 实例 fork 可达数百 ms 阻塞)
- 写时复制(COW): 子进程写盘期间主进程的写会复制内存页 → 最坏内存占用翻倍
对策: 1. 单机内存别过大(建议 <10GB, 大容量上集群分片)
2. 低峰期执行重写(auto-aof-rewrite-min-size/percentage)
3. 关闭 THP(透明大页), 减少 COW 粒度放大
总结:RDB 快恢复小丢失窗口、AOF 小丢失大文件;生产用 AOF(everysec)+混合持久化;fork 与 COW 是大实例的隐形杀手。
追问1:AOF 重写是什么? → 按当前数据状态生成最小命令集(如 100 次 INCR 重写为 SET 100),文件瘦身 追问2:Redis 重启加载顺序? → 有 AOF 先加载 AOF(更完整);无 AOF 加载 RDB 追问3:主从之间怎么同步数据? → 首次全量 RDB+增量命令流;断线重连按 offset 增量(repl_backlog 够大可免全量)
174. Redis 高可用:主从、哨兵与集群?
概念 主从复制(读写分离+数据冗余)→ 哨兵(Sentinel 自动故障转移,选新主)→ Cluster 集群(16384 槽位分片,数据分布式+内置高可用)。层级递进:容量或可用性到瓶颈才升级。
典型场景 Redis 单点故障;单实例内存不够(超 10GB);写 QPS 单机上限。
解决方案 三步递进:主从+哨兵 → Cluster 分片 → 选型决策。
第一步:主从+哨兵——自动故障转移
1 主 2 从 + 3 哨兵(奇数, 独立部署):
- 哨兵每秒 ping 主库, 超过 down-after-milliseconds 判主观下线
- 多数哨兵同意 → 客观下线 → 选举领头哨兵 → 从从库选数据最新的提升为主
- 客户端通过哨兵 API 发现新主(vip/DNS 或支持哨兵的客户端自动切换)
第二步:Cluster 集群——数据分片
16384 个槽位: key → CRC16(key) mod 16384 → 槽位 → 节点
- 每个 master 负责一段槽位(如 6 节点 × 2730 槽), 每 master 带 1 从(故障转移)
- 客户端直连: MOVED/ASK 重定向; 智能 client 缓存槽位表
- 限制: 多 key 操作必须同槽(hash tag: {user123}:orders 强制同槽)
- 适用: 单机内存上限(如数据 30GB)/写入 QPS 单机瓶颈
第三步:选型决策
数据 < 10GB, 能接受分钟级故障切换 → 主从+哨兵(最简单)
数据 > 10GB 或写 QPS 单机瓶颈 → Cluster(分片)
预算有限但要求可用 → 云厂商托管(Redis/Tair), 运维省心
注意: Cluster 下事务/Lua/多 key 操作受同槽限制 → 设计 key 时就要想好 hash tag
总结:主从+哨兵解决可用性,Cluster 解决容量与写入扩展;升级按需,Cluster 的同槽限制要提前进入 key 设计。
追问1:哨兵脑裂? → 旧主与新主并存期间客户端仍写旧主,新主提升后旧主数据被清 → min-replicas-to-write 限制主库最少从库数缓解 追问2:热 key 怎么办? → 本地缓存挡一层、key 加随机后缀分散到多节点、读写分离让从库分读 追问3:Redis 为什么单线程还这么快? → 纯内存操作+epoll 多路复用+单线程无锁无切换;6.0 后网络 IO 多线程但命令执行仍单线程
175. Redis 的内存淘汰策略怎么选?
概念 内存达到 maxmemory 时的淘汰策略:noeviction(默认,拒绝写入)、allkeys-lru/lfu(全键淘汰)、volatile-lru/lfu(仅带 TTL 的键)、allkeys-random、volatile-random、volatile-ttl(优先淘汰快过期的)。4.0+ 的 LFU 是热点场景更优解。
典型场景 缓存实例 OOM 报错(默认 noeviction 写入失败);缓存命中率随 LRU 抖动(冷数据被偶然访问顶掉热数据)。
解决方案 三步递进:策略矩阵 → LFU vs LRU → 过期键的删除时机。
第一步:策略矩阵——按用途选
纯缓存实例: allkeys-lru(或 lfu) —— 所有键都是缓存, 淘汰最久未用
缓存+存储混用: volatile-lru —— 只淘汰带 TTL 的(不带 TTL 的当存储保护)
不允许丢数据: noeviction —— 写满报错人工介入(存储型用法)
都有 TTL: volatile-ttl —— 优先删快过期的(顺水推舟)
生产缓存推荐: allkeys-lfu(4.0+) —— 按访问频率, 抗偶发扫描
第二步:LFU vs LRU——偶然访问的区别
LRU 问题: 一次大批量扫描(如离线任务全量遍历)会把真正的热数据全部"顶旧"
扫描键刚访问过 → LRU 认为它是"新的"
LFU 逻辑: 每个键维护访问计数(对数递增+周期衰减)
扫描键只加 1 次计数, 挤不掉高频热键
参数: lfu-log-factor 10(计数增长速度) / lfu-decay-time 1(分钟, 衰减周期)
第三步:过期键的删除时机——惰性+定期
TTL 到期 ≠ 立即删除:
1. 惰性删除: 访问该键时检查过期 → 过期才删(过期键若无人访问会占内存)
2. 定期删除: 后台周期性抽样删除过期键(每 100ms 抽样)
3. 内存满时: 淘汰策略兜底(volatile 系列会优先考虑过期键)
风险: 大量同刻过期+惰性堆积 → 内存假性打满 → 监控 expired_keys 指标
治理: TTL 加随机抖动(见 194 雪崩), 避免同刻过期
总结:缓存实例 allkeys-lfu 抗扫描;混用实例 volatile 系保护无 TTL 键;过期靠惰性+定期,TTL 抖动防堆积。
追问1:maxmemory 设多少? → 物理内存的 70-80%(留碎片率与 fork COW 余量,见 196 的 fork 隐患)
追问2:怎么查内存构成? → memory usage key(单键)、INFO memory(used_memory vs used_memory_rss, 比值即碎片率)、redis-cli --bigkeys
追问3:noeviction 报错的表现? → 写命令返回 OOM command not allowed;读不受影响——存储型实例必须监控内存提前扩容
176. 热点 Key 与大 Key 的治理?
概念 热点 Key:访问集中在少数键(QPS 数十万打一个键,单线程成瓶颈);大 Key:value 过大(String >1MB、集合类元素过多(如百万元素 ZSet))。两者都拖垮 Redis:热点打满单核,大 Key 阻塞单线程(操作耗时)+网络放大。
典型场景 明星热搜打进一个计数器;一个千万成员的 Hash 被 HGETALL;大 Key 删除时主线程卡顿。
解决方案 三步递进:发现手段 → 热点治理 → 大 Key 治理。
第一步:发现——监控先行
热点: redis-cli --hotkeys(需 maxmemory-policy 为 lfu)| 代理/客户端埋点统计 | monitor 采样(低峰)
大 Key: redis-cli --bigkeys(抽样) | RDB 离线分析(redis-rdb-tools, 精确) | 内存告警(memory usage 逐键排查)
标准(经验): String > 10KB / 集合 > 5000 元素 / 总量 > 1MB 即需关注
第二步:热点治理——打散与多级
# 文件: hotkey-shard.py
# 方案: key 加随机后缀打散到多个逻辑分片(读时随机读一个, 写时同步写全部分片)
def hot_counter_incr(name: str, n: int = 16):
idx = random.randint(0, n - 1) # 随机选分片写(或按机器哈希)
return r.incr(f"{name}:{idx}")
def hot_counter_get(name: str, n: int = 16) -> int:
pipe = r.pipeline()
for i in range(n): # 读时聚合全部分片
pipe.get(f"{name}:{i}")
return sum(int(v or 0) for v in pipe.execute())
# 进阶: 本地缓存挡读(Caffeine/进程内 LRU) —— 热点读根本不打到 Redis
第三步:大 Key 治理——拆分与渐进清理
# 文件: bigkey-split.py
# 1. 拆分: 大 Hash 按 hash(field)%N 拆成 N 个小 Hash; 大 List 按范围分段
def hset_split(name: str, field: str, value: str, n: int = 32):
bucket = hash(field) % n
return r.hset(f"{name}:{bucket}", field, value)
# 2. 删除: UNLINK(4.0+, 异步回收, 不阻塞主线程) 代替 DEL
r.unlink("big:key") # DEL 是同步逐元素释放 —— 百万元素删一次卡几秒
# 3. 集合类的渐进操作: HSCAN/SSCAN 游标遍历分批处理, 禁 HGETALL/SMEMBERS 全量
总结:热点靠打散(后缀分片+本地缓存)与多级缓存;大 Key 靠拆分(哈希分桶)+UNLINK 异步删+SCAN 渐进遍历;前提是 —bigkeys 与 RDB 分析的定期巡检。
追问1:为什么大 Key 拖慢单线程? → 序列化/网络传输耗时与 value 大小成正比,期间所有命令排队;删除的大对象释放也占主线程 追问2:集群下大 Key 的额外问题? → 数据倾斜(某分片内存/流量远超其他)+迁移卡顿(reshard 传输大 value) 追问3:热点 Key 在集群模式失效吗? → 是——key 只在一个槽位(一个节点),打散后缀才能摊到多节点
倒排原理、深分页、查询 DSL、写入优化、集群分片、同步管道、聚合、向量混合检索。
倒排原理、深分页、查询 DSL、写入、集群、同步、聚合、向量混合检索。
倒排原理、深分页、查询 DSL、写入优化、集群分片、同步管道、聚合、向量混合检索。
177. Redis 的发布订阅与 Stream?
概念 Pub/Sub:发布订阅广播(无持久化,离线订阅者丢消息,不保证送达);Stream(5.0+):持久化消息队列(消费组/ACK/消息 ID 有序,轻量 Kafka)。选型:通知广播用 Pub/Sub,可靠任务队列用 Stream(或专业 MQ)。
典型场景 配置变更通知全部实例;进程内轻量任务队列不想引 RabbitMQ;缓存失效广播。
解决方案 三步递进:Pub/Sub 的用法与缺陷 → Stream 基础 → 消费组实战。
第一步:Pub/Sub——广播但不保证
# 文件: pubsub-basic.py
# 订阅端(每个实例都订阅)
ps = r.pubsub()
ps.subscribe("config:changed")
for msg in ps.listen():
if msg["type"] == "message":
reload_config(msg["data"]) # 收到广播刷新本地缓存
# 发布端
r.publish("config:changed", json.dumps({"key": "rate_limit", "value": 100}))
# 缺陷: 订阅者断线期间的消息永久丢失; 无 ACK; 慢消费者被断开
# 适用: 丢了也无妨的"通知"(各实例主动拉最新值兜底)
第二步:Stream 基础——持久化与消费组
# 文件: stream-basic.py
# 生产: XADD 自动生成有序 ID(时间戳-序号)
r.xadd("orders:stream", {"order_id": 1001, "user_id": 42})
# 消费组: 多消费者负载均衡 + ACK 确认
r.xgroup_create("orders:stream", "processors", id="0")
while True:
# > 表示只取该消费者未处理过的新消息; block 阻塞等待
resp = r.xreadgroup("processors", "worker-1", {"orders:stream": ">"}, count=10, block=5000)
for stream, messages in resp:
for msg_id, fields in messages:
process(fields)
r.xack("orders:stream", "processors", msg_id) # 处理完 ACK
第三步:可靠性细节——pending 与死信
# 文件: stream-pending.py
# 消费者崩溃: 已读未 ACK 的消息进入 pending 列表
pending = r.xpending_range("orders:stream", "processors", "-", "+", 10)
for p in pending:
if idle_too_long(p["time_since_delivered"]): # 长时间未 ACK
# 转移给其他消费者重试(XCLAIM)
r.xclaim("orders:stream", "processors", "worker-2",
min_idle_time=60000, message_ids=[p["message_id"]])
# 消息修剪: XTRIM 控制流长度(MAXLEN ~ 按容量), 防 Stream 无限膨胀
r.xtrim("orders:stream", maxlen=100000, approximate=True)
总结:Pub/Sub 是“喊一嗓子”(广播无保障,通知类适用);Stream 是“登记在册”(持久化+消费组+ACK,pending+claim 处理故障);可靠队列需求大了仍上专业 MQ(见 165 选型)。
追问1:Stream 和 List 做队列的区别? → List 无消费组/ACK(lpop 即消费,崩溃丢消息);Stream 有完整队列语义——轻量队列选 Stream 追问2:Pub/Sub 在集群里怎么工作? → 广播到所有节点(每个节点转发给本地订阅者),流量放大——大规模广播慎用 追问3:Stream 会丢数据吗? → Redis 宕机未开持久化会丢(它首先是 Redis);AOF everysec 下最多丢 1s——与 RabbitMQ 的差距在此
178. Redis 的 Lua 脚本与事务( MULTI/EXEC)?
概念 Lua 脚本在 Redis 服务端原子执行(执行期间不插入其他命令),是实现复合原子操作(限流/锁/比较后赋值)的标准工具。MULTI/EXEC 事务是命令排队批量执行(原子但中途不能有条件判断);WATCH 实现乐观锁。
典型场景 令牌桶限流的原子扣减(见第一批 73);分布式锁的“检查并设置+过期”;库存扣减的“判断+扣减”原子化。
解决方案 三步递进:Lua 原子性 → 与 MULTI/EXEC 的对比 → 实战:可过期的分布式锁。
第一步:Lua 原子性——复合操作不分家
-- 文件: stock-deduct.lua
-- KEYS[1]=库存键, ARGV[1]=扣减数量
local stock = tonumber(redis.call('GET', KEYS[1]) or '0')
if stock < tonumber(ARGV[1]) then
return -1 -- 库存不足
end
redis.call('DECRBY', KEYS[1], ARGV[1]) -- 判断与扣减之间不会被插入其他命令
return stock - tonumber(ARGV[1])
# 文件: stock-deduct.py
import redis
r = redis.Redis(decode_responses=True)
left = r.eval(open("stock-deduct.lua").read(), 1, "stock:sku1001", 1)
# 若用 GET 再 DECRBY 两步: 并发下两者之间库存可能被改 → 超卖
第二步:与 MULTI/EXEC 对比——脚本有逻辑,事务只有排队
MULTI/EXEC: 命令入队 → 一次性顺序执行(执行期不被插入)
缺陷: 入队时不能依赖中间结果(不能"查了再决定"), 入队语法错才发现
定位: 简单批量(一次改多个 key 且无逻辑依赖)
Lua 脚本: 完整编程逻辑(if/循环), 原子执行
定位: 有条件的复合操作(限流/锁/库存)
生产口径: 需要原子复合逻辑 → Lua; 简单批量 → pipeline + MULTI
第三步:实战:带续期的分布式锁的正确写法
-- 文件: lock-acquire.lua
-- KEYS[1]=锁键, ARGV[1]=随机值, ARGV[2]=过期秒数
if redis.call('SET', KEYS[1], ARGV[1], 'NX', 'EX', ARGV[2]) then
return 1 -- 抢到
end
-- 可扩展: 持有者是自己的锁则续期(看门狗由客户端定时调用)
if redis.call('GET', KEYS[1]) == ARGV[1] then
redis.call('EXPIRE', KEYS[1], ARGV[2])
return 1
end
return 0
# 文件: lock-usage.py
token = uuid.uuid4().hex # 唯一标识持有者
got = r.eval(lua_acquire, 1, "lock:report", token, 10)
if got:
try: run_critical_section()
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:report", token)
总结:原子复合操作的标准答案是 Lua(判断+修改不分家);MULTI/EXEC 只是批量排队;分布式锁的正确性 = 唯一 token + Lua 原子获取/释放 + 过期兜底(续期可选)。
追问1:Lua 脚本的性能注意? → 脚本执行期间阻塞整个 Redis——长循环/大 key 操作的脚本会拖垮全库;脚本要短小 追问2:Redisson 的看门狗是什么? → 客户端后台定时(锁 TTL 的 1/3)调用续期 Lua,业务没跑完锁不过期——见 148 追问的原理实现 追问3:主从下 Lua 的执行? → 只在主节点执行,命令结果随复制传播——脚本内不能有随机/时间依赖(会主从不一致)
179. Redis 的 pipeline 与连接管理?
概念 pipeline(管道)把多条命令打包一次发送一次接收,省去逐条 RTT(往返延迟),吞吐提升数倍到数十倍;但非原子(命令间可插入其他客户端命令)。连接管理:连接池大小、超时、长连接复用。
典型场景 批量读写几百个 key;监控指标批量写入;高并发下连接数暴涨。
解决方案 三步递进:pipeline 用法与边界 → 批量替代方案(MSET/批量命令) → 连接池配置。
第一步:pipeline——攒批发送
# 文件: pipeline-basic.py
keys = [f"user:{i}" for i in range(1000)]
# 逐条: 1000 次 RTT, 局域网 0.5ms/次 → 仅网络就 500ms
# pipeline: 1 次 RTT
pipe = r.pipeline(transaction=False) # transaction=False: 纯管道不包 MULTI
for k in keys:
pipe.get(k)
values = pipe.execute() # 一次发送, 按序返回
# 提升量级: 数十倍; 边界: 非原子(命令间可插入他人命令, 需原子用 Lua)
第二步:批量替代——能一条命令就别 pipeline
# 文件: batch-vs-pipeline.py
# MSET/MGET: 一条命令搞定, 优于 pipeline
r.mset({f"k{i}": i for i in range(100)})
values = r.mget([f"k{i}" for i in range(100)])
# 注意: MGET 在 Cluster 模式跨槽会报错(需按槽分组, 或客户端按分片聚合)
# 大量写入仍要控制批量大小: 每批 500-1000 条, 分批提交(防单次响应过大阻塞)
第三步:连接池配置
# 文件: pool-config.py
pool = redis.ConnectionPool(
host="localhost", port=6379,
max_connections=100, # 上限: (应用实例数 × max) < Redis maxclients
socket_timeout=2, # 单命令超时: 卡死连接及时断
socket_connect_timeout=1, # 建连超时
health_check_interval=30, # 空闲连接定期 PING 保活(防 NAT/防火墙掐)
retry_on_timeout=True, # 超时重试(幂等命令才安全)
)
r = redis.Redis(connection_pool=pool)
# 监控: 连接池水位(pool._created/_available), maxclients 报错即池配过大
总结:pipeline 攒批省 RTT(非原子);能用 MSET/MGET 单命令更优;连接池三要素——上限核算、超时兜底、保活防掐。
追问1:pipeline 和 Lua 的组合? → 可以:pipeline 里 eval 多个 Lua——批量原子操作(如分片锁的批量获取) 追问2:Cluster 下 pipeline 的坑? → 不同槽的命令会路由失败;客户端需按槽分组分批(redis-py-cluster 自动处理但有拆分开销) 追问3:连接数多少合适? → 单实例池 20-100(看并发);总连接 = 实例数 × 池上限,需小于 maxclients(默认 10000)留管理余量
第二批完(100–199):Python 15、FastAPI 15、Python 后端进阶 10、MySQL 19(基础 15 + 深入 4)、Redis 9(基础 5 + 深入 4)、RabbitMQ/Kafka 7、Elasticsearch 8,共 80 题。NestJS 20 题与 LangChain/LangGraph/Agent/RAG 10 题已移至第三批文件。
消息队列七题:RabbitMQ 可靠性/延迟队列/消费端设计/集群,Kafka 模型与死信最终一致,题号 186–192。
六、RabbitMQ 与消息队列(180–189)
本章 10 题:Kafka 分区模型、死信重试与最终一致、积压应急、顺序性、幂等消费、RabbitMQ 选型与集群、消息可靠性三段防线、延迟队列、消费端设计。
180. Kafka 核心模型:分区、消费组与位点?
概念 Kafka 把 topic 分为多个 partition(分区,并行与顺序的单位);consumer group 内每个分区只被一个消费者消费(组内竞争、组间广播);offset(位点)记录消费进度,可重置回放。
典型场景 行为日志/消息流水线(高吞吐)、RAG 文档批量处理流水线、事件溯源;面试常与 RabbitMQ 对比。
解决方案 三步递进:分区与顺序 → 消费组与再平衡 → offset 管理。
第一步:分区——并行与顺序的单位
topic=user-events, 6 个 partition
生产: 按 key 哈希路由(user_id 相同的消息进同一分区 → 分区内有序)
消费: 分区数 = 消费组内最大并行度(6 分区最多 6 个消费者同时消费)
扩容: 加 partition 会破坏按 key 的分区映射(已写入数据不动) —— 分区数要一次规划足
第二步:消费组与再平衡
group: points-service —— 组内竞争(一条消息只被组内一个消费者处理)
group: audit-service —— 另一组全量消费(广播)
再平衡(Rebalance): 消费者加入/退出时分区重新分配
→ 期间整组停止消费(stop the world), 生产事故高发区
→ 缓解: session.timeout 合理设置、静态成员资格(group.instance.id)、增量协作再平衡
第三步:offset 管理——自动与手动的取舍
# 文件: kafka-offset.py
from confluent_kafka import Consumer, KafkaError
c = Consumer({
"bootstrap.servers": "kafka:9092",
"group.id": "points-service",
"enable.auto.commit": False, # 手动提交: 处理完才提交, 防丢
"auto.offset.reset": "earliest", # 新组从头消费
})
c.subscribe(["order-events"])
while True:
msg = c.poll(1.0)
if msg is None or msg.error(): continue
process(msg.value()) # 幂等消费(见 168)
c.commit(asynchronous=False) # 处理完同步提交(或攒批异步提交)
# 消息堆积可回放: 重置 offset 到历史位置重新消费(修复数据/补算) —— Kafka 独有能力
总结:分区=并行与顺序单位(分区内有序);消费组=组内竞争组间广播,再平衡是风险点;手动提交 offset + 幂等消费 = 不丢不重。
追问1:怎么保证消息不丢? → 生产 acks=all + retries;broker 副本因子 ≥2 + min.insync.replicas=2;消费手动提交 追问2:Kafka 为什么快? → 顺序写磁盘+页缓存、零拷贝(sendfile)、批量压缩、分区并行 追问3:消息堆积百万条怎么办? → 消费者扩容到分区数上限、提高 max.poll.records、优化单条处理耗时、下游瓶颈优先解决
181. 死信、重试与最终一致?
概念 消费失败的分级处理:可重试错误(下游超时)按退避间隔重试,重试耗尽进死信队列(DLQ)人工介入;本地消息表让”业务事务+发消息”原子化,实现最终一致。
典型场景 消费 LLM 回调时上游超时;积分服务故障期间消息堆积;跨服务数据一致性(订单库与积分库)。
解决方案 三步递进:错误分类与重试拓扑 → 死信处理 → 本地消息表。
第一步:错误分类——决定重试还是死信
可重试(TransientError): 下游超时、限流 429、临时网络抖动 → 退避重试
不可重试(PermanentError): 参数非法、业务校验失败、数据不存在 → 直接死信(重试无意义)
判断错误类型是消费端设计的第一步 —— 不分类的盲目重试=死循环风暴
第二步:重试拓扑与死信
拓扑(分级退避队列):
order.queue ─失败→ retry.5s.queue(5s 后回投 order.queue)
再次失败 → retry.30s.queue → 再次失败 → dead.letter.queue + 告警
实现: 每级队列声明 x-dead-letter-exchange 指向下一级, TTL 即退避间隔
死信消费: 人工排查 + 修复后 re-inject; 或提供管理接口按 id 重投
第三步:本地消息表——事务与消息的原子性
# 文件: local-message-table.py
def create_order(db, payload):
with db.transaction():
order = db.insert_order(payload) # 1. 业务写入
db.insert_outbox({ # 2. 消息记录同事务!
"topic": "order.created",
"payload": json.dumps(payload),
"status": "PENDING",
})
# 3. 后台轮询(或 binlog tail)把 PENDING 消息发 MQ, 成功后标记 SENT
# 崩溃恢复: 重启后轮询继续发送 → 业务与消息的最终一致
# 4. 对账兜底: 定时任务对比 outbox 与 MQ 控制台, 漏发的补发
总结:消费失败先分类再处理——可重试走分级退避队列,不可重试进死信+告警;“业务+消息”的原子性靠本地消息表(同事务落库+轮询补偿),这是最终一致的工程底座。
追问1:为什么不用 RabbitMQ 事务? → AMQP 事务把 broker 吞吐拉低一个量级;confirm+本地消息表是性能与可靠的平衡 追问2:死信队列的消息有 TTL 吗? → 可以设,过期自动删除或再转投;但人工处理前建议保留(带时间戳与原始 header) 追问3:分布式事务对比? → 2PC/XA 强一致性能差;TCC 业务侵入大;本地消息表+最终一致是互联网主流(见第一批 71 的幂等配合)
Elasticsearch 八题:倒排原理/深分页/DSL/写入/集群/同步管道/聚合/向量混合检索,题号 193–200。
182. 消息积压的应急处理?
概念 积压=生产速度持续大于消费速度。处理分三层:应急(扩消费者/批量消费/降级丢弃)、根因(消费慢在哪/生产突增)、预防(监控告警+容量规划)。
典型场景 大促消息洪峰消费不过来;消费者依赖的 DB 慢导致积压;上线了 bug 消费者反复失败。
解决方案 三步递进:应急三板斧 → 根因排查 → 预防机制。
第一步:应急三板斧
1. 扩消费者: 加机器/加 prefetch(注意分区数上限——Kafka 消费者数 > 分区数无效, 见 170)
2. 批量消费: 逐条改批量(DB 批量写/聚合后处理)——吞吐量级提升
3. 降级/转移:
- 可丢的(埋点/通知): 直接丢弃积压(过期 TTL)或抽样消费
- 不可丢但可慢: 转移到新的"快队列"(消费逻辑简化版: 只落库不处理)
- 终极: 持久化到磁盘, 离线补处理(先保线上)
第二步:根因排查
消费耗时拆解(消费一条 = 拉取 + 业务处理 + 外部调用 + 提交):
1. 外部依赖慢(DB/下游接口) → 大头通常在这: 优化查询/加缓存/熔断降级
2. 业务逻辑重(逐条调 LLM 之类) → 批量化/异步化(先落库后处理)
3. 消费者异常(反复重试空转) → 看错误日志: 死循环的消息进死信, 别堵队列
4. 生产突增(活动/bug) → 生产侧限流/修复
第三步:预防机制
监控: 队列深度(consumer lag)+ 消费速率趋势 —— lag 持续增长即积压前兆
告警: lag > 阈值(如 10 万)/ 消费速率跌幅 50%
容量: 压测得出单消费者吞吐 → 按峰值生产速度 x 2 规划消费者数
演练: 定期故障演练(kill 消费者观察恢复)——积压处理预案不是纸面文章
总结:积压应急=扩容/批量/降级转移;根因多在消费端外部依赖;lag 监控+容量规划是预防核心。
追问1:Kafka 的 lag 怎么看? → kafka-consumer-groups.sh —describe 或 Burrow/exporter 监控 consumer lag 指标 追问2:扩容无效的场景? → 消费者数已达分区数上限(Kafka)/ 瓶颈在下游 DB(扩消费者反而打挂 DB) 追问3:积压时消息过期了怎么办? → TTL 过期进死信或丢弃(按配置)——关键业务消息不设 TTL,靠容量兜底
183. 消息顺序性的深入场景?
概念 全局有序(单队列单消费者,牺牲并发)vs 局部有序(按业务 key 分区,同 key 有序)。局部有序是主流:分区路由保证同 key 进同队列,消费端单线程处理该队列。
典型场景 订单状态流转(创建→支付→发货不能乱);账户余额变更流水;同一用户的操作序列。
解决方案 三步递进:乱序的成因 → 分区路由实现 → 消费端保序的例外情况。
第一步:乱序的成因
三个乱序来源:
1. 生产端: 多线程发布, 网络重试导致先发后至(消息 2 重试成功早于消息 1)
2. 队列端: 多分区/多队列, 同 key 消息被路由到不同分区
3. 消费端: 多消费者/并发处理, 完成顺序与到达顺序不同
第二步:分区路由实现
# 文件: mq-order-key.py
# RabbitMQ: 一致的 routing key → 绑定到固定队列(每队列单消费者)
def publish_order_event(order_id: str, event: dict):
ch.basic_publish(
exchange="orders",
routing_key=f"order.{order_id}", # 同一订单恒定路由
body=json.dumps(event),
)
# 队列绑定: order.* 各订单分散到多个队列(哈希), 单队列内同订单连续
# Kafka: partition key
producer.produce(topic, key=order_id, value=...) # 同 key 同分区, 分区内有序
第三步:消费端的例外情况
重试破坏顺序: 消息 1 处理失败进重试队列, 消息 2 先被处理 → 乱!
对策:
1. 同 key 失败 = 该队列暂停消费(等重试成功) —— 牺牲吞吐保顺序
2. 业务层版本号: 消息带 version, 消费时 version <= 已处理版本则丢弃(幂等+乱序兼容)
3. 状态机校验: 订单"已支付"再来"待支付"事件 → 判定为迟到消息, 丢弃或修正
实践: 大多数业务用方案 3(状态机), 完美顺序的成本过高
总结:局部有序=分区路由(同 key 同队列)+消费端串行;重试会破坏顺序,用状态机/版本号做乱序兼容是务实解。
追问1:全局有序的代价? → 单队列单消费者,吞吐上限=单消费者能力,并行度 1——仅极核心场景用 追问2:状态机方案怎么设计? → 状态转移表(当前状态+事件→新状态),非法转移(乱序迟到)记日志丢弃 追问3:消费端多线程还能保序吗? → 按 key 再分派:拉取后按 key 哈希到固定工作线程(同 key 串行)
184. 幂等消费的深入设计?
概念 消息投递语义至少一次(at-least-once)必然重复,幂等是消费端必备。方案分层:唯一约束兜底、去重表(消息级)、业务状态机(业务级)、Redis 预检(性能层)。
典型场景 支付回调重复消费多扣款;积分重复累加;上游重试导致的批量重复。
解决方案 三步递进:四层方案对比 → 去重表实现 → 状态机幂等。
第一步:四层方案对比
唯一约束(DB): INSERT 冲突即拦截 —— 最硬的兜底, 必须有
去重表(消息级): consumed_messages(msg_id 唯一索引) —— 通用, 与业务解耦
状态机(业务级): 状态转移合法性校验 —— 语义正确(重复的"已支付"再处理=无操作)
Redis(性能层): SETNX 预检快速返回 —— 挡掉大部分重复, 但宕机有窗口(不能只靠它)
实践: Redis 预检 + DB 唯一约束 双层(快 + 稳)
第二步:去重表实现
# 文件: idempotent-table.py
def consume(msg):
msg_id = msg.headers["message_id"]
with db.transaction():
inserted = db.execute(
"INSERT INTO consumed_messages (msg_id, consumed_at) "
"VALUES (%s, NOW()) ON DUPLICATE KEY UPDATE msg_id=msg_id", # 幂等写
(msg_id,),
)
if inserted == 0: # 已消费过(唯一索引冲突)
ack(msg); return # 确认并跳过
process_business(msg.payload) # 与去重记录同事务: 要么都成功要么都回滚
ack(msg)
第三步:状态机幂等
# 文件: idempotent-statemachine.py
LEGAL = {("CREATED", "PAID"), ("PAID", "SHIPPED"), ("SHIPPED", "DONE")}
def on_order_event(order_id, new_status):
order = db.get_order(order_id)
if (order.status, new_status) not in LEGAL:
# 重复事件(当前已是 new_status)或乱序迟到 → 幂等跳过
log.warn(f"忽略状态转移 {order.status} -> {new_status}")
return
db.update_status(order_id, new_status)
# 重复的 PAID 事件: (PAID, PAID) 不在合法表 → 跳过(天然幂等)
总结:幂等四层——唯一约束兜底、去重表(消息级通用)、状态机(业务语义级)、Redis 预检(性能层);标准组合是 Redis 预检+DB 唯一约束双层。
追问1:去重表膨胀怎么办? → 定期归档(保留 N 天)/按 msg_id 哈希分表/用 Redis 带 TTL 做第一层减小写入量 追问2:msg_id 谁生成? → 生产者生成并持久化到消息头(业务 id+版本 或 UUID);消费端不生成 追问3:跨系统幂等(消费后调下游)? → 下游也要幂等(传递 msg_id 作幂等键)——链路上每跳都要,或本层落库后异步对账
倒排原理、深分页、查询 DSL、写入调优、集群分片、同步管道、聚合、向量混合、mapping 设计。
185. 消息队列解决什么问题?为什么选 RabbitMQ?
概念 MQ 三大价值:异步(削峰填谷)、解耦(生产者不关心消费者)、削峰(瞬时流量排队消化)。RabbitMQ:AMQP 协议、交换机路由灵活(直连/主题/扇形)、死信队列/延迟队列生态成熟。
典型场景 下单后要发短信/加积分/更新统计(同步串联慢且耦合);秒杀请求洪峰;AI 平台的异步任务(批量文档解析喂 RAG)。
解决方案 三步递进:同步 vs 异步的吞吐对比 → 交换机路由模型 → 与 Kafka 的选型。
第一步:同步链路的痛与异步化
# 文件: mq-why.py
# ❌ 同步串联: 用户等 3 个下游都完成, 任一失败全失败, 总耗时 900ms
create_order(); notify_sms(); award_points(); update_stats()
# ✅ 异步: 下单只管落库+发消息(50ms 返回), 其余由消费者异步完成
create_order()
mq.publish("order.created", {"order_id": 1})
# 消费端各自订阅: 短信服务/积分服务/统计服务 —— 新增需求只加消费者, 不改下单代码(解耦)
第二步:交换机路由模型
Producer → Exchange(交换机) → Binding(路由规则) → Queue → Consumer
- Direct: 精确匹配 routing key(订单事件 → order.queue)
- Topic: 通配符匹配(order.created 匹配 order.#)—— 事件总线常用
- Fanout: 广播到所有绑定队列(配置变更通知全部实例)
- 死信交换机 DLX: 消费失败/过期/队列满的消息转投到死信队列 → 人工处理或延迟重试
第三步:RabbitMQ vs Kafka 选型
RabbitMQ: 任务队列语义(每条消息只给一个消费者)、复杂路由、优先级/延迟队列、管理界面
Kafka: 日志流语义(消息保留可回放、分区并行)、高吞吐(百万/s)、适合事件溯源/日志管道
你的场景: 业务事件(下单/支付通知)、任务队列 → RabbitMQ; 用户行为日志流、RAG 文档处理流水线 → Kafka
总结:MQ 解决异步/解耦/削峰;RabbitMQ 的交换机路由+死信/延迟队列适合业务任务队列;日志流与大吞吐选 Kafka。
追问1:消息丢了怎么办? → 三段保证:生产者 confirm 模式(broker 确认)、队列/消息持久化(durable+delivery_mode=2)、消费者手动 ack 追问2:消息重复怎么办? → 网络重发不可避免,消费端幂等(唯一键去重表/Redis SETNX,见 72) 追问3:消息顺序怎么保证? → 单队列单消费者天然有序;多消费者按业务 key 分路由到固定队列(如 order:{id} → 固定 queue)
186. 消息可靠性:不丢消息的三段防线?
概念 消息从生产到消费的三段:生产端(confirm 确认)、存储端(持久化)、消费端(手动 ack)。任何一段丢失都会造成消息丢失。
典型场景 支付成功消息丢失导致订单未处理;服务重启队列消息消失;消费者抛异常消息被误 ack。
解决方案 三步递进:生产端 confirm → 存储持久化 → 消费端 ack 与重试。
第一步:生产端——confirm 模式
# 文件: mq-confirm.py
import pika
channel.confirm_delivery() # 开启 confirm 模式
try:
channel.basic_publish(
exchange="events", routing_key="order.created",
body=json.dumps(payload),
properties=pika.BasicProperties(delivery_mode=2), # 消息持久化
)
# confirm 模式下 publish 是同步确认的: broker 收到才返回
except pika.exceptions.UnroutableError:
save_to_local_table(payload) # 路由失败落库补偿(本地消息表)
第二步:存储端——队列与消息双持久化
# 文件: mq-durable.py
channel.queue_declare(queue="order_queue", durable=True) # 队列持久化
channel.basic_publish(
exchange="", routing_key="order_queue",
body=payload,
properties=pika.BasicProperties(delivery_mode=2), # 消息持久化(delivery_mode=2)
)
# 注意: 已存在的非持久化队列不能直接改 durable —— 删了重建或换名字
第三步:消费端——手动 ack 与重试/死信
# 文件: mq-ack.py
def callback(ch, method, properties, body):
try:
process(json.loads(body))
ch.basic_ack(delivery_tag=method.delivery_tag) # 成功才 ack
except TransientError:
# 可重试错误: nack 回队列(requeue=True)会造成立即重试风暴 → 走延迟重试队列
ch.basic_nack(delivery_tag=method.delivery_tag, requeue=False) # 转投死信交换机
except PermanentError:
ch.basic_nack(delivery_tag=method.delivery_tag, requeue=False) # 不可重试 → 死信人工处理
channel.basic_consume("order_queue", callback)
# 重试拓扑: 队列 x-delayed-message 插件 或 "retry.5s/retry.30s" 分级队列 + DLX 路由
总结:不丢消息=confirm(生产)+durable(存储)+手动 ack(消费),三段缺一不可;失败消息走死信队列分级重试,不要 requeue=True 无限循环。
追问1:本地消息表是什么? → 业务与消息记录同事务落库,后台轮询把未发送的消息补偿发出——把”发消息”纳入事务保障(最终一致) 追问2:消息堆积了怎么办? → 扩消费者实例、批量消费、查消费逻辑耗时(通常是下游 DB 慢);紧急时建临时队列分流 追问3:怎么保证事务与发消息的原子性? → 同一数据库事务先写本地消息表 → 事务提交 → 轮询/事务日志(tail)发 MQ → 成功后标记
187. 延迟队列:订单超时自动取消?
概念 RabbitMQ 原生不支持延迟;三种实现:死信队列 TTL(过期转投,有队头阻塞缺陷)、延迟插件(x-delayed-message,推荐)、或应用侧轮询(ZSet/DB 扫描)。
典型场景 订单 30 分钟未支付自动取消;预约提醒(提前 1 小时推送);失败重试的分级退避。
解决方案 三步递进:TTL+DLX 方案与缺陷 → 延迟插件 → 精度要求高的替代。
第一步:TTL+死信——理解队头阻塞
拓扑: order.delay.queue(TTL 30min, x-dead-letter-exchange=order.exchange)
→ 消息过期后转投 order.exchange → order.cancel.queue 被消费
缺陷: 队列只检查队头消息 —— 30min 消息后面排一条 5min 消息, 5min 的要等 30min 的出队才轮到
(不同延迟需分级队列: delay.5m / delay.30m / delay.2h 各自一条)
第二步:延迟插件——任意延迟一条搞定
# 文件: mq-delay-plugin.py
# 安装 rabbitmq_delayed_message_exchange 插件
channel.exchange_declare(
exchange="delay.exchange",
exchange_type="x-delayed-message",
arguments={"x-delayed-type": "direct"},
)
channel.basic_publish(
exchange="delay.exchange",
routing_key="order.cancel",
body=json.dumps({"order_id": 123}),
properties=pika.BasicProperties(
headers={"x-delay": 30 * 60 * 1000}, # 毫秒: 每条消息自带延迟
delivery_mode=2,
),
)
# 消费端正常订阅 order.cancel 队列; 插件把消息暂存 Mnesia 表, 到点投递
第三步:高精度/海量延迟——别硬靠 MQ
海量(百万级)延迟任务: Redis ZSet(score=到期时间戳)轮询, 或时间轮(Netty HashedWheelTimer 思想)
精度要求秒级以内: MQ 延迟插件的精度依赖 broker 负载, 不保证毫秒
组合拳: MQ 延迟插件管业务级延迟(分钟), Redis ZSet 管高频短延迟(秒级)
总结:延迟三方案——TTL+DLX(队头阻塞,需分级)、延迟插件(推荐)、Redis ZSet/时间轮(高精度海量);按精度与规模选。
追问1:延迟消息的持久化? → 插件的消息存 Mnesia(随节点持久化),节点故障消息保留;集群下节点挂了该节点延迟消息待节点恢复才投递 追问2:取消订单和用户支付并发怎么办? → 取消前查支付状态(当前读),或用分布式锁按订单粒度互斥;最终以支付回调为准 追问3:延迟消息堆积? → 插件把延迟消息全存内存/Mnesia,百万级注意节点内存;超大场景转 Redis ZSet 分页扫描
188. 消费端设计:幂等、顺序与并发?
概念 消费端三件事:幂等(重复消息不产生副作用)、顺序(同 key 消息按序处理)、并发(prefetch 与多消费者吞吐)。
典型场景 网络重发导致同一订单消息到达两次;积分服务乱序(先扣后加变先加后扣);消费速度跟不上生产。
解决方案 三步递进:幂等表 → 顺序保证 → 并发与 prefetch。
第一步:幂等——去重表是标配
# 文件: consumer-idempotent.py
def consume_order_created(msg):
msg_id = msg.headers["message_id"]
with db.transaction():
# 唯一索引兜底: 重复消息插入直接冲突 → 事务回滚 → ack 跳过
inserted = db.execute(
"INSERT IGNORE INTO consumed_messages (msg_id, consumed_at) VALUES (%s, NOW())",
(msg_id,),
)
if inserted == 0:
return # 已处理过, 幂等跳过
award_points(msg.payload["user_id"]) # 真正的业务逻辑
第二步:顺序——按业务 key 路由到固定队列
错误做法: 单队列多消费者 → 并发乱序
正确做法: 按业务 key 分路由(order:{user_id} 哈希到 10 个队列之一), 每队列单消费者串行
→ 同一用户的操作有序, 不同用户并行(局部有序, 全局并行)
Kafka 对应: 按 partition key 路由, 分区内有序
第三步:并发与 prefetch——吞吐调节阀
prefetch = broker 在收到 ack 前最多推给消费者的消息数
- prefetch 过小: 消费者大部分时间在等消息, 吞吐低
- prefetch 过大: 消费者挂掉时大量未 ack 消息重回队列; 内存占用高
- 经验: 处理耗时均匀的任务 prefetch=10-30; 耗时差异大的(如调 LLM)设小(1-5)防"饿死邻居"
吞吐优化优先级: 加消费者实例 > 优化单条处理耗时 > 调 prefetch
总结:消费端三支柱——去重表幂等、业务 key 分队列保局部有序、prefetch 调节吞吐;顺序与并发是权衡(单队列单消费保序,多队列并行提吞吐)。
追问1:幂等的 Redis 方案? → SETNX msg_id 过期 10min,快但 Redis 宕机有窗口;DB 唯一索引最稳,可 Redis+DB 双层 追问2:消费失败重试次数耗尽? → 进死信队列 + 告警;人工修复后重新投递或手动补偿 追问3:一条消息处理 10 分钟,怎么防超时? → 拆小任务;或消费侧定期 heartbeat(Amqqp basic_ack 前需确认连接未超时 heartbeat)
189. RabbitMQ 集群与镜像队列?
概念 RabbitMQ 集群共享元数据(交换机/绑定)但队列内容默认只在创建节点;镜像队列(quorum queue 3.8+ 推荐)把队列副本复制到多节点,节点故障自动切换。
典型场景 单节点 RabbitMQ 挂了消息全丢;业务要求消息服务高可用;节点维护需不中断。
解决方案 三步递进:集群模式 → quorum queue → 客户端重连。
第一步:集群与经典镜像的演进
经典镜像队列(ha-mode=all): 已不推荐 —— 复制效率低、故障切换可能丢消息
Quorum Queue(3.8+): Raft 协议副本(默认 3 副本多数派写入), 无脑裂, 官方推荐
x-queue-type: quorum
特点: 更低的吞吐上限(多数派确认), 换取强可靠 —— 消息可靠性优先场景必选
第二步:quorum queue 声明
# 文件: mq-quorum.py
channel.queue_declare(
queue="order_critical",
arguments={
"x-queue-type": "quorum", # quorum 队列
"x-quorum-initial-group-size": 3, # 3 副本
},
durable=True,
)
第三步:客户端重连——生产必备
# 文件: mq-reconnect.py
import pika
def get_connection():
while True:
try:
conn = pika.BlockingConnection(pika.ConnectionParameters(
host="node1", heartbeat=30, # 心跳检测死连接
connection_attempts=3, retry_delay=2,
))
return conn
except pika.exceptions.AMQPConnectionError:
time.sleep(2) # 指数退避后重试下一个节点
# 或用 kombu(带重连)/aio-pika(asyncio)封装; 心跳防 NAT/防火墙掐空闲连接
总结:集群共享元数据但队列内容按副本策略;quorum queue(Raft 多数派)替代经典镜像;客户端心跳+重连是生产标配。
追问1:quorum queue 和 mirror 的迁移? → 新队列直接声明 quorum;存量 mirror 队列排空消费后重建为 quorum 追问2:消息优先级队列? → x-max-priority 参数,高优先级消息先投递;quorum queue 也支持 追问3:RabbitMQ 管理端口? → 5672(AMQP)/15672(管理 UI)/5552(Streams);监控队列深度与消费者数
第二批完(100–199):Python 15、FastAPI 15、Python 后端进阶 10、MySQL 15、Redis 10、RabbitMQ/Kafka 7、Elasticsearch 8,共 80 题。NestJS 20 题与 LangChain/LangGraph/Agent/RAG 10 题已移至第三批文件。
第二批完(100–199):Python 15、FastAPI 15、Python 后端进阶 10、MySQL 15、Redis 10、RabbitMQ/Kafka 7、Elasticsearch 8,共 80 题。NestJS 20 题与 LangChain/LangGraph/Agent/RAG 10 题已移至第三批文件。
七、Elasticsearch(190–199)
本章 10 题:倒排索引与分词、search_after 深分页、bool 查询与相关性、写入近实时(refresh/translog/bulk)、集群分片与脑裂、MySQL 同步管道、聚合统计、kNN 向量与混合检索、mapping 字段设计。
190. 倒排索引与分词:ES 为什么搜索快?
概念 正排:文档→词;倒排:词→文档列表( postings)。写入时 Analyzer 分词(text→terms),查询按 term 直接定位 posting list 求交集/并集。BM25 打分排序。
典型场景 全文检索需求、理解”为什么 LIKE ‘%x%’ 走不了索引而 ES 能”、设计 mapping 前的分词决策。
解决方案 三步递进:倒排索引结构 → 分词器与 mapping → 中文场景的 IK 分词。
第一步:倒排索引的结构
文档1: "球状闪电是一种雷电现象"
文档2: "雷电多产生于雷雨天气"
分词后倒排:
雷电 → [doc1, doc2]
球状闪电 → [doc1]
天气 → [doc2]
查询 "雷电": 直接取出 [doc1, doc2] —— 无需扫全部文档(O(1) 定位 + BM25 排序)
对比 MySQL LIKE '%雷电%': 全表逐行扫 + 无索引可用
第二步:分词器与 mapping——检索质量的源头
// 文件: mapping.json
{
"mappings": {
"properties": {
"title": {
"type": "text", // 全文检索字段: 会分词
"analyzer": "ik_max_word", // 写入时细粒度分词
"search_analyzer": "ik_smart" // 查询时粗粒度(减少误召回)
},
"title.keyword": { "type": "keyword" }, // 精确匹配/排序/聚合用不分词子字段
"content": { "type": "text", "analyzer": "ik_max_word" },
"author_id": { "type": "keyword" } // ID 类用 keyword
}
}
}
// 设计原则: 检索字段 text + 分词器; 过滤/聚合字段 keyword; 数字/日期用对应类型
第三步:中文分词——IK 的两种粒度
ik_max_word: 最细粒度切分("球状闪电" → 球状/闪电/球状闪电) —— 写入用, 召回优先
ik_smart: 粗粒度切分("球状闪电" → 球状闪电) —— 查询用, 精度优先
自定义词库: 领域名词(如"RAG"“LangChain")加入 ik 的 main.dic 扩展词典
效果: 不分词的中文默认按单字切, 检索质量极差 —— 中文场景 IK 是必配
总结:倒排索引(词→文档列表)是全文检索快的本质;mapping 的 text/keyword 之分与中文 IK 分词粒度决定检索质量;写入细粒度、查询粗粒度是通用搭配。
追问1:BM25 打分原理? → TF(词频,有饱和度)+ IDF(逆文档频率,稀有词权重大)+ 文档长度归一化 追问2:text 字段能排序/聚合吗? → 不能(分词后无意义),需要排序/聚合走 keyword 子字段 追问3:更新的代价? → 倒排不可变,更新=删除标记+重新索引;频繁更新的字段不适合进 ES
191. 深分页与 search_after?
概念 ES 默认 from+size 限制 10000(协调节点要归并 from+size 份结果,深分页代价爆炸)。深翻页用 search_after(游标,基于排序值)或 scroll(快照导出用,已建议换 PIT+search_after)。
典型场景 检索结果翻页翻到后面卡死;全量导出到 CSV 喂给向量库;分页报 Result window is too large。
解决方案 三步递进:from+size 的原理性缺陷 → search_after 游标 → 全量导出方案。
第一步:from+size 为什么深翻页爆炸
from=10000, size=10 → 协调节点向每个分片要 10010 条 → 合并排序 50010 条(3 分片) → 取 10 条
翻到越深, 每个分片要的越多, 内存与 CPU 随页深线性增长 → 系统限制 10000 保护自己
第二步:search_after——游标翻页
// 文件: search-after.json
// 第一页:
POST /docs/_search
{ "size": 20, "sort": [{ "created_at": "desc" }, { "_id": "asc" }],
"query": { "match": { "content": "球状闪电" } } }
// 下一页: 携带上一页最后一条的 sort 值
{ "size": 20,
"sort": [{ "created_at": "desc" }, { "_id": "asc" }],
"search_after": ["2026-10-01T09:00:00", "doc_abc"],
"query": { "match": { "content": "球状闪电" } } }
// 排序必须含唯一值字段(_id)保证游标确定性; 复杂度与页深无关
第三步:全量导出——PIT + search_after
// 文件: pit-export.json
POST /docs/_pit?keep_alive=5m // 打开 point in time(数据快照视图)
// 之后每次 search 带上 pit.id 与上一页 sort 值, 直到结果为空
// 对比 scroll: PIT+search_after 是官方推荐的现代方案(scroll 已不推荐新用)
总结:from+size 只适合浅分页;深翻页用 search_after(携带排序游标,复杂度恒定);全量导出用 PIT+search_after,scroll 是遗留方案。
追问1:排序为什么要加 _id? → created_at 可能相同,游标不唯一会导致丢数据/重复数据 追问2:能放宽 10000 限制吗? → 能(index.max_result_window)但强烈不建议——协调节点内存会爆,本质问题没解决 追问3:总数怎么算? → track_total_hits: true 精确(慢)/false 显示 10000+(快);大结果集展示”约 N 条”
192. 查询 DSL:bool 查询与相关性调优?
概念 bool 查询组合 must(AND,计分)/filter(AND,不计分可缓存)/should(OR,加分)/must_not(排除);相关性默认 BM25,可通过 boost/字段权重调整。
典型场景 多条件筛选(状态+时间+关键词);搜索结果排序”最相关的在前”;filter 与 must 的性能困惑。
解决方案 三步递进:bool 组合模板 → filter 与 must 的性能差异 → 相关性调优手段。
第一步:bool 组合模板——搜索页的标准写法
// 文件: bool-template.json
POST /docs/_search
{
"query": {
"bool": {
"must": [
{ "match": { "content": "球状闪电" } } // 全文检索, 参与打分
],
"filter": [ // 过滤条件, 不打分(可缓存!)
{ "term": { "status": "published" } },
{ "range": { "created_at": { "gte": "2026-01-01" } } },
{ "term": { "author_id": "u1001" } }
],
"should": [
{ "match": { "title": { "query": "球状闪电", "boost": 3 } } } // 标题命中加权
]
}
},
"highlight": { "fields": { "content": {} } } // 高亮片段
}
第二步:filter 与 must 的性能差异
must(match): 计算相关性得分 → 每条文档都要算分, 不可缓存
filter(term/range): 只过滤不算分 → 结果可被位集缓存(filter cache), 多次查询复用
规则: 纯过滤条件(状态/时间/ID)一律放 filter; 只有"影响排序的文本匹配"放 must
效果: 筛选型页面的查询从数百 ms 降到几十 ms
第三步:相关性调优——让”对的”排前面
1. 字段加权: title boost 3 > content boost 1(标题命中更相关)
2. 新鲜度: 加 should range(created_at gte now-30d) boost 2(新内容加分)
3. 业务加权: function_score 按 likes/view_count 调分
4. 评测: 真实查询集 + 人工标注 → NDCG/MRR 指标验证调优效果(别凭感觉)
总结:bool 是查询的骨架——must 管相关性、filter 管过滤(可缓存)、should 管加权;相关性调优用字段加权+新鲜度+业务分,用评测集验证。
追问1:match 和 term 的区别? → match 会分词后匹配(检索 text 字段);term 精确匹配不分词(查 keyword 字段) 追问2:match_phrase 干什么? → 短语匹配:词序与位置一致才命中(“球状 闪电”≠“闪电球状”),防拆词误召回 追问3:minimum_should_match? → should 子句至少命中几个(如 3 个词至少命中 2 个),平衡召回与精度
基础 5 题(数据结构/缓存三问/一致性/持久化/高可用)接深入 5 题(淘汰策略/热点大 Key/Stream/Lua/pipeline)。
基础 5 题(数据结构/缓存三问/一致性/持久化/高可用)接深入 5 题(淘汰/热点大 Key/Stream/Lua/pipeline)。
基础 5 题(数据结构/缓存三问/一致性/持久化/高可用)接深入 5 题(淘汰策略/热点大 Key/Stream/Lua/pipeline)。
193. 写入与近实时:refresh、translog 与 bulk?
概念 ES 写入先写内存 buffer+translog(防丢),默认每 1s refresh 生成新 segment 使数据可搜(近实时,NRT);bulk 批量写入显著优于单条;段(immutable)靠 merge 合并。
典型场景 RAG 文档批量入库速度慢;写入后立刻搜不到;磁盘 IO 高(CP 100%)。
解决方案 三步递进:写入链路 → bulk 批量实践 → refresh/merge 调优。
第一步:写入链路——理解”近实时”
写入 → 内存 buffer + translog(顺序写, 防丢)
→ 默认 1s refresh: buffer 生成新 segment → 可被搜索(这就是"1 秒后才搜到"的原因)
→ translog 按策略 fsync(默认 request? 5.0+ 为每 5s 或 512MB)
→ 后台 merge: 小段合并成大段(段不可变, 删除只是标记)
要"写完立刻可搜": 手动 POST /index/_refresh(高频调用伤性能)
第二步:bulk 批量写入
# 文件: es-bulk.py
from elasticsearch import Elasticsearch, helpers
es = Elasticsearch("http://localhost:9200")
def gen_actions(docs):
for d in docs:
yield {"_index": "docs", "_id": d["id"], "_source": d} # _id 保证幂等(重复导入覆盖)
helpers.bulk(es, gen_actions(docs), chunk_size=500) # 500 条一批
# 失败条目在返回值 errors 里逐条处理 —— bulk 是部分成功的
第三步:写入密集场景调优
1. refresh_interval 调大: 写入期 "refresh_interval": "30s"(导入完改回 1s)
2. 副本先置 0: number_of_replicas: 0(导入完恢复 1)—— 副本是写入放大
3. bulk chunk_size: 5-15MB 一批, 并发 2-4 个 bulk 线程
4. translog: 导入期 durability: "async"(完成改回 request)
导入完成后恢复全部默认 —— 这些是"导入窗口"的临时参数
总结:写入=buffer+translog+1s refresh(近实时);批量入库用 bulk+gen 动作;导入窗口临时调大 refresh/关副本,导完恢复。
追问1:translog 什么时候清? → fsync 后保留(用于恢复),merge flush 时截断;按 512MB 或 5s 策略滚动 追问2:segment 是什么? → Lucene 的最小检索单元(不可变);太多小段拖慢搜索,后台 merge 合并 追问3:删除的文档什么时候真正消失? → delete 只打标记,segment merge 物理清理;磁盘空间在 merge 后才释放
194. ES 集群与分片:容量规划与脑裂?
概念 索引按主分片(shard,数据与检索的并行单位)分布到数据节点,每个主分片有副本(replica)容灾。分片数创建时定死(不可改,只能 reindex);集群健康 green/yellow/red。
典型场景 新建索引规划分片;节点宕机后集群 yellow;分片过大或过小的性能问题。
解决方案 三步递进:分片规划公式 → 集群健康状态 → 脑裂防护。
第一步:分片规划公式
单个分片建议 10-50GB(经验值):
- 太小: 分片数多 → 每查询扇出大, 元数据开销大
- 太大: 单分片查询慢、迁移/恢复时间长
例: 数据 200GB → 主分片 = 200/30 ≈ 7 → 取 6(便于节点均匀分配)
副本数: 1(可用性+读扩展); 写入密集导入期临时 0
分片数创建后不可改! 改只能 reindex 到新索引(别名切换零停机)
第二步:集群健康三色
green: 所有主分片+副本正常
yellow: 主分片正常, 有副本未分配(单节点建了副本数 1 的索引 → 永远 yellow, 正常现象)
red: 有主分片丢失 → 数据不可用, 立即处理
排查: GET _cluster/health → GET _cat/shards?v 查未分配分片原因(allocation explain)
第三步:脑裂防护——quorum
旧版: discovery.zen.minimum_master_nodes = 可选主节点数/2 + 1(防两个主)
7.x+: 自动维护 quorum(基于投票配置), 无需手工设置 —— 升级 7.x+ 后此问题大幅简化
节点角色: master-eligible / data / ingest 分离, 大集群建议专用 master(3 台小规格)
总结:分片按 10-50GB/片规划且创建后不可改;green/yellow/red 对应”全好/缺副本/丢主分片”;7.x+ 自动 quorum 防脑裂,角色分离是大规模最佳实践。
追问1:reindex 的流程? → 新索引(新分片数)→ _reindex 拷数据 → 别名原子切换 → 删旧索引;期间写入要双写 追问2:索引别名是什么? → 指向索引的可变名称,应用始终用别名查询,reindex 后原子切换指向——零停机变更的标准姿势 追问3:ES 和向量数据库的关系? → ES 8 有 dense_vector+kNN(小规模向量可用);大规模/纯向量场景 Qdrant/Milvus 更专业
195. 数据同步:MySQL 到 ES 的管道?
概念 binlog→Canal/Debezium→MQ→消费者写 ES,是标准化同步管道;双写(应用同时写 MySQL 和 ES)有一致性风险,不推荐为首选。同步延迟用 MQ 与重试控制,一致性核对用对账任务。
典型场景 MySQL 是事实源、ES 负责检索(RAG 文档库/商品搜索);改了 MySQL 数据 ES 里搜不到。
解决方案 三步递进:管道架构 → 全量+增量初始化 → 一致性对账。
第一步:管道架构
MySQL(binlog) → Canal/Debezium(CDC) → Kafka → 消费者(transform) → Elasticsearch
优点: 对业务零侵入(不用改代码双写)、不丢(CDC 有位点)、解耦(多下游订阅同一 topic)
写入 ES 用 bulk + _id=业务主键(幂等: 同一条数据重复同步只是覆盖)
删除事件 → ES delete(带 is_deleted 软删字段的要在 transform 里过滤)
第二步:全量+增量初始化
1. 记录 binlog 位点(或 CDC 的 snapshot 模式先全量)
2. 全量: 分批 SELECT(id 游标)→ bulk 写 ES
3. 增量: CDC 从位点继续 → 实时同步
4. 全量期间的增量已由 CDC 记录, 追平即无缝衔接
简版(数据量小): 定时任务全量重建(每夜)——接受 T+1 延迟
第三步:一致性对账——同步管道的质检
# 文件: sync-reconcile.py
# 定时抽样对账: 抽 1000 条 MySQL 记录, 与 ES 对比关键字段
def reconcile(sample_ids):
mysql_rows = db.fetch(sample_ids)
es_docs = es.mget(index="docs", body={"ids": sample_ids})
for row in mysql_rows:
es_doc = es_docs.get(row["id"])
if es_doc is None or es_doc["updated_at"] != row["updated_at"]:
es.index(index="docs", id=row["id"], document=row) # 修复
stats["fixed"] += 1
# 对账发现系统性缺失 → 触发该范围的全量重建(报警+自动修复)
总结:MySQL→ES 标准管道=CDC(Canal/Debezium)+MQ+bulk 消费;初始化”全量+增量位点衔接”;对账任务兜底一致性。
追问1:为什么不用应用双写? → 双写无法原子(一边失败即不一致),且侵入业务代码;CDC 管道对业务零侵入且可靠 追问2:同步延迟怎么监控? → 对比 MySQL updated_at 与 ES 同字段时间差(抽样);CDC 位点滞后(MQ 堆积)监控 追问3:ES 写入失败怎么办? → 消费端重试(见 170 手动提交);多次失败进死信;对账兜底修复
196. ES 的聚合:统计与分组?
概念 聚合(aggregation)做统计分组:terms(分组)/range(区间)/avg/max/metric;嵌套聚合实现”分组后再分组/再统计”;聚合在 keyword/数值/日期字段上进行。
典型场景 检索页左侧的筛选项(各分类的文档数)、运营报表、日志分析(Histogram)。
解决方案 三步递进:terms 聚合(分组计数) → 嵌套聚合 → date_histogram 时间序列。
第一步:terms 聚合——筛选项计数
// 文件: terms-agg.json
POST /docs/_search
{ "size": 0, // 不要文档只要统计
"query": { "match": { "content": "AI" } },
"aggs": {
"by_category": { "terms": { "field": "category.keyword", "size": 10 } }
}
}
// 返回: 各分类的命中数 → 前端渲染筛选侧栏(点分类=再加 filter)
第二步:嵌套聚合——分组内再统计
// 文件: nested-agg.json
{ "size": 0,
"aggs": {
"by_author": {
"terms": { "field": "author_id", "size": 20 },
"aggs": {
"avg_likes": { "avg": { "field": "likes" } }, // 组内平均
"by_month": { // 组内再按月分
"date_histogram": { "field": "created_at", "calendar_interval": "month" }
}
}
}
}
}
第三步:date_histogram——时间序列
// 文件: date-histogram.json
{ "size": 0,
"query": { "range": { "created_at": { "gte": "now-30d" } } },
"aggs": {
"daily": {
"date_histogram": { "field": "created_at", "calendar_interval": "day", "min_doc_count": 0 },
"aggs": { "total_tokens": { "sum": { "field": "tokens" } } }
}
}
}
// 输出按天的文档数与 token 总量 → 折线图数据源(min_doc_count=0 补空桶)
总结:聚合三件套 terms(分组)/metric(avg/sum)/date_histogram(时间序列);聚合在 keyword/数值/日期字段上;size:0 只要统计不要文档。
追问1:聚合精度问题? → terms 默认按分片 top-N 合并(shard_size),多分片下计数是近似;doc_count 误差可用 shard_size 调 追问2:聚合内存爆了怎么办? → 减 size、避免高基数字段聚合(百万级唯一值)、用 composite aggregation 分页聚合 追问3:ES 做报表和数仓的区别? → ES 适合”近实时+交互式钻取”;大规模离线分析用 ClickHouse/数仓
197. ES 与向量检索:kNN 与混合检索?
概念 ES 8 的 dense_vector 字段 + kNN 搜索支持向量检索;结合 BM25 的 BM25+向量双路查询(RRF 融合)即混合检索——一套基础设施同时覆盖关键词与语义检索。
典型场景 RAG 场景已有 ES 不想再引入 Qdrant;既要精确关键词(报错码)又要语义泛化的混合检索。
解决方案 三步递进:dense_vector mapping → kNN 查询 → RRF 混合检索。
第一步:mapping 向量字段
// 文件: vector-mapping.json
{
"mappings": {
"properties": {
"content": { "type": "text", "analyzer": "ik_max_word" },
"embedding": {
"type": "dense_vector",
"dims": 1024,
"index": true, // 开启 kNN 索引(HNSW)
"similarity": "cosine"
}
}
}
}
第二步:kNN 查询
// 文件: knn-query.json
POST /docs/_search
{
"knn": {
"field": "embedding",
"query_vector": [0.12, -0.3, "..."],
"k": 10, // 返回近邻数
"num_candidates": 100, // 候选池(越大越准越慢)
"filter": { "term": { "status": "published" } } // 先过滤后向量检索(减少候选)
}
}
第三步:RRF 混合检索——BM25 与向量双路
// 文件: hybrid-rrf.json
POST /docs/_search
{ "retriever": {
"rrf": { // Reciprocal Rank Fusion: 按排名融合两路结果
"retrievers": [
{ "standard": { "query": { "match": { "content": "球状闪电" } } } }, // BM25 路
{ "knn": { "field": "embedding", "query_vector": [...], "k": 10 } } // 向量路
],
"rank_window_size": 50
}
}
}
// 关键词精确(报错码/专有名词)与语义泛化(同义改写)两路互补 —— RAG 检索质量的标准打法
总结:ES 8 dense_vector+kNN 让”已有 ES 的团队”直接做向量与混合检索(RRF 融合);超大规模纯向量场景仍选专业向量库。
追问1:HNSW 是什么? · 分层可导航小世界图——近似最近邻(ANN)索引,牺牲少量召回换数量级速度 追问2:embedding 模型换了怎么办? → 向量空间不兼容,必须全量重算 embedding(成本高)——选型要慎重,记录模型版本 追问3:RRF 的公式? → score = Σ 1/(k + rank),k 通常 60——只看排名不看分数,规避两路分值不可比的问题
第二批完(100–199):Python 15、FastAPI 15、Python 后端进阶 10、MySQL 15(基础 10 + 深入 5)、Redis 10(基础 5 + 深入 5)、RabbitMQ/Kafka 7、Elasticsearch 8,共 80 题。NestJS 20 题与 LangChain/LangGraph/Agent/RAG 10 题已移至第三批文件。
第二批完(100–199):Python 15、FastAPI 15、Python 后端进阶 10、MySQL 15(基础 10 + 深入 5)、Redis 10(基础 5 + 深入 5)、RabbitMQ/Kafka 7、Elasticsearch 8,共 80 题。NestJS 20 题与 LangChain/LangGraph/Agent/RAG 10 题已移至第三批文件。
RabbitMQ 五题 + Kafka 两题:可靠性三段防线、延迟队列、消费端幂等、集群、分区模型与死信。
RabbitMQ 五题 + Kafka 两题。
RabbitMQ 五题 + Kafka 两题:可靠性、延迟队列、消费端幂等、集群、分区模型与死信。
198. ES 写入性能调优实战?
概念 写入性能四杠杆:bulk 批量、refresh 间隔、副本数、translog 策略。导入期临时调优(接受短暂风险)与稳态配置要区分;segment merge 是后台开销的另一来源。
典型场景 百万文档初始化导入;持续高吞吐写入(日志);导入后搜索变慢。
解决方案 三步递进:导入期配置 → 稳态调优 → segment 与 merge。
第一步:导入期配置(临时,导完恢复)
# 文件: es-import-tuning.sh
# 1. refresh 拉长(默认 1s → 30s,减少 segment 生成)
curl -X PUT localhost:9200/myidx/_settings -H 'Content-Type: application/json' -d \
'{"index.refresh_interval": "30s"}'
# 2. 副本置 0(导入完恢复 1)
curl -X PUT localhost:9200/myidx/_settings -d '{"index.number_of_replicas": 0}'
# 3. translog 异步(导入期接受)
curl -X PUT localhost:9200/myidx/_settings -d '{"index.translog.durability": "async"}'
# 导完后: 全部恢复默认 + 手动 _forcemerge?max_num_segments=1(见第三步)
第二步:稳态调优
bulk 参数: chunk 5-15MB/批(不是越大越好, 响应内存与超时要考虑)+ 并发 2-4 个 bulk 线程
写入端: _id 由 ES 自动生成(业务 _id 会查重, 写入慢 20%+; 幂等需求除外)
mapping: 不检索的字段 index:false / 关闭 _source 不需要的字段(别乱关, 更新要靠它)
分片: 写入热点分散到多分片(主分片数 = 写入并行度)
第三步:segment 与 merge
每个 refresh 生成一个 segment(不可变) → 小段过多拖慢搜索与内存
后台 merge 自动合并; 干预手段:
_forcemerge?max_num_segments=1 # 强制合并(导入完成后跑一次, IO 重, 低峰执行)
index.merge.scheduler 控制 merge 线程资源
监控: _cat/segments 看段数量; "small segments 多 + 搜索慢" 是合并信号
删除的文档: 标记删除, merge 时物理清理(磁盘在 merge 后才释放)
总结:导入三件套(refresh 30s/副本 0/translog async)+导完恢复与 forcemerge;稳态靠 bulk 尺寸/自动 _id/字段级 mapping;segment 数量是搜索与写入的共同敌人。
追问1:bulk 的响应怎么处理部分失败? → items 数组逐条看 status,失败的收集重发(bulk 是部分成功的) 追问2:_id 自动生成为什么快? → 免去”同 _id 是否存在”的查重(布隆过滤前的定位开销) 追问3:forcemerge 什么时候不能跑? → 持续写入的索引(合并期间又产生新段);只适合导入完成的静态索引
199. ES 的字段类型与 mapping 设计?
概念 mapping = ES 的表结构:text(分词全文检索)/keyword(精确值,过滤排序聚合)/数值/日期/对象与嵌套(nested vs object)/alias 字段。mapping 一旦写入不能改类型(需 reindex),设计期要想清楚。
典型场景 新索引设计;text 上聚合报错(fi eld data);对象数组扁平化导致关联丢失。
解决方案 三步递进:核心类型选型 → object 与 nested → mapping 变更。
第一步:核心类型选型
// 文件: mapping-design.json
{
"mappings": {
"properties": {
"title": { "type": "text", "analyzer": "ik_max_word",
"fields": { "keyword": { "type": "keyword" } } },
"status": { "type": "keyword" },
"views": { "type": "long", "index": false },
"price": { "type": "scaled_float", "scaling_factor": 100 },
"created_at": { "type": "date", "format": "yyyy-MM-dd HH:mm:ss||epoch_millis" },
"suggest": { "type": "completion" },
"embedding": { "type": "dense_vector", "dims": 1024 }
}
}
}
// 原则: 检索 text(带 keyword 子字段兼顾聚合); 过滤/聚合 keyword; 纯存储 index:false
第二步:object 与 nested
// 文件: mapping-nested.json
// object 类型: 数组对象被扁平化 —— 关联丢失!
// {"users":[{"name":"A","age":20},{"name":"B","age":30}]}
// object 存储: name=["A","B"], age=[20,30] → 查 name=A AND age=30 会误命中!
"users": { "type": "nested",
"properties": { "name": {"type":"keyword"}, "age": {"type":"integer"} } }
// nested: 每个对象独立 Lucene 文档, 保住关联
// 查询用 nested query; 代价: 写入膨胀 + 查询稍慢 —— 按需用
第三步:mapping 变更与 reindex
不能变: 字段类型(text → keyword 不行)、分词器(已有数据不会重新分词)
能变: 新增字段 / 已有字段的 ignore_above 等映射参数
大改 = reindex: 新索引(新 mapping)→ POST _reindex → 别名切换(零停机, 见 176 追问)
预防: 上线前 mapping 评审 + 动态 mapping 关闭(strict 模式, 字段写错显式报错)
总结:类型选型口诀——检索 text、过滤聚合 keyword、不检索关 index;数组对象要关联用 nested;类型不可改,大改靠 reindex+别名切换,设计期评审是根本。
追问1:dynamic strict 是什么? → mapping 外的新字段直接报错拒写(默认 dynamic true 会自动加字段)——防字段污染 追问2:多字段(fields)的代价? → keyword 子字段多占一份索引空间——只为确实要聚合的字段配 追问3:_source 关掉省多少? → 省磁盘(不存原文),但失去 update/reindex/highlight 能力——一般不关
第二批完(100–199):Python 15、FastAPI 15、Python 后端进阶 15、MySQL 20、Redis 15、RabbitMQ/Kafka 12、Elasticsearch 10,共 100 题(补充 20 题:MySQL 5/Python 进阶 5/Redis 5/MQ 3/ES 2)。NestJS 20 题与 LangChain/LangGraph/Agent/RAG 10 题已移至第三批文件。
第二批完(100–199):Python 15、FastAPI 15、Python 后端进阶 15、MySQL 20、Redis 15、RabbitMQ/Kafka 10、Elasticsearch 10,共 100 题。2026-10-17 重排:145–199 按主题归位(MySQL 内核 10 题并入、Redis 15、MQ 10、ES 10),题号重编。