跳转到主要内容

高阶问题(AI 工程师)

Python 与 FastAPI 与后端 100 题

AI 工程师面试题库 · 第二批(题号 101–200):Python 语言核心、FastAPI、Python 后端进阶、MySQL、Redis、RabbitMQ 与消息队列、Elasticsearch。

  • 面试
  • AI 工程师
  • Python

AI 工程师面试题库 · 第二批:Python、FastAPI、MySQL 深入、Redis 深入、RabbitMQ、Elasticsearch


目录

一、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),题号重编。