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

04.4.8.4 连接池事务边界与分页优化

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.4 Rust / 04.4.8 数据访问

04.4.8.4-001 数据库访问为什么需要连接池?

一句话结论

建立 TCP 连接与数据库认证成本高、耗时不可忽略;连接池复用物理连接,避免每次请求重新握手认证,同时把并发连接数控制在数据库可承受范围内。

概念解释

数据库连接包含网络握手、认证、会话状态初始化等步骤,逐条新建在高并发下既慢又会耗尽数据库连接上限。池化把「创建—借出—归还—复用」闭环管理:空闲连接保存在队列,任务借出使用,用完归还而不是关闭。池同时承担容量控制、健康检查与失效重建。没有池化时,每个请求一条新连接,数据库侧连接数随流量线性膨胀。

原理流程

  1. 应用启动按初始容量建立一批连接。
  2. 请求到达从池借出空闲连接。
  3. 使用完毕归还入队,不关闭。
  4. 连接损坏或超期由池销毁并补建。

代码或图示

无池:请求 → 新建连接(TCP + 认证 + 会话)→ 使用 → 关闭
有池:请求 → 借出空闲连接 → 使用 → 归还复用
     池负责:容量上限、空闲回收、健康检查、坏连接重建

常见误区

  • 以为一次查询很快就不需要池:握手认证在每次新建连接时重复发生。
  • 池开得越大越好:数据库 max_connections 有限,过量连接反而拖慢数据库。

追问

  • 连接池放在应用进程内还是独立中间件?答:两者都有,应用内池(sqlx Pool、deadpool、bb8)最常见;独立连接代理如 PgBouncer 用于多实例汇聚,见后续题目。
  • 池化能替代数据库扩容吗?答:不能,池只是复用与限流,承载能力仍受数据库资源约束。

04.4.8.4-002 sqlx 的 Pool 如何建立与配置?

一句话结论

sqlx::Pool 由 PoolOptions 链式设置最大连接、超时、空闲与生命周期等参数后 connect 建立;Pool 可克隆共享,内部持有连接队列。

概念解释

sqlx 连接池内置在查询库中,配置项集中在 PoolOptions:max_connections、acquire_timeout、idle_timeout、max_lifetime 等。建立后 Pool 句柄克隆到各任务共享,每次查询 acquire 取连接。池按数据库驱动后端工作,不同数据库的池行为一致。具体配置项名称与默认值以 sqlx 当前版本文档为准,不臆造默认数字。

原理流程

  1. 构造 PoolOptions 并设置参数。
  2. connect(url) 初始化池与初始连接。
  3. 句柄克隆放入应用状态。
  4. 查询时获取连接,用完归还。

代码或图示

use sqlx::postgres::PgPoolOptions;

let pool = PgPoolOptions::new()
    .max_connections(10)
    .acquire_timeout(std::time::Duration::from_secs(5))
    .connect("postgres://user:pass@localhost:5432/db")
    .await?;

常见误区

  • 每个请求新建 Pool:池内连接无法复用,等于没用池。
  • 只配最大连接不配超时:连接获取无限等待,故障时堆积。

追问

  • Pool 为什么能克隆共享?答:内部是 Arc 风格的共享队列句柄,连接物理上只有一份,克隆只复制句柄。
  • 待确认点是什么?答:各超时参数默认值与 min_connections 配置项,以 docs.rs/sqlx 当前版本 PoolOptions 文档为准。

04.4.8.4-003 deadpool 的池化原理与 Manager 角色是什么?

一句话结论

deadpool 是通用连接池框架:Manager trait 负责创建、校验与回收单个对象,Pool 管理对象队列与生命周期;数据库专用 crate(如 deadpool-postgres)实现对应 Manager。

概念解释

deadpool 把池化逻辑与具体对象类型解耦:Manager 定义如何新建连接、借出前是否健康检查、归还时能否复用。Pool 负责容量、借出等待、超时与对象销毁。这种设计让同一套池化机制复用在不同后端。运行时集成由 runtime 特性控制。Manager 实现不当会把坏连接放回队列,导致后续任务拿到失效连接。

原理流程

  1. 实现 Manager:create 新建对象,recycle 校验可复用性。
  2. 构造 Pool 并设容量与超时。
  3. 借出时取空闲对象,必要时 recycle 检查。
  4. 归还入队;不可复用则销毁并补建。

代码或图示

deadpool 结构:
  Manager:create / recycle / 后端类型绑定
  Pool:容量、队列、借出等待、超时、关闭
  专用 crate:deadpool-postgres 等实现 PG 后端 Manager

常见误区

  • 跳过 recycle 直接复用:服务端已断开的连接被借出,查询报错。
  • 把 Manager 当 ORM:它只管连接生命周期,不涉及查询映射。

追问

  • deadpool 与 sqlx 内置池重复吗?答:可以二选一;用 sqlx 查询库时常直接用内置 Pool,裸客户端后端常用 deadpool 这类独立池。
  • 待确认点是什么?答:当前版本 Manager trait 方法签名与配置项,以 docs.rs/deadpool 文档为准。

04.4.8.4-004 bb8 的池化模型与 Builder 如何工作?

一句话结论

bb8 是异步通用连接池,通过 Pool::builder(Manager) 配置最大规模与超时,Manager 负责连接创建与健康校验;池在后台维护连接生命周期。

概念解释

bb8 与 deadpool 定位同类:通用池化框架,后端连接由 Manager 适配。Builder 配置 max_size、连接超时、空闲回收等策略。池化过程同样区分借出、复用、销毁路径。bb8 面向异步运行时,连接创建与回收不阻塞工作线程。选型时对比两个池框架的 API 成熟度、维护状态与和所选后端的配套 crate。

原理流程

  1. 实现后端 Manager。
  2. builder(manager).max_size(n).build() 建池。
  3. get() 借出连接,结束归还。
  4. 池后台按策略回收或重建连接。

代码或图示

bb8 结构:
  Manager:连接创建与回收校验
  Pool::builder:max_size / 超时 / 生命周期配置
  get():异步借出,Drop 归还

常见误区

  • 把池对象长期持有而不借出:连接闲置占用上限名额。
  • 以为池会无限新建:max_size 到达后请求进入等待队列。

追问

  • bb8 连接创建失败如何表现?答:借出时按超时与错误策略返回错误,具体错误类型以当前版本为准。
  • 与 deadpool 怎么选?答:按后端配套 crate、团队经验与 API 熟悉度评估,两者核心职责一致。

04.4.8.4-005 sqlx Pool、deadpool、bb8 三者核心差异是什么?

一句话结论

sqlx Pool 是查询库内置池,与驱动和行映射一体;deadpool、bb8 是通用独立池,配合裸客户端或自定义后端使用;差异主要在绑定深度、适用后端与配置抽象。

概念解释

内置池随查询库一起工作,连接类型与驱动绑定,省去额外适配。通用池把连接类型抽象为 Manager,适合 tokio-postgres 这类裸客户端或多后端复用同一池化逻辑。配置能力三者相近:容量、超时、回收、健康检查。工程上不必同时引入两套池;混用会出现两组连接上限与两套监控指标。

原理流程

  1. 已用 sqlx 查询库:优先内置 Pool。
  2. 裸客户端后端:选 deadpool 或 bb8 独立池。
  3. 核对池配置项与后端 Manager 实现。
  4. 统一池指标与超时治理。

代码或图示

对比:
  sqlx Pool   内置,绑定 sqlx 驱动与映射,配置随库
  deadpool    通用 Manager 模型,独立池化框架
  bb8         通用 Builder 模型,独立异步池

常见误区

  • 同一进程同时跑两个池:连接数与监控重复,排错混乱。
  • 把通用池的连接强行交给其他库驱动:类型不匹配。

追问

  • 独立池能配合 sqlx 用吗?答:通常直接用 sqlx 内置池;独立池面向裸驱动,混用价值低且需自行适配。
  • 待确认点是什么?答:三个池当前版本的配置项完整清单,以各自 docs.rs 文档为准。

04.4.8.4-006 连接池大小如何推算?

一句话结论

池大小要结合数据库 max_connections、应用实例数、CPU 核数与查询类型估算:不能盲目调大,目标是让数据库饱和但连接排队不过长。

概念解释

经典经验公式按核数估算连接需求,但真实负载要结合:每实例池上限 × 实例数 ≤ 数据库总连接余量;IO 密集型查询连接等待占比高,计算密集型连接占用 CPU。读多写少与批量任务的连接需求不同。推算方法:先压测观察连接占用、等待队列与数据库负载,再调整上限。预留连接给迁移、运维与其他实例。

原理流程

  1. 查数据库 max_connections 与当前占用。
  2. 按实例数分摊可用连接余量。
  3. 压测单实例连接峰值与等待情况。
  4. 调整池上限并保留运维预留。

代码或图示

推算约束:
  单实例池上限 × 实例数 + 其他客户端占用 ≤ max_connections
  观察指标:连接利用率、获取等待时长、数据库 CPU/IO
  批量任务池与在线请求池可分开设置

常见误区

  • 池大小设成等于数据库最大连接:没有预留,运维与其他实例连不上。
  • 按 CPU 核数直接套公式不压测:混合负载下偏差大。

追问

  • 连接数越多吞吐越高吗?答:不是,超过数据库处理能力后上下文切换与锁竞争加剧,吞吐反而下降。
  • 读写分离时池怎么配?答:读库与写库分别建池,按各自容量与流量配上限。

04.4.8.4-007 acquire_timeout 控制什么?

一句话结论

acquire_timeout 是从池获取连接的最长等待时间;池满且连接未及时归还时,请求在队列等待,超过该超时返回获取错误,避免无限挂起。

概念解释

池上限到达后,新请求进入等待队列排队。获取超时保护任务不被无限阻塞:超时后返回错误,上层可快速失败、重试或降级。超时设置要大于正常连接持有时长,又要小于请求整体超时。过短在峰值时误杀正常请求;过长导致请求堆积、资源占用久。该超时与单条查询语句超时是两层独立配置。

原理流程

  1. 请求尝试从池取连接。
  2. 有空闲立即返回;无空闲进入等待。
  3. 等待计时达到 acquire_timeout 仍未获取则报错。
  4. 上层按错误类型决定重试或降级。

代码或图示

// sqlx 配置示例,方法名以当前版本为准
let pool = PgPoolOptions::new()
    .max_connections(10)
    .acquire_timeout(std::time::Duration::from_secs(3))
    .connect(&url)
    .await?;

常见误区

  • 不设获取超时:池满时任务永久挂起,连接泄漏放大雪崩。
  • 把获取超时当查询超时:拿到连接后的语句执行仍需单独超时控制。

追问

  • 频繁获取超时说明什么?答:连接不够用或连接归还过慢,先排查泄漏与长事务,再考虑扩容池或数据库。
  • 超时后能重试获取吗?答:可以有限次重试,但根因是池容量或归还速度,重试只缓解瞬时峰值。

04.4.8.4-008 idle_timeout 与空闲连接回收有什么作用?

一句话结论

idle_timeout 规定连接空闲多久后被池关闭回收;防止长期空闲连接占用名额,也减少被中间代理或数据库主动断开后留下的坏连接。

概念解释

空闲连接不是越留越好:长时间无流量的连接可能被数据库、防火墙或代理静默断开,下次借出才发现失效。空闲超时让池定期回收闲置连接,降低坏连接比例。设置过短会在流量波动时频繁新建连接,握手成本上升;过长则空闲连接堆积且易被断。空闲超时通常小于数据库与代理的空闲断开阈值。

原理流程

  1. 连接归还后开始空闲计时。
  2. 期间被复用则重置计时。
  3. 超过 idle_timeout 未使用,池关闭该连接。
  4. 需要时按容量新建。

代码或图示

// 配置项名称以当前版本 PoolOptions 文档为准
.idle_timeout(std::time::Duration::from_secs(300))

常见误区

  • 空闲超时设得比代理断连还长:借出时拿到已被代理关闭的连接。
  • 流量低谷频繁建连:空闲过短导致反复握手。

追问

  • 待确认点是什么?答:idle_timeout 的默认值与计时重置行为,以 docs.rs/sqlx 或所选池框架文档为准。
  • 空闲连接健康检查靠什么?答:回收策略配合借出前 recycle 校验,见健康检查题目。

04.4.8.4-009 max_lifetime 与连接最大寿命如何设置?

一句话结论

max_lifetime 限制连接从创建到销毁的总寿命,到期无论是否空闲都被回收重建;用于规避长期连接积累的状态漂移、内存增长与服务端侧老化问题。

概念解释

即使连接一直被复用,长时间存活也可能积累会话状态、临时对象与驱动侧资源。最大寿命让连接定期轮换,保持状态干净。寿命一般设为分钟到小时级,小于数据库侧连接回收策略。注意寿命到期时若连接正在使用,会等当前使用结束再销毁,不强制切断在途事务。设置过短重建频繁,过长失去轮换意义。

原理流程

  1. 连接创建时记录起始时间。
  2. 每次借出/归还检查存活时长。
  3. 达到 max_lifetime 标记为待销毁。
  4. 归还后关闭,池补建新连接。

代码或图示

// 配置项名称以当前版本为准
.max_lifetime(std::time::Duration::from_secs(1800))

常见误区

  • 把 max_lifetime 当空闲超时:一个按总寿命、一个按空闲时长,两者独立。
  • 寿命到期强行断开在途事务:正确实现应等使用结束再销毁。

追问

  • 待确认点是什么?答:到期连接是否等待归还、能否强制关闭,以所选池框架源码与文档为准。
  • 为什么不依赖数据库自动断连?答:主动轮换可预测,避免借出时才遭遇服务端清理。

04.4.8.4-010 连接健康检查(recycle/ping)如何做?

一句话结论

借出或回收前对连接做轻量校验(如 SELECT 1 或后端 ping),确认连接仍可用;坏连接销毁重建,避免把失效连接交给业务任务。

概念解释

网络中断、数据库重启、代理超时清理都会让连接表面在队列里、实际已失效。健康检查在借出前或归还时探测:成功则复用,失败则丢弃补建。检查不能太重,否则放大每次获取成本;一般用最简探测语句。检查时机有借出前、归还时两种策略,不同池框架可配置。健康检查与空闲回收配合,覆盖不同断连场景。

原理流程

  1. 连接待借出或归还。
  2. 执行轻量探测。
  3. 探测通过:标记可用。
  4. 探测失败:销毁连接,按需新建补充。

代码或图示

健康检查策略:
  借出前检查:拿到连接先 ping,失败重建后再给任务
  归还时检查:归还入队前校验,坏连接不入队
  探测语句:最小代价的 SELECT 1 类查询

常见误区

  • 完全不检查:坏连接流出到业务,随机报错难复现。
  • 检查语句过重:每次借出都跑复杂查询,抵消池化收益。

追问

  • 待确认点是什么?答:所选池框架是否支持自定义 recycle 检查与检查时机配置,以 Manager/Builder 文档为准。
  • 检查通过就一定可用吗?答:不绝对,检查到使用之间仍可能断连,语句执行错误仍需处理重连。

04.4.8.4-011 连接泄漏是怎么产生的,如何识别?

一句话结论

连接被借出后未归还(句柄被遗忘、事务未结束、任务提前退出)即为泄漏;表现为池占用持续上涨、最终获取超时,识别靠池指标计数与未归还连接追踪。

概念解释

正常路径连接句柄 Drop 时归还池;泄漏路径包括:句柄存入长生命周期结构、任务被取消后连接未释放、事务一直挂起、连接跨任务错误传递。泄漏连接不会自动回收,池上限被占满。识别指标:size 持续升高而 num_idle 趋零、获取等待增长。部分池框架提供泄漏警告(借出后长时间未归还的日志)。

原理流程

  1. 连接借出,句柄进入业务作用域。
  2. 作用域结束应 Drop 归还;若句柄被长期持有则不归还。
  3. 池内可用连接逐步耗尽。
  4. 新请求排队直至获取超时。

代码或图示

泄漏常见路径:
  - 连接句柄存入全局/长生命周期容器
  - await 被取消后句柄未清理
  - 事务悬挂未提交/回滚
  - 异步任务持有连接后不再归还
识别:池占用只增不减、空闲趋近 0、获取超时增多

常见误区

  • 把数据库慢查询当成泄漏:慢查询是持有时间长,结束会归还;泄漏是永不归还。
  • 泄漏后盲目调大池上限:延缓爆发,根因是未归还路径。

追问

  • 池框架能定位泄漏句柄吗?答:部分实现记录借出位置并在超时未归还时告警,能力以当前版本为准。
  • 临时缓解手段?答:重启实例释放连接,同时必须修复句柄生命周期。

04.4.8.4-012 池满时的等待队列如何工作?

一句话结论

池达到最大连接数后,新请求在队列等待空闲连接归还;队列按先后顺序唤醒,等待时长受 acquire_timeout 约束,超时返回错误。

概念解释

池内部维护等待者队列:无空闲连接且未达上限时新建;达上限后请求挂起等待。连接归还时唤醒队列首位等待者。队列长度与等待时长是容量信号:持续排队说明连接需求超过池容量。排队不会无限增长,超时机制兜底。不同池框架的公平性(FIFO)与唤醒实现以源码为准。

原理流程

  1. 请求获取连接:有空闲则借出。
  2. 无空闲且未满:新建连接。
  3. 已满:入等待队列挂起。
  4. 连接归还唤醒等待者;等待超时则报错。

代码或图示

获取流程:
  空闲连接存在 → 借出
  池未满 → 新建
  池已满 → 入队等待 → 归还唤醒 / 超时失败

常见误区

  • 排队请求也占用数据库连接:不占用,连接在池中,队列只是应用内等待。
  • 忽略队列长度指标:只看连接数看不出排队压力。

追问

  • 队列可以设上限吗?答:部分池实现有等待者限制配置,能力以框架文档为准;获取超时始终是兜底。
  • 排队过长怎么优化?答:先查连接持有时长(慢查询/长事务/泄漏),再评估扩容。

04.4.8.4-013 池监控有哪些关键指标?

一句话结论

核心指标:当前大小、空闲连接数、已借出数、等待队列长度、获取等待时长、关闭状态;通过这些判断池是否耗尽、泄漏或配置过小。

概念解释

池指标把抽象的连接复用可视化:size 是池内总连接,num_idle 空闲,差值为已借出。等待队列与获取超时反映容量缺口。连接泄漏表现为借出数只增不减。池关闭后新获取直接失败。工程上把指标接可观测系统,设告警阈值(空闲过低、等待升高、超时增多)。具体方法名(size/num_idle/closed)以所选池框架版本为准。

原理流程

  1. 定期读取池内计数。
  2. 对比借出/空闲/队列趋势。
  3. 结合获取耗时与错误率。
  4. 异常时定位泄漏、慢查询或容量不足。

代码或图示

池指标清单:
  size        池内连接总数
  num_idle    空闲连接数
  已借出      size - idle
  waiting     等待队列长度
  acquire wait 获取等待时长
  closed      池是否已关闭

常见误区

  • 只监控连接数不看等待:连接未满但排队已经发生。
  • 不区分慢持有与泄漏:两者处置方向不同。

追问

  • 待确认点是什么?答:各池框架暴露的指标方法名与是否提供事件钩子,以当前版本文档为准。
  • 指标接入哪里?答:跟随工程 tracing/metrics 体系,见 04.4.12 可观测性主题。

04.4.8.4-014 连接断线后池如何重建恢复?

一句话结论

池通过健康检查识别坏连接并销毁补建;新连接按创建流程握手认证。应用层监控池关闭与建连错误,必要时触发重连与告警。

概念解释

数据库重启或网络中断后,池内存量连接全部失效。健康检查在借出时逐个探测,坏连接被替换;池在容量不足时自动补建新连接。若整库不可用,新建失败进入错误与重试循环,恢复后自动补回。重建期间在途请求失败,需要上层容错。连接重建不应由业务代码手工维护,池框架负责补建节奏。

原理流程

  1. 故障导致存量连接失效。
  2. 借出探测失败,销毁坏连接。
  3. 池按容量新建连接,失败则重试。
  4. 数据库恢复后连接逐步补齐。

代码或图示

恢复路径:
  坏连接 → recycle 失败 → 销毁
  容量缺口 → 新建连接 → 重试间隔
  整库不可用 → 建连错误等待恢复 → 恢复后补齐

常见误区

  • 断线后手工清池:正确做法是让池按探测结果替换,避免误删健康连接。
  • 不重试新建:数据库恢复后池一直空着。

追问

  • 应用启动时数据库还没起来怎么办?答:连接建立可配重试,或启动健康检查阻塞就绪,避免实例带病接流量。
  • 待确认点是什么?答:池框架新建失败的重试策略与可配置项,以文档为准。

04.4.8.4-015 PgBouncer 在部署中解决什么问题?

一句话结论

PgBouncer 是 PostgreSQL 连接代理,在多个应用实例与数据库之间复用/汇聚连接,缓解数据库连接数压力;应用连接池与代理池可分层配合。

概念解释

PostgreSQL 每个物理连接有后端进程开销,实例多时直连会撑爆 max_connections。PgBouncer 在中间维护到数据库的连接池,应用连到代理,代理按模式复用后端连接。应用内池仍负责单实例内复用,代理负责跨实例汇聚。两层池大小都要规划,避免应用侧开很大、代理侧排队。PgBouncer 模式对 prepared statement 与会话特性有兼容约束,见后续题目。

原理流程

  1. 应用连接到 PgBouncer 代理地址。
  2. 代理按池模式管理到 PG 的后端连接。
  3. 请求复用或新建后端连接。
  4. 两层池容量分别规划。

代码或图示

分层:
  应用实例 → 应用内连接池 → PgBouncer 代理池 → PostgreSQL
  关注点:应用池上限、代理池大小、PG max_connections 三层容量匹配

常见误区

  • 以为有了代理就可以关闭应用池:代理解决跨实例汇聚,单实例内复用仍需应用池。
  • 两层池容量不联动:任一层排队都会成为瓶颈。

追问

  • MySQL 有类似代理吗?答:有各类连接代理方案,本题聚焦 PG 的 PgBouncer;选型按数据库生态确认。
  • 代理本身是单点吗?答:部署时需高可用配置,代理故障影响全部数据库访问。

04.4.8.4-016 PgBouncer 的 session、transaction、statement 三种池化模式有何区别?

一句话结论

session 模式连接整段会话独占复用;transaction 模式事务结束即归还连接;statement 模式单条语句后归还;复用粒度越细,并发支撑越高,但会话特性兼容性越弱。

概念解释

session pooling:应用会话期间绑定后端连接,结束才归还,兼容性最好但复用率低。transaction pooling:事务边界归还,事务内状态保持,事务外不保留会话状态,是常用折中。statement pooling:每条语句后归还,复用最充分,但任何会话级状态都不保留,兼容性最差。模式选择受应用使用的会话特性(prepared statement、临时表、SET、advisory lock)约束。各模式细节以 PgBouncer 官方文档为准。

原理流程

  1. 应用请求到达代理。
  2. 按模式决定何时绑定/释放后端连接。
  3. session:整会话持有;transaction:事务持有;statement:语句持有。
  4. 归还后连接可被其他请求复用。

代码或图示

模式对比:
  session    粒度:会话;兼容性:高;复用率:低
  transaction 粒度:事务;兼容性:中;复用率:中(常用)
  statement  粒度:单语句;兼容性:低;复用率:高

常见误区

  • 用 transaction 模式却依赖会话级状态:跨事务保留的设置在复用后丢失。
  • 盲目选最细粒度:兼容性问题以难复现的随机错误出现。

追问

  • 默认推荐哪种?答:多数应用 transaction pooling,前提是不依赖跨事务会话状态;具体按应用语句特征评估。
  • 待确认点是什么?答:当前 PgBouncer 版本对各特性的兼容清单,以官方文档为准。

04.4.8.4-017 transaction pooling 与 prepared statement 有什么兼容问题?

一句话结论

命名 prepared statement 绑定会话后端连接;transaction 模式下连接在事务间被复用,语句归属的后端连接可能已更换,导致语句找不到或冲突;兼容方案是用未命名语句、禁用服务端预编译或切 session 模式。

概念解释

预编译语句是会话级状态:在某后端连接上准备,该连接复用到其他请求时不应被原请求继续引用。transaction pooling 归还连接后,下一个请求可能复用同一后端连接,残留命名语句造成冲突或失效。常见规避:驱动使用简单查询协议(不创建命名服务端语句)、语句只在单事务内使用、或对有需要的连接走 session 模式。应用框架的语句缓存行为要核对。

原理流程

  1. 连接在后端准备命名语句。
  2. 事务结束连接归还代理池。
  3. 另一请求复用该后端连接。
  4. 原语句引用失效/冲突,触发兼容问题。

代码或图示

兼容风险:
  命名 prepared statement 绑定会话连接
  transaction 模式连接跨事务复用
  规避:未命名/简单查询协议、事务内使用、session 模式专用连接

常见误区

  • 只在应用层做语句缓存就认为兼容:语句实际存在服务端会话连接上。
  • 出问题时归为随机驱动错误:先核对代理模式与预编译使用方式。

追问

  • sqlx 宏生成的语句受影响吗?答:取决于驱动是否创建服务端命名语句,具体行为以 sqlx 当前版本与代理配置为准,需实测验证。
  • 待确认点是什么?答:所选客户端/驱动在 transaction pooling 下的语句策略,验证方式为连接日志与代理兼容文档。

04.4.8.4-018 哪些会话级特性在 transaction pooling 下必须注意?

一句话结论

advisory lock、会话级 SET/参数、临时表、会话游标、LISTEN 订阅、命名语句等绑定会话后端状态的特性,在细粒度池化下不能跨事务依赖;需要时走专用连接或 session 模式。

概念解释

这些特性的状态存在后端会话上,连接归还后被其他请求复用,状态不随之迁移。典型坑:事务外设置的参数下条语句失效;advisory lock 持有期间连接不能被归还;LISTEN 绑定连接,连接换道后通知收不到。排查这类问题先区分「数据库事务状态」与「会话状态」。需要强会话粘性的功能,单独建立走 session 模式的连接或固定连接。

原理流程

  1. 识别特性是否依赖会话状态。
  2. 评估代理池化模式是否允许状态跨请求保留。
  3. 不兼容时隔离专用连接。
  4. 其余普通请求走细粒度池化。

代码或图示

会话绑定特性清单:
  advisory lock / 会话参数 SET / 临时表
  会话游标 / LISTEN-NOTIFY 订阅 / 命名 prepared statement
处置:专用连接或 session 模式,不进事务池复用

常见误区

  • 以为事务回滚会清理所有会话状态:部分会话设置独立于事务。
  • 监听通知的连接被池回收:订阅随连接失效。

追问

  • 全局参数应该设在哪?答:数据库默认值或连接初始化配置,不依赖请求会话临时设置。
  • 待确认点是什么?答:PgBouncer 对各特性的兼容说明,以官方文档特性章节为准。

04.4.8.4-019 事务执行期间连接在池中处于什么状态?

一句话结论

事务开启后连接被该任务独占持有,不计入可复用空闲;事务提交或回滚后连接才归还池。长事务会长期占用连接,加剧池耗尽。

概念解释

借出的连接在事务期间不能被其他任务复用:事务涉及多条语句与一致性视图,共享连接会破坏原子性与隔离性。因此事务长度直接决定连接持有时间。事务内做外部调用、等待用户操作都会拉长占用。池监控看到的「已借出」包含在途事务连接。优化方向是缩短事务边界,而非单纯调大池。

原理流程

  1. 取连接并开启事务。
  2. 连接标记占用,不进空闲队列。
  3. 事务语句执行期间独占。
  4. commit/rollback 后连接归还。

代码或图示

连接占用周期:
  借出 → BEGIN → 事务语句 → COMMIT/ROLLBACK → 归还
  事务内等待外部响应 = 连接持续占用

常见误区

  • 以为事务结束后连接自动归还但句柄还在作用域:以句柄 Drop 与事务结束为准。
  • 长事务靠池扩容解决:根因是事务边界过长。

追问

  • 只读查询也需要独占连接吗?答:单次查询借出即可;显式事务期间同样独占,见只读事务题目。
  • 池耗尽与长事务如何区分?答:看连接持有时长分布,长事务表现为占用时间长且与业务步骤关联。

04.4.8.4-020 池化环境下裸客户端(tokio-postgres)连接如何复用?

一句话结论

裸 Client 不自带池,配合 deadpool/bb8 等独立池管理连接生命周期;池内每个连接对应一个客户端句柄,任务借出后独占使用,归还后供复用。

概念解释

tokio-postgres 的单 Client 与其后台 Connection 任务绑定。池化时 Manager 负责新建 (Client, Connection) 对、spawn 后台任务、回收校验。任务拿到借出的客户端执行语句,Drop 时归还。后台连接任务随池内连接存活;坏连接销毁时连同后台任务一起终止。不要把裸 Client 克隆后并发共享给多个任务。

原理流程

  1. Manager 新建连接并 spawn Connection 后台任务。
  2. 池借出客户端句柄给任务。
  3. 任务独占执行语句。
  4. 句柄 Drop 归还;坏连接连同后台任务销毁。

代码或图示

裸客户端池化要素:
  Manager:create 建连 + spawn 后台任务,recycle 校验
  Pool:队列与容量管理
  任务:独占借出的 Client,不并发共享

常见误区

  • 多个任务共用一个 Client:协议消息串扰,结果错乱。
  • 归还时忘记停后台任务:连接泄漏伴随任务泄漏。

追问

  • 池化客户端需要重新 prepare 吗?答:语句状态随连接走,复用连接保留缓存,跨连接需重新准备,见 04.4.8.3 语句缓存题目。
  • 待确认点是什么?答:deadpool-postgres 当前版本连接封装与回收 API,以 docs.rs 为准。

04.4.8.4-021 每个请求取一次连接与长借用连接有什么区别?

一句话结论

短借用:每条语句或每个用例从池取连接、用完即还;长借用:连接在一段流程内持续持有。短借用池利用率高,长借用仅在事务等必须独占的场景使用。

概念解释

非事务的独立查询应随用随取,归还后其他任务复用。长借用连接会把池容量占在流程等待上,尤其跨 await 外部调用时。唯一合理的长借用是显式事务:事务内连接必须独占。架构上避免「取一条连接贯穿整个请求处理」,这等于退化成请求级独占连接,池化失效。

原理流程

  1. 独立查询:取连接 → 执行 → 归还。
  2. 事务用例:取连接 → BEGIN → 执行 → 结束 → 归还。
  3. 非事务流程中等待外部响应时不持有连接。
  4. 连接持有范围最小化。

代码或图示

推荐:
  普通查询:即用即还
  事务:事务期间独占,结束归还
不推荐:
  请求开始取连接,处理完所有逻辑(含外部调用)才归还

常见误区

  • 在 handler 入口取连接放状态里全程持有:池并发度被请求数锁死。
  • 只读流程也长借用:白白占用名额。

追问

  • 同一用例多条独立语句要同一连接吗?答:不需要,各自取连接即可;只有需要事务一致性时才独占。
  • 连接可以在函数间传递吗?答:可以在事务边界内传递句柄,但不要传出事务作用域。

04.4.8.4-022 获取超时与语句查询超时是什么关系?

一句话结论

两层独立超时:acquire_timeout 等待获取连接的时间,语句超时控制单条 SQL 在数据库执行的时长;都需要配置,分别应对池排队与慢查询。

概念解释

获取阶段还没拿到连接,等待的是池;拿到连接后执行语句,等待的是数据库。两层超时叠加决定请求最坏耗时。只配获取超时,慢查询会长期占连接;只配语句超时,池满时任务无限排队。语句超时通过数据库侧设置(如配置项或语句级 SET)实现,能力按数据库方言。请求整体超时再外包一层(HTTP/任务超时)。

原理流程

  1. 获取连接:受 acquire_timeout 约束。
  2. 执行语句:受语句超时约束。
  3. 任一层超时返回对应错误。
  4. 外层请求超时兜底整体生命周期。

代码或图示

超时层级:
  acquire_timeout → 池等待上限
  语句超时         → 单条 SQL 执行上限(数据库/驱动配置)
  请求/任务超时    → 整个用例上限

常见误区

  • 认为配了池超时就覆盖慢查询:两层作用阶段不同。
  • 语句超时设太长:慢查询占连接拖垮池。

追问

  • 语句超时怎么设置?答:按数据库方言的语句超时参数或驱动选项,具体名称以数据库文档为准。
  • 待确认点是什么?答:所选查询库是否暴露语句超时配置项,以当前版本文档为准。

04.4.8.4-023 应用池容量与数据库 max_connections 如何匹配?

一句话结论

所有实例应用池上限之和加其他客户端预留,必须小于数据库 max_connections;多层池(代理)容量也要纳入换算,避免总和超出数据库承载。

概念解释

连接预算从上往下分配:数据库总连接先扣除运维、迁移、其他服务预留,剩余按应用实例数分摊单实例池上限。有代理层时,代理到数据库的后端池是另一段预算。容量规划要考虑实例扩容上限,不能按当前实例数算满。数据库侧连接耗尽会拒绝新连接,应用表现为获取失败。上线前用压测验证连接峰值。

原理流程

  1. 读取数据库 max_connections 与现有占用。
  2. 预留运维与其他客户端份额。
  3. 按实例数与扩容上限分摊应用池。
  4. 压测校验峰值连接不超预算。

代码或图示

连接预算:
  max_connections
  - 运维/迁移/其他服务预留
  - 代理后端池占用(若有)
  = 应用可用连接
  应用可用 ÷ 实例数 ≈ 单实例池上限

常见误区

  • 各实例独立设大池,总和超出数据库:整体连接拒绝。
  • 忘记预留迁移/运维连接:高峰期 DBA 无法登录排查。

追问

  • 扩容实例时池要下调吗?答:是,实例数增加后单实例池上限应同步下调,保持总预算不变。
  • 数据库连接数能调大吗?答:受内存与进程开销约束,盲目调大反而降低稳定性。

04.4.8.4-024 连接串、TLS 与池配置如何组织?

一句话结论

连接信息按环境配置注入(环境变量/配置中心),池参数与连接串分离管理;TLS 配置随池建立一次生效,敏感凭据不写进代码与日志。

概念解释

池配置包括:连接地址凭据、池容量、各类超时、TLS 模式。开发、测试、生产环境参数不同,通过配置层注入。凭据属于敏感信息,不提交仓库、不打印日志。TLS 校验模式按环境区分:生产强制校验证书,本地开发可宽松但不得带入生产。池在启动时建立,配置变更需重启或重载连接。

原理流程

  1. 从配置源读取连接串与池参数。
  2. 构造 TLS 连接器。
  3. 建池并健康检查。
  4. 运行期凭据与日志保持脱敏。

代码或图示

配置分组:
  连接:host/port/user/password/dbname/sslmode
  池:max_connections / 超时 / 回收策略
  TLS:证书与校验模式(生产严格)

常见误区

  • 凭据写死在示例代码并提交:隐私泄露。
  • 开发环境宽松 TLS 复制到生产:证书校验被绕过。

追问

  • 待确认点是什么?答:所选池/驱动的 TLS 配置入口与支持的后端实现,以版本文档为准。
  • 连接串里的密码会出现在错误日志吗?答:注意日志脱敏,错误信息与配置打印避免带凭据。

04.4.8.4-025 连接池问题的综合排查清单是什么?

一句话结论

按「连接能否建立 → 池容量是否耗尽 → 连接是否泄漏/长持有 → 健康检查是否生效 → 两层超时是否合理」顺序定位,先看指标再看语句。

概念解释

池问题表象分三类:建连失败(网络/认证/TLS/数据库满)、获取排队(容量不足或归还过慢)、使用时报错(坏连接/解码/语句)。排查先读池指标区分阶段,再下钻。不要在没看指标前盲目调大池或改语句。常见根因:连接泄漏、长事务、慢查询、代理兼容、配置超时不合理。

原理流程

  1. 检查建连:网络、凭据、TLS、数据库连接余量。
  2. 读池指标:size/idle/queue/等待时长。
  3. 区分泄漏(不归还)与长持有(慢/事务)。
  4. 核对健康检查、超时与代理兼容配置。

代码或图示

排查顺序:
  1. 建连错误:网络 / 认证 / TLS / max_connections
  2. 获取排队:池上限 / 队列长度 / 等待超时
  3. 连接泄漏:借出不归还,句柄生命周期
  4. 长持有:慢查询 / 长事务 / 外部调用占连接
  5. 坏连接:健康检查与代理断连

常见误区

  • 直接调大池上限:掩盖泄漏与长事务,数据库侧最终被压垮。
  • 把所有池错误归为数据库故障:先区分应用池阶段。

追问

  • 下一步深入什么?答:事务边界与长事务治理见 026 题起;慢查询与执行计划见 089 题起。
  • 待确认点是什么?答:各池框架指标方法名与告警钩子,以当前版本文档为准。

04.4.8.4-026 事务边界为什么应放在 service 层?

一句话结论

事务边界对应一个完整业务用例,应在 service(用例编排)层开启与提交;controller/handler 只处理请求响应,repository 只提供单条数据访问,不各自开事务。

概念解释

跨多张表、需要原子性的操作属于一个业务用例:service 方法编排若干 repository 调用,在最外层开事务。这样事务范围与业务一致性边界一致,repository 复用为事务内的一步。若在 repository 层各自开事务,跨表操作失去原子性;若在 handler 层开事务,业务规则泄漏到接口层且难以复用。分层后事务策略可按用例统一调整。

原理流程

  1. handler 解析请求,调用 service 用例。
  2. service 开启事务,编排多个 repository 操作。
  3. 全部成功提交,任一失败回滚。
  4. 结果返回 handler 转换响应。

代码或图示

分层:
  handler    请求/响应转换,不开事务
  service    事务边界,编排用例步骤
  repository 单表/单聚合数据访问,加入外层事务

常见误区

  • repository 方法各自 commit:跨表写入部分成功。
  • handler 里拼事务逻辑:业务用例换个入口就漏事务。

追问

  • 一个 service 方法能调另一个带事务的 service 吗?答:嵌套时明确传播行为(加入外层事务还是新开),避免双重提交语义混乱。
  • 只读用例需要事务吗?答:可走只读事务或普通查询,见只读事务题目。

04.4.8.4-027 事务内部不应该做哪些事情?

一句话结论

事务内避免外部 HTTP/RPC 调用、消息发送、等待人工确认、长耗时计算;这些操作拉长事务持有时长,占用连接与锁,放大死锁与池耗尽风险。

概念解释

事务持有数据库连接、行锁与一致性视图,事务越长这些资源占用越久。外部调用时长不可控(下游超时、重试),把它放进事务等于把数据库资源押在外部可用性上。正确顺序:事务内只做数据库读写,外部副作用在事务提交后执行;需要一致性时用 outbox/消息表模式补偿。批处理大事务也要拆分批次。

原理流程

  1. 开启事务前准备好所有入参与外部数据。
  2. 事务内只执行数据库读写。
  3. 提交后再发消息、调外部接口。
  4. 外部失败走补偿或重试机制。

代码或图示

事务内禁忌:
  外部 HTTP / RPC / MQ 发送等待
  人工审批等待
  大段同步计算与文件处理
  跨长时间的批量遍历
推荐:事务内短读写,副作用提交后处理

常见误区

  • 「先调外部成功再开事务」:外部成功而库写入失败,产生不一致。
  • 事务内循环发消息:消息发送失败回滚数据库,但已发消息无法撤回。

追问

  • 必须先有外部单号怎么办?答:先取外部单号落库(短事务),主流程后续步骤再用;或设计补偿流程。
  • 消息发送怎么保证与库一致?答:outbox 模式,见 034 题。

04.4.8.4-028 事务与 await 跨任务有什么注意事项?

一句话结论

事务连接绑定在持有它的任务上,不能把事务句柄随便传到其他 spawn 任务并发使用;跨任务传递会破坏连接独占性,任务取消也可能导致事务悬挂。

概念解释

异步事务句柄包含独占的数据库连接,连接不能被两个并发任务共享。spawn 出的任务若拿走事务连接,原任务与新任务交替使用同一连接,协议状态错乱。任务被取消时事务可能未提交也未回滚,连接悬挂占用。需要并行查询时各取独立连接;需要同事务的步骤顺序执行在同一任务内。异步运行时取消传播要能触发事务清理。

原理流程

  1. 事务在当前任务内开启。
  2. 事务内步骤顺序 await 执行。
  3. 不把事务句柄送入并发任务。
  4. 任务退出时确保 commit/rollback 路径执行。

代码或图示

// 错误倾向:把 tx 交给 spawn 的并发任务共享同一连接
// 正确:并行只读各自取连接;写步骤留在事务任务内顺序执行

常见误区

  • 为了并发把事务连接 clone 到处传:协议状态串扰。
  • spawn 的后台任务持有事务:主流程结束后事务悬挂。

追问

  • 异步任务取消时事务会回滚吗?答:取决于句柄 Drop 行为与运行时取消传播,需核对框架实现;关键路径要有超时与回滚保障。
  • 待确认点是什么?答:所选 ORM/驱动事务句柄的 Drop 语义,以当前版本文档为准。

04.4.8.4-029 事务与 HTTP 请求生命周期如何配合?

一句话结论

事务应在请求处理线程/任务内开启并在同一请求内结束,不跨越请求生命周期;请求结束时事务必须已提交或回滚,连接归还池。

概念解释

把事务挂在长生命周期状态里跨请求复用,会导致连接长期占用、隔离状态混乱,且下一请求看到未提交上下文。每个请求独立建立自己的事务边界:进入 service 开事务,响应返回前结束。异步任务/后台流程有自己的事务边界,不挂在请求对象上。请求超时中断时,事务要能被清理回滚。

原理流程

  1. 请求到达,进入 service 用例。
  2. 事务在请求任务内开启。
  3. 用例执行完提交/回滚。
  4. 响应返回前连接已归还池。

代码或图示

请求生命周期:
  接收 → service 开事务 → 读写 → 结束事务 → 响应
  禁止:事务存入应用状态跨请求保留

常见误区

  • 连接/事务放全局状态:跨请求污染且泄漏。
  • 响应已返回而事务仍在后台悬挂:连接不归还。

追问

  • 后台发消息能借用请求事务吗?答:不能,后台任务用自己的连接与事务,请求事务提交后再投递。
  • 请求超时后数据库事务状态?答:连接随任务清理回滚,需验证驱动 Drop 行为并设置语句/事务超时。

04.4.8.4-030 事务提交失败或连接断开时如何处理?

一句话结论

提交阶段失败原因可能是约束冲突、连接中断或数据库故障;此时事务状态不确定(未提交还是已提交),不能盲目重试写操作,需先查明状态再决定重试或补偿。

概念解释

执行语句阶段失败通常明确回滚;提交阶段失败更棘手:网络断在 COMMIT 前后,数据库可能已提交。应用层不能假设「提交失败就没写入」。处理:错误分类(约束可重试修正、连接断开需查状态)、关键写操作带幂等键、必要时回查业务状态。连接断开的事务由数据库/连接清理结束,不会半提交悬挂。

原理流程

  1. 提交调用返回错误。
  2. 区分错误类型:约束冲突 / 连接中断 / 数据库故障。
  3. 连接中断场景按业务键回查是否已落库。
  4. 未提交则重试;已提交则走后续步骤。

代码或图示

提交失败处置:
  约束冲突 → 业务错误,不盲目重试
  连接断开 → 回查状态,避免重复写入
  数据库故障 → 有限重试 + 告警
  写入操作带幂等键兜底

常见误区

  • 提交失败直接重放整个写流程:可能产生重复订单/重复扣款。
  • 不区分语句错误与提交错误:重试策略错误。

追问

  • 怎么回查是否已提交?答:用唯一业务键查询目标行是否存在及状态,查询本身走新连接。
  • 待确认点是什么?答:驱动在连接断开时对事务结束状态的报告方式,以错误文档为准。

04.4.8.4-031 嵌套事务与保存点在工程上怎么用?

一句话结论

嵌套业务步骤需要局部回滚时用保存点;绝大多数 service 编排用单一外层事务即可,嵌套事务不等于独立提交,提交边界仍由最外层决定。

概念解释

数据库没有真正嵌套事务,内层「事务」映射为保存点。工程上很少显式嵌套:service 调用链共享一个事务上下文。只有内层步骤需要失败重试且不影响外层已完成步骤时,才用保存点。过度嵌套增加排错复杂度。ORM 封装的嵌套事务行为(保存点、命名)按版本确认。

原理流程

  1. 外层事务 BEGIN。
  2. 需要隔离的步骤前建保存点。
  3. 内层失败回滚到保存点重试。
  4. 外层统一提交或整体回滚。

代码或图示

使用判断:
  普通多步骤 → 单事务顺序执行
  内层可重试隔离 → 保存点
  独立一致性边界 → 新开事务(注意不是嵌套)

常见误区

  • 以为内层 commit 会独立落库:外层未提交前都可整体回滚。
  • 每层 service 都开事务:提交边界错乱。

追问

  • 跨聚合的两个独立一致性边界怎么办?答:开两个事务,用 saga/补偿保证最终一致,见 042 题。
  • 待确认点是什么?答:所选框架嵌套事务是否生成保存点及接口名称,以文档为准。

04.4.8.4-032 测试中如何用事务回滚隔离测试数据?

一句话结论

集成测试可在测试外层开一个大事务,每个用例在其中执行,结束回滚;或用保存点按用例回滚,避免测试数据污染彼此、加快清理。

概念解释

测试隔离常见方案:每个用例独立库/表、用例后清理、事务回滚。事务回滚方案:测试连接开启事务,用例内 repository 操作都在该事务内,用例结束整体 rollback,数据不落库。注意外部可见状态(缓存、MQ、搜索索引)不会随数据库回滚,需要单独清理。事务回滚方案要求测试代码能拿到同一事务连接。

原理流程

  1. 测试开始开启外层事务。
  2. 用例通过该事务连接执行业务代码。
  3. 断言验证结果。
  4. 用例结束回滚,下个用例从干净状态开始。

代码或图示

测试事务方案:
  外层 BEGIN
  用例 A 操作 → 断言 → ROLLBACK(或回滚到保存点)
  用例 B 从干净状态开始
  注意:缓存/MQ/索引状态需另行清理

常见误区

  • 业务代码自己提交事务:测试外层回滚被内层 commit 打断。
  • 以为回滚能清掉外部副作用:消息、缓存、文件不在数据库事务内。

追问

  • 这种方案能测真实提交路径吗?答:部分掩盖 commit 行为,关键提交场景另写独立事务用例验证。
  • 多线程测试能用同一事务连接吗?答:不能并发共享,测试并发要各自连接或独立库。

04.4.8.4-033 测试数据清理有哪些替代方案?

一句话结论

除事务回滚外,还有用例后按标记清理、每个用例独立 schema/库、预先准备固定数据集;按测试速度、隔离强度与副作用范围选择。

概念解释

清理方案对比:事务回滚最快但不覆盖外部副作用;按业务标记删除可清理落库数据但写删除逻辑;独立库/schema 隔离最彻底但初始化慢;固定数据集适合只读场景。集成测试与单元测试策略不同:repository 测试可落库清理,service 测试可用替身。方案要保证用例间不依赖执行顺序。

原理流程

  1. 识别测试涉及的存储与副作用。
  2. 选择回滚/清理/独立库方案。
  3. 准备数据集与清理钩子。
  4. 验证用例顺序无关性。

代码或图示

清理方案:
  事务回滚   快,仅库内,外部副作用另清
  标记删除   落库后清理,需写删除路径
  独立库     隔离彻底,初始化成本高
  固定数据集 只读场景复用

常见误区

  • 用例依赖上一个用例残留数据:顺序一变就失败。
  • 清理逻辑本身有 bug:测试数据越积越多影响后续。

追问

  • 测试库能用生产同构 schema 吗?答:是,迁移在测试库执行一遍,保证结构一致。
  • 外部副作用怎么隔离?答:测试环境用替身/沙箱,或独立队列与命名空间。

04.4.8.4-034 本地消息表(outbox)模式如何保证库写入与消息发送一致?

一句话结论

业务数据与待发消息写在同一个本地事务里(outbox 表),提交后由独立投递器读取未发消息发送 MQ/外部接口,失败重试;避免「库提交了消息没发」或「消息发了库回滚」。

概念解释

分布式一致性的本地方案:事务内同时写业务表与 outbox 消息记录,原子提交。后台任务扫描 outbox 表,投递成功后标记状态;投递失败重试,保证至少一次投递。消费端按幂等处理重复消息。outbox 把跨系统一致性拆成「本地事务一致 + 异步可靠投递」,不依赖分布式事务。消息顺序、重复投递、积压监控都要配套设计。

原理流程

  1. 业务事务内写业务行与 outbox 行(同事务提交)。
  2. 投递器轮询/订阅未发送消息。
  3. 发送成功标记已投递;失败重试并记录次数。
  4. 消费端幂等消费。

代码或图示

outbox 流程:
  BEGIN → 写业务数据 + 写 outbox 消息 → COMMIT
  后台:取 outbox 未发 → 投递 → 标记成功/重试
  消费端:幂等处理重复消息

常见误区

  • 事务内直接调 MQ:MQ 发送不参与数据库事务,失败即不一致。
  • outbox 消息不标记状态:重复投递或反复扫描。

追问

  • 消息顺序怎么保证?答:按业务键分区与排序投递,必要时消息带序号;具体取决于 MQ 能力。
  • 至少一次投递带来重复怎么办?答:消费端用唯一业务键去重,见幂等设计题目。

04.4.8.4-035 事务消息与最终一致性的关系是什么?

一句话结论

本地事务保证库内一致,跨系统靠可靠消息 + 幂等消费达到最终一致;不追求跨库强一致,而是接受短暂不一致并通过重试与补偿收敛。

概念解释

分布式场景下跨库/跨服务强一致代价高,多数业务采用最终一致:本地事务先落库,消息驱动下游更新,失败重试,异常走补偿。最终一致需要:消息可靠投递、消费幂等、重试与死信、对账兜底。业务上明确哪些数据允许短暂不一致。不要把最终一致当成「不用管一致性」,仍要有收敛机制与监控。

原理流程

  1. 本地事务提交业务状态。
  2. 可靠通知下游(outbox/MQ 事务消息)。
  3. 下游幂等处理,失败重试。
  4. 对账任务发现不一致并补偿。

代码或图示

最终一致链路:
  本地事务 → 可靠消息 → 幂等消费 → 重试/死信 → 对账补偿

常见误区

  • 没有幂等就指望消息不重复:重试必然带来重复投递。
  • 没有对账:失败消息静默积压,不一致长期存在。

追问

  • 哪些场景必须强一致?答:资金扣减类核心约束按业务要求评估,仍可用本地事务 + 幂等 + 对账,跨库 2PC 慎用。
  • 事务消息(MQ 半消息)方案与 outbox 区别?答:outbox 基于本地表轮询,MQ 事务消息依赖中间件能力,选型按基础设施确认。

04.4.8.4-036 跨库事务的 2PC 局限与本地方案如何取舍?

一句话结论

两阶段提交(2PC)理论上跨库强一致,但同步阻塞、性能差、协调者单点与故障恢复复杂;高并发业务通常放弃 2PC,改用本地事务 + outbox/ saga 补偿的最终一致方案。

概念解释

2PC 要求所有参与方预备后统一提交,协调者驱动;阻塞期间各库持锁,节点故障可能悬挂,扩展性差。Rust 生态中跨库 2PC 支持有限,工程上少见。替代方案:按业务边界拆分本地事务,事件驱动下游,失败补偿;资金等强约束场景用对账与幂等兜底。设计阶段先判断是否真的需要跨库原子性,多数「跨库一致」可拆为最终一致。

原理流程

  1. 评估一致性要求:强一致还是最终一致可接受。
  2. 强约束场景评估 2PC 成本与基础设施。
  3. 一般场景拆分本地事务 + 事件/补偿。
  4. 对账兜底残留不一致。

代码或图示

2PC:预备 → 全局提交/回滚;阻塞持锁、协调者单点、故障恢复复杂
替代:本地事务 + outbox 事件 + saga 补偿 + 对账

常见误区

  • 把跨服务调用塞进一个数据库事务:服务调用根本不参与数据库事务。
  • 迷信 2PC 解决所有一致性:性能与可用性代价被低估。

追问

  • saga 模式是什么?答:每个步骤本地事务 + 失败执行对应补偿动作,见 042 题。
  • 待确认点是什么?答:当前生态可用的分布式事务组件成熟度,以实际基础设施为准,不凭记忆断言。

04.4.8.4-037 sqlx、SeaORM、Diesel 开启事务的写法有何差异?

一句话结论

三者都提供事务入口:sqlx 用 pool.begin() 得到事务句柄;SeaORM 用连接的 transaction 闭包封装;Diesel 在连接上 transaction 闭包执行;底层都是数据库 BEGIN/COMMIT/ROLLBACK,封装形态不同。

概念解释

写法差异反映抽象层次:sqlx 是句柄式,事务连接可直接传查询;SeaORM 闭包式自动按返回结果提交/回滚;Diesel 也是闭包式,闭包内用同一连接执行。无论哪种,事务内必须使用事务句柄对应的连接,不能混用池内其他连接。具体方法名、错误类型与闭包返回约束以各库当前版本为准。

原理流程

  1. 从池/连接开启事务。
  2. 事务句柄传入各数据访问调用。
  3. 闭包 Ok 提交、Err 回滚(句柄式需显式 commit/rollback)。
  4. 连接归还池。

代码或图示

// sqlx:句柄式(方法名以当前版本为准)
let mut tx = pool.begin().await?;
// ... 用 &mut tx 执行查询 ...
tx.commit().await?;

// SeaORM:闭包式
db.transaction(|txn| Box::pin(async move { /* ... */ })).await?;

// Diesel:闭包式(同步连接语义,API 以版本为准)
conn.transaction(|conn| { /* ... */ }).unwrap();

常见误区

  • 闭包式里误用外层池连接:该操作脱离事务。
  • 句柄式忘记 commit:事务结束按回滚处理,结果与预期不符。

追问

  • 待确认点是什么?答:Diesel 事务闭包的返回类型约束与异步支持现状,以官方文档为准。
  • 事务句柄能传给 repository 吗?答:能,按库的连接 trait 抽象参数传入,保持同一事务。

04.4.8.4-038 只读事务有什么作用与限制?

一句话结论

只读事务声明事务内不写数据,数据库可据此优化(避免 WAL 写入、部分隔离优化),并在应用误写时直接拒绝;用于一致性读的批量查询场景。

概念解释

只读事务告诉数据库该事务只执行读操作,写语句被拒绝。它保证事务内多次读取处于一致快照(按隔离级别),适合批量导出、报表对账这类需要一致视图的查询。只读事务同样持有连接,仍需控制时长。开启方式按数据库方言与驱动支持,标记可能是事务属性或语句级设置。普通单条查询不必特意开只读事务。

原理流程

  1. 以只读模式开启事务。
  2. 事务内执行多条一致读取。
  3. 写操作被数据库拒绝。
  4. 提交/回滚释放连接。

代码或图示

只读事务适用:
  批量导出需要一致快照
  对账/报表多次读取保证视图一致
不适用:任何包含写入的用例

常见误区

  • 只读事务当性能银弹:主要收益是一致视图与写保护,读性能提升有限。
  • 只读事务内仍尝试写入:被拒绝后报错中断。

追问

  • 待确认点是什么?答:所选驱动/ORM 开启只读事务的接口与数据库方言支持,以文档为准。
  • 只读事务能避免长读锁吗?答:MVCC 下读通常不阻塞写,但仍受隔离级别与数据库实现约束。

04.4.8.4-039 事务内连接什么时候不会归还池?

一句话结论

连接在事务 commit/rollback 完成、事务句柄 Drop 后才归还;事务未结束、句柄仍被持有、任务悬挂或出错未清理时,连接一直被占用。

概念解释

归还时点容易被误判:返回了响应不代表连接已归还,关键看事务句柄生命周期。泄漏路径见连接池题目;事务场景下常见悬挂是:闭包提前 return 但句柄未清理、await 被取消、句柄存入长生命周期结构。监控上表现为借出数居高不下。代码评审要检查事务句柄的作用域退出路径。

原理流程

  1. 事务开启,连接借出占用。
  2. 正常结束 commit/rollback。
  3. 句柄 Drop,连接归还。
  4. 异常路径未清理则连接悬挂不归还。

代码或图示

不归还路径:
  事务未结束句柄仍在作用域
  任务取消后清理未执行
  句柄被存入全局/长生命周期结构
  出错路径漏了回滚

常见误区

  • 以为查询结束连接就归还:显式事务内要等事务结束。
  • 只测正常路径:异常取消路径才是泄漏高发处。

追问

  • 如何发现悬挂事务?答:池指标借出不下降,数据库侧查看活跃事务与连接时长。
  • 框架能自动回滚悬挂事务吗?答:句柄 Drop 语义与运行时取消行为需按驱动确认,不能依赖未验证的自动清理。

04.4.8.4-040 乐观重试与事务如何配合?

一句话结论

乐观锁冲突(版本号不匹配)通常回滚当前事务后,重新读取数据并重试用例;重试在事务外编排,事务内只做一次尝试,避免在事务里反复自旋等待。

概念解释

乐观并发控制:更新时检查版本,冲突则放弃本次事务。重试循环放在 service 层:重新取数、开新事务、再写。重试次数与退避有限制,区分可重试冲突与不可重试业务错误。事务内不做重试等待,否则长占用连接。重试必须保证整个用例幂等,重复执行不产生副作用。

原理流程

  1. service 读当前数据与版本。
  2. 开事务尝试写入,带版本条件。
  3. 版本冲突回滚,记录一次失败。
  4. 有限次重新开始用例,超限报错。

代码或图示

重试编排(事务外):
  for attempt in 0..N {
      let result = service_tx().await; // 内部独立事务
      match result { Ok(v) => return Ok(v), Conflict => continue }
  }

常见误区

  • 事务内死循环重试:连接与锁长期占用。
  • 重试不幂等:重复提交产生重复业务记录。

追问

  • 乐观锁冲突概率高怎么办?答:说明并发争用激烈,评估改悲观锁、拆分热点或降低事务粒度,而不是加重试。
  • 重试间隔怎么设?答:短冲突可立即重试少量次,持续冲突退避并告警。

04.4.8.4-041 批量操作的事务粒度如何划分?

一句话结论

批量写入按批次划分事务:每批一个事务提交,避免单一大事务长时间持锁与大量日志;批次大小平衡吞吐、失败回滚代价与重试粒度。

概念解释

一次处理上万行若放一个事务:undo/redo 日志膨胀、锁范围大、失败整体回滚成本高、连接占用久。分批后每批独立提交,失败只回滚当前批,已提交批次保留并记录断点。批大小结合参数上限、锁影响与数据库负载实测调整。批间可短暂让出资源。批量任务还要记录进度,支持断点续跑。

原理流程

  1. 读取待处理集合与断点。
  2. 按批次切片。
  3. 每批开启事务、写入、提交。
  4. 失败回滚当前批,记录位置,重试或人工介入。

代码或图示

批量策略:
  小批事务:锁范围小,回滚代价低
  批次大小:参数上限 / 锁影响 / 实测吞吐
  断点记录:失败续跑不重跑已提交批

常见误区

  • 全量一个事务:长事务 + 大回滚段。
  • 每行一个事务:往返过多,吞吐低。

追问

  • 批次需要整体一致吗?答:业务要求全成功或全失败时才大事务;一般批处理接受部分成功 + 失败重试。
  • 大批量迁移怎么减小锁影响?答:错峰执行、分批、控制每批行数,必要时在线变更方案。

04.4.8.4-042 saga 模式与补偿事务如何设计?

一句话结论

saga 把长业务流程拆成一系列本地事务,每步有对应补偿动作;某步失败时按相反顺序执行已完成步骤的补偿,达到最终一致。

概念解释

跨服务/跨聚合的长流程不持有一个全局事务,而是步骤化:每个步骤本地事务提交,记录步骤状态;失败触发补偿(退款、撤销、回滚库存)。补偿动作本身要幂等且可重试。saga 分编排式(中央协调器)与协同式(事件驱动)。不是所有动作都可补偿(如已对外发通知),设计时识别不可逆步骤并预留人工处理。

原理流程

  1. 定义流程步骤与各自补偿动作。
  2. 步骤本地事务提交,记录状态。
  3. 后续步骤失败,反向执行补偿。
  4. 补偿失败重试,超限转人工。

代码或图示

saga 顺序:
  T1 提交 → T2 提交 → T3 失败
  补偿:C2 → C1
  每步与补偿都要幂等、可重试

常见误区

  • 补偿动作不幂等:重复补偿造成二次撤销。
  • 忽略不可逆步骤:补偿无法回退外部已生效动作。

追问

  • saga 与 outbox 怎么配合?答:步骤间事件投递用 outbox 保证可靠,saga 协调状态推进流程。
  • 补偿失败怎么办?答:重试 + 死信 + 人工干预队列,不能静默跳过。

04.4.8.4-043 审计日志写入应不应该放在业务事务内?

一句话结论

审计记录通常与业务数据同事务写入,保证业务变更与审计痕迹一致;但审计量大时可异步落库,接受审计最终一致并保证不丢。

概念解释

同事务写审计:业务回滚则审计不残留,一致性强,代价是多写一张表与事务时长。异步审计:业务提交后发事件写日志,吞吐好但可能短暂丢失,需要可靠投递。合规要求强的审计一般不允许丢失,优先同事务或 outbox。审计表只追加不改写,写入模型与业务表分离。注意审计内容不含敏感明文。

原理流程

  1. 业务事务内写业务行与审计行(同提交)。
  2. 或业务提交后经 outbox 投递审计事件。
  3. 审计只追加,保留变更前后值与操作主体。
  4. 异步方案监控投递积压。

代码或图示

审计方案:
  同事务:一致性强,事务略重
  outbox 异步:吞吐好,需可靠投递与积压监控
  审计字段:变更前后值、操作人、时间、原因

常见误区

  • 审计日志打印到应用日志就完事:应用日志可清理,合规审计需持久化存储。
  • 同事务写大量审计明细:拖长核心事务。

追问

  • 审计表需要业务索引吗?答:按查询主体/时间范围建索引,写入为主避免过多索引。
  • 待确认点是什么?答:合规要求按业务场景确定,技术方案对齐审计留存周期与不可篡改要求。

04.4.8.4-044 为什么说「一个业务用例一个事务」?

一句话结论

事务边界应与业务用例的原子性需求对齐:一个用例内必须同生共死的操作放同一事务;用例之间独立事务,避免不必要的锁范围与耦合。

概念解释

判断哪些操作同属一个用例:它们是否必须一致成功或回滚。属于同一用例的多张表写入放一个事务;不同用例、可独立重试的操作分开。过宽事务把无关操作卷入,拉长锁与连接占用;过窄事务破坏用例原子性。用例划分来自业务领域,不是表数量。接口层只触发用例,不决定边界。

原理流程

  1. 梳理用例:触发动作、涉及写入、一致性要求。
  2. 必须原子的操作归入同一事务。
  3. 可独立成功的操作拆分。
  4. 跨用例一致性用消息/补偿方案。

代码或图示

用例边界判断:
  必须同时成功/回滚 → 同事务
  可独立提交、失败可补偿 → 分开事务
  外部副作用 → 提交后异步

常见误区

  • 按控制器接口划分事务:一个接口可能含多个独立用例。
  • 按表划分事务:跨表用例被拆碎,失去原子性。

追问

  • 用例边界不清楚怎么办?答:回到领域模型梳理聚合边界,聚合内强一致,跨聚合最终一致。
  • 一个用例调多个 repository 会重复开事务吗?答:repository 不开关事务,加入 service 外层事务。

04.4.8.4-045 事务边界问题的综合排查清单是什么?

一句话结论

按「边界层级 → 事务内操作 → 连接归还 → 异常路径 → 一致性方案」排查:先确认事务开在哪层,再看事务内是否混入外部调用,最后核对失败回滚与跨系统补偿。

概念解释

事务问题表象:部分写入、连接占用高、重复提交、悬挂事务、跨系统不一致。排查从代码分层入手:边界是否在 service、事务句柄是否正确传递、异常与取消路径是否回滚、跨系统是否有可靠消息与补偿。结合数据库侧活跃事务列表与池指标定位长事务。

原理流程

  1. 检查事务开启位置与传播路径。
  2. 扫描事务内是否有外部调用/长等待。
  3. 核对异常、取消路径的回滚清理。
  4. 跨系统一致性核对 outbox/补偿/对账。

代码或图示

排查清单:
  1. 事务边界:service 层,句柄正确传递
  2. 事务内:无外部调用、无长等待、无大批量
  3. 异常路径:回滚执行、连接归还
  4. 跨系统:outbox 投递、幂等消费、补偿对账
  5. 数据库侧:活跃事务时长、锁等待

常见误区

  • 只看正常流程:异常取消路径才是悬挂与不一致来源。
  • 应用层自查不查库:长事务与锁要结合数据库视图确认。

追问

  • 长事务在数据库侧怎么查?答:查看活跃事务、运行时长与持锁语句,配合慢查询日志,见性能排查部分。
  • 下一步:隔离级别与锁策略见 046 题起。

04.4.8.4-046 事务隔离级别有哪些,各自对应哪些并发现象?

一句话结论

ANSI 四级隔离:读未提交、读已提交、可重复读、串行化;逐级抑制脏读、不可重复读、幻读,级别越高并发越低、一致性越强。

概念解释

并发现象:脏读(读到未提交数据)、不可重复读(同一事务两次读同行结果不同)、幻读(两次范围查询行数变化)。读已提交阻止脏读;可重复读阻止脏读与不可重复读;串行化避免所有现象。各数据库默认级别与实现不同(如 PG 默认读已提交,MySQL InnoDB 默认可重复读,MVCC 实现细节有差异)。选型按业务一致性需求与并发承受度,不为所有事务开最高级别。

原理流程

  1. 确定业务允许的不一致现象。
  2. 选择匹配的隔离级别。
  3. 数据库按 MVCC/锁实现该级别。
  4. 高并发处评估级别对吞吐的影响。

代码或图示

级别 vs 现象:
  读未提交:可能脏读
  读已提交:阻止脏读
  可重复读:阻止脏读 + 不可重复读
  串行化:阻止脏读 + 不可重复读 + 幻读

常见误区

  • 以为隔离级别越高越好:高级别并发下降、锁冲突与重试增多。
  • 混淆数据库默认级别:跨库迁移时行为假设错误。

追问

  • 待确认点是什么?答:目标数据库各级别实现与默认值,以数据库官方文档为准。
  • 幻读在可重复读下完全避免吗?答:取决于数据库实现,MySQL/PG 行为不同,按文档与版本确认。

04.4.8.4-047 MVCC 多版本并发控制如何影响读写互不阻塞?

一句话结论

MVCC 为行保留多版本,读操作按一致性快照访问旧版本,写操作创建新版本,从而读写通常不互相阻塞;隔离级别决定快照可见范围。

概念解释

写不覆盖读所见的旧版本:读者看快照版本,写入产生新版本,并发读写不抢同一把读锁。版本链按事务可见性判断哪些版本可读。快照在事务内的建立时点由隔离级别决定:读已提交每条语句取新快照,可重复读事务内固定快照。MVCC 下写阻塞写(行锁/版本冲突),读一般不阻塞写。长期旧版本不清理会导致版本膨胀(如 vacuum 滞后)。

原理流程

  1. 写入创建行新版本,旧版本保留。
  2. 读取按事务快照可见性选版本。
  3. 读写各自基于版本,不阻塞对方。
  4. 旧版本由数据库清理机制回收。

代码或图示

MVCC 要点:
  行多版本 + 可见性判断
  读走快照,写产生新版本
  写-写仍需锁/冲突控制
  旧版本回收滞后会膨胀

常见误区

  • 以为 MVCC 下完全没有锁:写并发仍冲突,更新同一行要等待。
  • 忽略版本清理:长事务阻止旧版本回收,表膨胀。

追问

  • 长事务为什么导致版本膨胀?答:旧版本对该长事务仍可见,清理机制不能回收,数据表与索引膨胀。
  • MVCC 与隔离级别关系?答:级别决定快照时点与可见版本规则,见各后续题目。

04.4.8.4-048 读已提交(Read Committed)的行为特征是什么?

一句话结论

读已提交下每条语句看到的是语句开始时已提交的数据;防止脏读,但同一事务内两次读同一行可能得到不同结果(不可重复读)。

概念解释

每条语句用新快照,能读到其他事务已提交的最新值。适合大多数普通业务:读写并发好,一致性要求不极端。场景:单行读取展示、无一致性视图要求的查询。需要事务内多次读取结果一致时,该级别不够。写冲突仍按行锁/版本控制处理。PostgreSQL 默认级别即读已提交。

原理流程

  1. 事务开始。
  2. 每条语句执行时取当前已提交快照。
  3. 其他事务提交后,下一条语句可见新值。
  4. 防止读取未提交中间状态。

代码或图示

Read Committed:
  语句级快照
  无脏读
  允许不可重复读
  并发表现好,多数业务默认选择

常见误区

  • 期待事务内两次读取一致:该级别不保证,会被其他提交改写。
  • 以为读已提交会读到未提交数据:不会,脏读被阻止。

追问

  • 高并发扣减用什么级别?答:隔离级别之外还要靠行锁或乐观锁控制写冲突,级别不解决写并发。
  • 待确认点是什么?答:目标库 Read Committed 下语句快照的精确语义,以数据库文档为准。

04.4.8.4-049 可重复读(Repeatable Read)的行为特征是什么?

一句话结论

可重复读在事务内固定一致性快照,多次读取同一行结果不变;阻止不可重复读,幻读行为按数据库实现而定。

概念解释

事务快照在首次读时建立,整个事务访问同一版本视图,其他事务提交的修改在本事务内不可见。适合需要一致视图的对账、批量读取。代价:快照长期存在,旧版本不能及时清理;写冲突处理仍需锁或乐观控制。MySQL InnoDB 默认可重复读,其幻读抑制实现有专门机制,与其他库行为不完全相同。

原理流程

  1. 事务首次读取建立快照。
  2. 事务内所有读取沿用该快照。
  3. 其他事务提交对本事务不可见。
  4. 事务结束后快照释放,旧版本可回收。

代码或图示

Repeatable Read:
  事务级快照
  无脏读、无不可重复读
  幻读抑制程度依数据库实现
  长事务持有快照,注意版本膨胀

常见误区

  • 认为可重复读下写入也基于旧版本无冲突:写仍受当前行锁与约束影响。
  • 跨库沿用幻读假设:各库 RR 实现差异需核对。

追问

  • 可重复读事务看到自己的写入吗?答:本事务自身修改可见,快照过滤的是其他事务版本。
  • 待确认点是什么?答:目标库 RR 对幻读与快照建立时机的定义,以官方文档为准。

04.4.8.4-050 串行化(Serializable)隔离级别适合什么场景,代价是什么?

一句话结论

串行化保证事务并发执行等价于某种串行顺序,避免所有并发异常;代价是更高的冲突检测、重试概率与并发下降,仅用于一致性要求极高且冲突可控的场景。

概念解释

串行化通过强约束或乐观冲突检测防止并发写出现异常结果。数据库可能在提交时检测到写倾斜/读写依赖冲突而中止事务,应用必须重试。普通业务用不到该级别;金融、库存强约束等关键场景才评估。串行化不等于加全表锁,实现方式(悲观锁或可串行化快照检测)依数据库而定。重试压力大时说明并发模型需要重新设计。

原理流程

  1. 关键用例声明串行化级别。
  2. 数据库检测并发依赖是否可串行。
  3. 检测到冲突中止事务,应用重试。
  4. 无冲突事务正常提交。

代码或图示

Serializable:
  等价串行执行,无并发异常
  冲突中止 + 应用重试
  并发吞吐下降
  适用:极高一致性、低冲突关键流程

常见误区

  • 全局开串行化:普通查询也被拖慢,重试风暴。
  • 被中止后不重试:事务失败直接暴露给用户。

追问

  • 串行化与显式加锁哪个可控?答:按场景评估;显式悲观锁范围明确,串行化由数据库检测,行为可预测性不同。
  • 待确认点是什么?答:目标库串行化的实现(锁/SSI)与冲突错误码,以数据库文档为准。

04.4.8.4-051 FOR UPDATE 悲观锁如何使用,各框架写法有何差异?

一句话结论

SELECT ... FOR UPDATE 对命中行加排他行锁,事务内持有到提交;SQLx/裸客户端直接写语句,ORM 在查询链上加锁方法,写法不同但底层都是数据库行锁。

概念解释

悲观锁假设冲突会发生,读取关键行时锁定,其他事务更新或再锁需等待。典型场景:库存扣减、余额更新前先锁行。锁在事务内有效,事务结束释放。框架差异:裸客户端/tokio-postgres 在 SQL 文本写 FOR UPDATE;sqlx 直接执行带锁语句;ORM 提供查询构造器的锁定方法(方法名按版本确认)。FOR UPDATE 不锁不匹配的行,范围查询加锁范围要评估。

原理流程

  1. 事务内查询目标行并带 FOR UPDATE。
  2. 数据库对命中行加排他锁。
  3. 当前事务读取并更新。
  4. 提交/回滚释放锁。

代码或图示

// 裸客户端 / sqlx 风格:SQL 文本带锁
// SELECT id, stock FROM product WHERE id = $1 FOR UPDATE

// SeaORM / Diesel:查询构造器的锁定入口(方法名以当前版本为准,待确认)
// .lock(SelectLock::Update)

常见误区

  • 非事务里用 FOR UPDATE:语句结束锁立即释放,锁不住并发更新。
  • 范围查询加锁过大:锁住多余行,并发下降甚至死锁。

追问

  • 锁等待超时怎么配?答:数据库锁等待超时参数,超时后返回错误;按方言配置。
  • 待确认点是什么?答:各 ORM 锁定方法名与支持的锁选项,以当前版本文档为准。

04.4.8.4-052 行锁粒度与锁等待如何分析?

一句话结论

行锁只锁定匹配的具体行,不锁整表(索引选择决定实际锁定范围);其他事务访问锁定行时排队等待,等待时长与死锁由数据库监控。

概念解释

行锁粒度依赖查询用到的索引:走唯一索引锁单行,索引失效可能退化为锁更多行甚至表级锁定。锁等待表现为并发事务阻塞,等待队列在数据库侧可见。分析锁要结合执行计划:命中哪些索引、锁定哪些行。锁持有时间等于事务时长,缩短事务是降低等待的根本手段。锁等待与死锁视图在数据库侧查询。

原理流程

  1. 带锁查询走执行计划确定索引。
  2. 数据库锁定匹配行。
  3. 冲突事务排队等待。
  4. 提交释放;等待超时报错或死锁被检出。

代码或图示

锁分析:
  执行计划 → 索引是否命中 → 锁定行数
  锁等待 → 谁持有、谁等待、等待时长
  优化 → 索引精确、事务缩短、热点拆分

常见误区

  • 以为行锁永远只锁一行:索引不匹配时锁定范围扩大。
  • 锁等待归为数据库慢:根因可能是事务长持有。

追问

  • 数据库侧怎么看锁?答:查锁等待与活跃事务视图,结合慢查询日志;具体视图按数据库方言。
  • 行锁会升级成表锁吗?答:部分数据库在特定场景有锁升级或表锁策略,按方言文档确认。

04.4.8.4-053 版本号乐观锁如何实现?

一句话结论

表加版本号列,更新时带版本条件 WHERE id=? AND version=?,影响行数为 0 说明并发冲突;冲突后重新读取并重试,无需预先加锁。

概念解释

乐观锁假设冲突少发生:读数据时记录版本,写入时校验版本是否仍为读取值。更新语句同时递增版本号。影响行数 0 表示期间被其他事务改过,本次写入放弃重试。相比悲观锁不阻塞读,适合冲突概率低的场景。实现要在实体/查询中带版本条件,不能只在应用层判断。版本号也可用更新时间戳代替,但时间精度与并发判断弱于整数版本。

原理流程

  1. 读取业务行与当前版本号。
  2. 构造更新:主键 + 旧版本条件,版本 +1。
  3. 执行更新,检查影响行数。
  4. 0 行:冲突,重新取数重试;成功则提交。

代码或图示

UPDATE product
SET stock = $1, version = version + 1
WHERE id = $2 AND version = $3

常见误区

  • 只在应用层比对版本,SQL 不带条件:并发下校验形同虚设。
  • 冲突后不重读直接重试:仍基于旧数据,再次冲突。

追问

  • 乐观锁冲突怎么反馈?答:service 层识别 0 行更新,转为可重试冲突或业务提示。
  • 版本号类型用什么?答:整数递增最直接;时间戳方案注意精度与同毫秒并发。

04.4.8.4-054 唯一约束如何作为并发兜底?

一句话结论

对业务上必须唯一的字段(订单号、手机号、业务键)建数据库唯一约束;并发插入重复时数据库拒绝,应用捕获唯一冲突转为业务错误,比应用层先查后插更可靠。

概念解释

「先查询再插入」在并发下有竞态:两个事务同时查到不存在,都插入导致重复。唯一约束在数据库层兜底,重复写入直接冲突失败。应用层先查用于友好提示,最终保证靠约束。唯一冲突错误要识别并映射,不能当成系统故障。软删除场景唯一索引需兼容残留行(部分索引或带标记列)。约束命名与错误码按数据库识别。

原理流程

  1. 表上建唯一索引/约束。
  2. 应用插入并发行。
  3. 数据库拒绝重复键。
  4. 捕获唯一冲突错误,返回业务提示或触发更新分支。

代码或图示

兜底链路:
  应用先查(体验优化,不保证唯一)
  数据库唯一约束(最终保证)
  捕获冲突 → 业务错误 / upsert 分支

常见误区

  • 只靠应用层查重:并发竞态下重复落库。
  • 唯一冲突一律 500:应转为可预期的业务状态。

追问

  • upsert(冲突时更新)怎么实现?答:按方言用 ON CONFLICT/ON DUPLICATE KEY 语法,ORM 是否暴露对应接口待确认。
  • 软删除行占用唯一键怎么办?答:部分唯一索引(仅未删除行唯一)或唯一键拼接删除标记,按方言支持选择。

04.4.8.4-055 死锁是如何产生的,数据库如何检测?

一句话结论

两个以上事务以不同顺序持有并等待对方的锁,形成循环等待即死锁;数据库周期性检测等待环,中止其中一个事务打破死锁。

概念解释

死锁四条件:互斥、持有等待、不可剥夺、循环等待。典型场景:事务 A 锁行 1 等行 2,事务 B 锁行 2 等行 1。数据库死锁检测器发现循环后选牺牲品回滚。应用应保持多事务加锁顺序一致,降低交叉等待。死锁与锁等待不同:死锁是循环阻塞,等待是单向排队。日志中死锁错误与普通锁超时要区分处理。

原理流程

  1. 事务按不同顺序锁定资源。
  2. 互相持有对方需要的锁。
  3. 数据库检测到等待环。
  4. 中止一个事务,另一个继续。

代码或图示

死锁示例:
  T1: 锁行 A → 等待行 B
  T2: 锁行 B → 等待行 A
  检测到环 → 回滚 T1 或 T2
规避:统一加锁顺序、缩短事务、减少交叉更新

常见误区

  • 死锁靠无限重试解决:不改变加锁顺序,死锁会反复发生。
  • 死锁错误当成系统故障告警:属于可重试并发冲突,但频繁出现要分析顺序。

追问

  • 怎么统一加锁顺序?答:多表/多行更新按固定排序(如主键升序)锁定,避免相反顺序。
  • 待确认点是什么?答:目标库死锁检测周期、牺牲品选择策略与错误码,以数据库文档为准。

04.4.8.4-056 死锁与锁等待冲突的重试策略怎么定?

一句话结论

死锁牺牲品与短暂锁等待可有限次重试,重试前重新读取数据;重试次数与退避设上限,持续冲突要分析加锁顺序与热点,不能无限自旋。

概念解释

可重试错误:死锁回滚、锁等待超时(短暂排队后失败)。不可盲目重试:约束冲突、业务参数错误不应重试。重试循环在事务外,每次重试开新事务。退避避免冲突事务同时重试加剧竞争。重试次数耗尽后上报,结合死锁日志定位根因。幂等性保证重复重试不产生副作用。

原理流程

  1. 执行业务事务。
  2. 识别死锁/锁等待错误为可重试。
  3. 有限次重试,重读数据,新事务执行。
  4. 超限报错并记录冲突上下文。

代码或图示

重试策略:
  可重试:死锁、短暂锁等待
  不重试:唯一冲突、参数错误、约束失败
  每次重试:重读 + 新事务 + 幂等
  上限:次数 + 退避 + 告警

常见误区

  • 事务内自旋重试:长占锁加剧死锁。
  • 所有数据库错误都重试:不可恢复错误被反复放大。

追问

  • 重试退避怎么设?答:少量立即重试 + 短暂退避,持续冲突快速失败告警,不做长循环。
  • 怎么判断是死锁还是慢查询持锁?答:死锁有循环等待检测记录;慢持锁表现为单向等待,结合事务时长分析。

04.4.8.4-057 悲观锁与乐观锁如何选型?

一句话结论

冲突频繁、临界资源关键选悲观锁(先锁再改);冲突概率低、读多写少选乐观锁(版本校验 + 重试);热点高并发场景还要考虑拆分与队列化。

概念解释

选型维度:冲突频率、事务持锁成本、失败重试代价。悲观锁阻塞并发写,实现直观,但锁等待与死锁风险;乐观锁不阻塞读,冲突时放弃重试,适合低冲突。库存秒杀这类高热点两者都吃力,需队列、预扣、分桶等设计。选择依据是实测冲突率,不是偏好。混合方案:读用乐观校验,关键写入短事务悲观锁。

原理流程

  1. 估算业务并发冲突率。
  2. 高冲突/关键约束 → 悲观锁 + 短事务。
  3. 低冲突 → 乐观锁 + 有限重试。
  4. 热点瓶颈 → 业务层拆分/排队,而非只换锁策略。

代码或图示

对比:
  悲观锁:先加锁,阻塞等待,适合高冲突
  乐观锁:版本校验,冲突重试,适合低冲突
  热点:分桶/队列/预扣,缓解行级争用

常见误区

  • 低冲突也上悲观锁:不必要的阻塞。
  • 高冲突用乐观锁:重试风暴反而更差。

追问

  • 两种锁能一起用吗?答:可以分层,但同一写入路径保持策略一致,避免语义混乱。
  • 待确认点是什么?答:数据库行锁与乐观约束的实际表现,以压测结果为准。

04.4.8.4-058 MySQL 的间隙锁与 next-key lock 是什么?

一句话结论

InnoDB 在可重复读下用 next-key lock(行锁 + 间隙锁)防止范围查询幻读,锁定记录及其间隙;可能阻塞范围内的插入,是 MySQL 特有的锁机制。

概念解释

间隙锁锁定索引记录之间的区间,阻止其他事务在区间插入;next-key lock 是行锁加间隙锁的组合。范围查询、条件未走唯一索引时可能锁定较大间隙,并发插入被阻塞。其他数据库(如 PostgreSQL)幻读抑制机制不同,不能照搬 MySQL 锁结论。MySQL 锁分析要结合索引与隔离级别;减少间隙锁影响:查询走精确唯一索引、降低范围锁范围。

原理流程

  1. 范围查询在 RR 级别走索引扫描。
  2. 对扫描记录与间隙加 next-key lock。
  3. 其他事务向间隙插入被阻塞。
  4. 事务提交释放。

代码或图示

MySQL InnoDB:
  记录锁:锁定具体行
  间隙锁:锁定记录间区间,阻止插入
  next-key:行锁 + 间隙锁组合
  注意:其他数据库机制不同,勿跨库套用

常见误区

  • 把 MySQL 间隙锁结论套到 PG:PG 用 MVCC 与其他机制控制幻读。
  • 范围条件不走索引:间隙锁定范围扩大,阻塞更多插入。

追问

  • 待确认点是什么?答:当前 MySQL 版本各语句加锁规则与间隙锁行为,以官方锁文档为准。
  • 如何降低间隙锁影响?答:等值查询走唯一索引、避免大范围扫描、评估隔离级别是否必须 RR。

04.4.8.4-059 幂等设计如何与唯一键、重试配合?

一句话结论

写操作带唯一业务键,重试/重复请求用同一键落库被唯一约束识别;消费端按业务键去重,使多次执行结果等价一次执行。

概念解释

幂等保证同一请求执行多次与一次效果相同。手段:客户端生成唯一请求号/业务键;服务端落库前查或靠唯一约束冲突识别重复;消息消费按业务键记录已处理状态。接口重试、MQ 重复投递、用户重复提交都依赖幂等兜底。幂等键要贯穿请求、库表、消息链路。不能只依赖前端按钮置灰。

原理流程

  1. 请求携带唯一业务键。
  2. 写入时业务键入唯一约束。
  3. 重复执行命中冲突,返回首次结果或忽略。
  4. 消费端记录处理状态去重。

代码或图示

幂等链路:
  请求唯一键 → 库表唯一约束 → 冲突识别
  消息消费 → 已处理记录表 → 重复跳过
  重复执行:结果等价,不产生重复副作用

常见误区

  • 重试场景不设计幂等:重复扣款、重复下单。
  • 幂等键每次请求重新生成:去重失效。

追问

  • 幂等记录放哪?答:业务表唯一键或独立去重表,按写操作类型选择;消息消费用消费记录表。
  • 超时后重试如何避免部分成功?答:回查业务状态 + 幂等键,见提交失败处理题目。

04.4.8.4-060 隔离级别与锁策略的选型清单是什么?

一句话结论

先按业务一致性要求选隔离级别,再按冲突率选锁策略;默认读已提交 + 乐观锁/唯一约束,强一致关键流程评估更高级别或悲观锁,全程配合短事务与索引。

概念解释

清单顺序:识别用例一致性需求 → 选隔离级别 → 评估并发冲突 → 选乐观/悲观/约束兜底 → 配合索引与短事务。不要全局拉高隔离级别,也不要在无保护下做并发写。每个关键写入路径明确:一致性要求、冲突概率、兜底约束、重试策略。选型结论要能解释给面试官:为什么这个用例用这个级别。

原理流程

  1. 梳理用例:读取一致性、写入并发、失败补偿需求。
  2. 默认读已提交,特殊场景升级。
  3. 低冲突乐观锁,高冲突悲观锁,唯一约束兜底。
  4. 压测验证冲突率与锁等待。

代码或图示

选型清单:
  一致性要求 → 隔离级别
  冲突概率   → 乐观 / 悲观锁
  唯一性     → 数据库唯一约束
  重试       → 幂等 + 有限退避
  基础保障   → 短事务、精确索引、固定加锁顺序

常见误区

  • 跳过一致性分析直接套默认配置:关键用例保护不足。
  • 锁策略与隔离级别割裂考虑:两者共同决定并发行为。

追问

  • 待确认点是什么?答:目标数据库各级别与锁的精确语义,以官方文档为准。
  • 下一部分是什么?答:分页与深分页优化见 061 题起。

04.4.8.4-061 OFFSET/LIMIT 分页的原理与代价是什么?

一句话结论

offset 分页跳过前 N 行再取 M 行;数据库仍需扫描并排序前 N+M 行再丢弃前 N 行,offset 越大扫描成本越高。

概念解释

LIMIT M OFFSET N 语义:排序后跳过 N 行返回 M 行。数据库执行时不能直接定位到第 N 行,通常扫描候选行、排序、丢弃前 N。深页码时丢弃的工作量随 N 增长。有索引支撑排序时扫描效率改善,但 offset 跳过成本仍在。offset 方案实现简单,适合浅页码与后台管理。前端跳页需求强时才用 offset,无限滚动优先游标。

原理流程

  1. 按排序条件扫描候选行。
  2. 排序(若索引不覆盖)。
  3. 跳过前 offset 行。
  4. 返回 limit 行。

代码或图示

SELECT id, name FROM fruit
ORDER BY id
LIMIT 20 OFFSET 1000;
-- 扫描 1020 行,丢弃前 1000

常见误区

  • 以为 offset 是直接定位:数据库没有按页码随机访问的能力。
  • 深页码仍用 offset:扫描成本随页码线性上升。

追问

  • 索引能消除排序吗?答:排序列有覆盖索引时可避免 filesort,但 offset 跳过仍需扫描。
  • 大 offset 的典型症状?答:深页码响应慢、扫描行数大,执行计划可见扫描行数。

04.4.8.4-062 深分页问题具体表现在哪些方面?

一句话结论

深分页表现为高 offset 扫描丢弃成本大、count 开销高、数据变动导致翻页重复或遗漏;前端无限滚动到深层时体验与性能同时恶化。

概念解释

三个叠加问题:offset 扫描成本、总数 count 成本、翻页一致性。后台列表通常页码浅,问题不明显;面向用户的 feed/滚动列表翻到深层,问题集中爆发。缓解方向:游标分页替代 offset、限制可翻深度、count 估算或不展示总数。业务上识别哪些场景允许「只往下翻」,哪些必须跳页。

原理流程

  1. 深页码到达,offset 增大。
  2. 扫描与丢弃成本上升。
  3. 期间数据增删,位置漂移。
  4. 响应变慢且结果不稳定。

代码或图示

深分页症状:
  扫描行数随 offset 增长
  count 全表估算/统计成本
  翻页期间行位移 → 重复/遗漏
  深层滚动体验下降

常见误区

  • 后台深分页不设上限:用户翻到几千页拖垮数据库。
  • 用缓存总数掩盖列表扫描成本:两个问题独立。

追问

  • 电商订单允许深翻吗?答:通常配合时间范围筛选收窄结果集,或引导搜索条件,而非无限翻页。
  • 待确认点是什么?答:目标库对大 offset 的优化行为,以执行计划实测为准。

04.4.8.4-063 keyset 游标分页如何实现?

一句话结论

游标分页用排序键的上一页末行位置作为条件(如 id > last_id)配合 LIMIT,数据库从游标位置开始扫描,跳过成本与页码无关。

概念解释

keyset 分页不跳过 N 行,而是记住上一页最后一条的排序键值,下一页取该值之后的行。WHERE id > :last_id ORDER BY id LIMIT 20 直接从索引位置开始扫描。要求排序键唯一且稳定,游标随响应返回客户端。缺点:不能跳页(只能上一页/下一页),排序字段变化时游标要携带全部排序键。适合无限滚动、feed 流。

原理流程

  1. 第一页按固定排序取 limit 行。
  2. 记录末行排序键作为游标。
  3. 下一页条件:排序键 > 游标值。
  4. 从游标位置继续取,无 offset 扫描。

代码或图示

-- 第一页
SELECT id, name FROM fruit ORDER BY id LIMIT 20;
-- 下一页:last_id 为上一页末行 id
SELECT id, name FROM fruit
WHERE id > $1 ORDER BY id LIMIT 20;

常见误区

  • 游标用不唯一的排序键:同值行跨页重复或遗漏。
  • 排序顺序与游标条件方向不一致:结果错乱。

追问

  • 能回翻吗?答:可以保存方向,用 < last_id 取上一页;跳页仍不支持。
  • 多列排序怎么做游标?答:携带全部排序列的复合游标(如 (created_at, id) 比较),保证唯一性。

04.4.8.4-064 游标分页对排序键有什么要求?

一句话结论

排序键必须唯一、有序、与索引顺序一致;复合排序时游标携带全部排序列,保证任何两行顺序确定,不会跨页漂移。

概念解释

非唯一排序(如只按 created_at)存在同值多行,游标无法区分先后,翻页重复或漏行。末位追加唯一键(主键)作为兜底排序列。排序键要有对应索引,否则游标条件仍触发全表扫描。排序方向固定,不能每页切换。排序键值不可变(主键或不可变时间戳),更新排序列会导致行位置跳动。

原理流程

  1. 选择排序列,末位补唯一主键。
  2. 建立对应联合索引。
  3. 每页末行提取完整排序键作游标。
  4. 下一页按键值比较取后续行。

代码或图示

游标键要求:
  唯一:并列值可区分
  有序:索引顺序与 ORDER BY 一致
  稳定:排序列不被更新
  复合:多列排序全部进游标

常见误区

  • 排序列允许更新:行在分页中途移动位置。
  • 只有普通索引无联合索引:游标条件走不到索引。

追问

  • 按热度等动态排序能游标分页吗?答:排序值频繁变化时位置不稳定,需要快照排序或接受抖动。
  • 游标编码怎么传递?答:多列键组合编码为不透明游标,服务端解码,不要暴露内部结构。

04.4.8.4-065 分页 count 查询的代价是什么?

一句话结论

COUNT(*) 在大表或复杂条件下要扫描满足条件的行,与列表查询成本接近甚至更高;深分页场景每次翻页都 count 会重复付出代价。

概念解释

总数用于显示「共多少条、多少页」。count 要统计所有满足条件的行,不能用 limit 截断;复杂 join、聚合、非索引条件下成本高。每次翻页重算 count 放大开销。缓解:缓存总数、估算行数、只在首屏取总数、前端不显示总数。count 走索引的程度取决于条件与索引设计。

原理流程

  1. 按相同条件执行 count 统计。
  2. 数据库扫描匹配行计数。
  3. 结果换算总页数。
  4. 翻页时是否重复 count 按策略决定。

代码或图示

-- 与列表同条件的计数
SELECT COUNT(*) FROM fruit WHERE kind = 'tropical';

常见误区

  • 每页翻页都实时 count:重复扫描大表。
  • count 条件与列表条件不一致:总数与页内容对不上。

追问

  • count 能走索引吗?答:覆盖索引且条件可索引时成本较低;复杂条件仍需扫描。
  • 待确认点是什么?答:目标库 count 优化(近似统计、索引计数)能力,以数据库文档为准。

04.4.8.4-066 不精确总数与估算方案有哪些?

一句话结论

可接受不精确时用数据库统计信息估算行数、缓存总数一段时间、或前端不展示总数;牺牲精确性换取分页性能。

概念解释

方案层级:精确 count(准确但慢)、缓存 count(短暂一致,定时刷新)、数据库估算(基于统计信息,偏差随数据波动)、不展示总数(只提供下一页)。按业务容忍度选择:管理后台可精确,feed 流可不显示总数。估算值要标注口径,避免被当成精确数字。缓存 count 要在数据变更后考虑失效策略。

原理流程

  1. 评估业务是否需要精确总数。
  2. 需要精确:优化 count 条件与索引。
  3. 可容忍偏差:缓存或估算。
  4. 不需要:只返回当前页与是否有下一页。

代码或图示

总数方案:
  精确 count     准确,成本高
  缓存 count     定时刷新,短暂不一致
  统计估算       快但有偏差
  不显示总数     仅判断 has_next

常见误区

  • 估算值当精确数字展示:用户预期不符。
  • 缓存 count 永不过期:数据变化后总数长期失真。

追问

  • 怎么判断有没有下一页?答:列表多取一行(limit+1)判断,比 count 便宜。
  • 待确认点是什么?答:目标库估算行数的系统视图与偏差范围,以数据库文档为准。

04.4.8.4-067 各 Rust 数据库访问库的分页写法有何差异?

一句话结论

sqlx 手写 LIMIT/OFFSET 与参数;SeaORM 提供 paginator 封装页大小与总数;Diesel 查询 DSL 用 limit/offset 方法;rbatis 映射语句拼分页 SQL;底层都翻译为方言分页语法。

概念解释

分页抽象程度不同:裸查询库自己拼 limit/offset 与游标条件;ORM 封装分页器对象,管理页大小、总数与页码。跨库方言差异(limit/offset、其他方言分页语法)由框架或语句处理。游标分页在各库都靠手写排序键条件,没有统一魔法接口。面试作答时区分「框架封装分页」与「SQL 方言分页」两层。

原理流程

  1. 确定分页方案:offset 还是游标。
  2. 框架提供的分页器直接配置页大小。
  3. 裸 SQL 手写 limit/offset/游标条件。
  4. 总数按所选方案获取。

代码或图示

// sqlx / 裸查询:手写条件
// SELECT ... ORDER BY id LIMIT $1 OFFSET $2

// SeaORM:paginator(方法名以版本为准)
// Entity::find().paginate(&db, 20)

// Diesel:DSL limit/offset(API 以版本为准)
// users.filter(...).limit(20).offset(40)

常见误区

  • 把 ORM paginator 当游标分页:底层仍是 offset + count。
  • 跨库假设分页语法一致:方言差异需框架或语句隔离。

追问

  • 待确认点是什么?答:各库当前版本分页接口方法名与总数获取方式,以版本文档为准。
  • 游标分页能复用分页器吗?答:标准 paginator 面向 offset,游标条件需自行实现。

04.4.8.4-068 遍历全量数据有哪些方式?

一句话结论

全量遍历可选 keyset 分批、流式查询或分页循环;避免一次性 all 载入内存,每批处理后记录断点,支持中断续跑。

概念解释

后台任务、数据迁移、导出都要遍历全表。方式对比:游标分批稳定可控,每批独立提交;流式查询边读边处理但连接占用贯穿全程;offset 循环深分页成本高。大批量任务记录最后键值作为断点,失败续跑不重跑。批次大小结合内存、事务与数据库负载。遍历过程中数据可能被修改,按业务决定是否需要快照一致视图。

原理流程

  1. 选择遍历方式:游标分批优先。
  2. 按批次大小取数处理。
  3. 记录断点键值。
  4. 失败从断点续跑。

代码或图示

全量遍历:
  游标分批:每批独立,断点清晰
  流式读取:边读边处理,连接占用久
  offset 循环:深批成本高,不推荐

常见误区

  • 一次性查全表到内存:内存峰值随表增长。
  • 遍历任务无断点:失败从头重跑。

追问

  • 遍历期间数据变更怎么处理?答:按业务接受快照视图或新数据;需要一致视图用可重复读事务,但注意快照与版本膨胀。
  • 大批量导出走文件还是流式响应?答:按接口能力选择,分批写入避免内存堆积。

04.4.8.4-069 分页查询如何配合索引设计?

一句话结论

分页排序列与过滤条件应进联合索引,使游标/排序走索引顺序扫描;缺少索引时分页退化为全表扫描加排序,深页尤其慢。

概念解释

列表查询的索引覆盖:过滤条件列、排序列、返回列尽量被联合索引覆盖。游标分页要求索引顺序与排序一致。联合索引列顺序按过滤等值在前、排序在后设计。索引过度也影响写入,按列表查询模式平衡。慢分页先看执行计划:是否走索引、是否 filesort、扫描行数多少。

原理流程

  1. 提取列表查询的过滤与排序列。
  2. 设计联合索引(等值列 + 排序列)。
  3. 验证执行计划命中索引。
  4. 游标条件沿索引定位位置。

代码或图示

索引配合:
  WHERE 等值列 → 索引前导列
  ORDER BY 列  → 索引后续列,顺序一致
  覆盖索引:减少回表

常见误区

  • 只给排序列建索引:过滤条件仍全表扫描。
  • 索引列顺序与查询不匹配:索引不生效。

追问

  • 回表是什么?答:索引未覆盖返回列时,按索引回表取整行,额外随机 IO。
  • 待确认点是什么?答:目标库联合索引最左前缀与索引跳跃扫描规则,以数据库文档为准。

04.4.8.4-070 翻页期间数据增删为什么会导致重复或遗漏?

一句话结论

offset 按当前时刻行位置计数,翻页之间新行插入或旧行删除会使位置平移,导致下一页重复看到上一页行或跳过某些行;游标分页按键值定位,受中间增删影响更小。

概念解释

offset 方案:第一页后有行插入,后续行位置后移,下一页 offset 落到错位位置,重复或遗漏。游标方案按 id > last_id 定位,新插入更小/更大键值的行不影响当前游标之后的顺序(仍取决于键值设计)。删除行使 offset 前移同理。对一致性要求高的列表要么接受短暂漂移,要么用游标 + 固定排序键。

原理流程

  1. 第一页读取并记录位置/游标。
  2. 期间其他事务增删行。
  3. offset 位置相对漂移。
  4. 下一页结果出现重复或遗漏。

代码或图示

offset 漂移:
  翻页间插入 → 行后移 → 重复/跳过
  翻页间删除 → 行前移 → 跳过
游标:按键值比较,中间增删对定位影响较小

常见误区

  • 假设列表在翻页期间不变:活跃业务必然有变更。
  • 用 offset 又要求严格不重不漏:方案不匹配。

追问

  • 订单类列表怎么防漂移?答:游标按创建时间 + 主键排序,或接受业务可接受的轻微重复并以前端去重兜底。
  • 快照一致列表怎么做?答:可重复读事务内完成分页,但长事务代价高,适合小批量导出。

04.4.8.4-071 排序不稳定时如何保证分页结果确定?

一句话结论

排序必须有唯一兜底列(主键),使任意两行有确定先后顺序;避免仅按非唯一列排序导致同值行顺序在两次查询间变化。

概念解释

数据库不保证同值行的返回顺序,只按声明的排序列排序。非唯一列(状态、时间、名称)同值多行顺序不稳定,分页边界处来回跳动。末位补主键后顺序完全确定。排序列更新会改变行位置,设计分页时选择不常更新的排序键。动态排序(用户选列)要保证每次查询排序规则一致。

原理流程

  1. 主排序列 + 唯一兜底列。
  2. 查询按完整排序规则返回。
  3. 同值行按兜底列确定顺序。
  4. 游标携带完整排序键。

代码或图示

-- 不稳定:同 created_at 多行顺序不定
ORDER BY created_at
-- 稳定:主键兜底
ORDER BY created_at, id

常见误区

  • 排序只写业务列:边界行顺序随机。
  • 排序列频繁更新:行位置中途跳动。

追问

  • 用户可切换排序列怎么办?答:每次都带主键兜底,游标按所选排序规则生成。
  • 待确认点是什么?答:目标库对相等键的返回顺序保证,以文档为准;不依赖未定义行为。

04.4.8.4-072 分页场景选型清单是什么?

一句话结论

按交互模式选:浅页码后台管理用 offset 分页器;无限滚动/深层列表用 keyset 游标;总数按业务容忍度选精确/估算/不展示;所有方案配合索引与唯一排序键。

概念解释

选型决策树:是否需要跳页(offset)还是只往下翻(游标);结果集大小;总数是否必须精确;排序键是否稳定。列表查询还要评审索引。混合场景:首屏 offset 取前几页,深翻转游标。方案落地前用真实数据量压测深页表现。接口设计返回页数据、游标与是否有下一页,总数按方案返回。

原理流程

  1. 识别交互:跳页 / 连续滚动。
  2. 识别结果集规模与总数要求。
  3. 选 offset、游标或混合方案。
  4. 核对索引、排序键与总数策略。

代码或图示

决策:
  跳页 + 浅规模 → offset + paginator
  连续滚动 + 深规模 → keyset 游标
  总数:精确 count / 缓存 / 估算 / 不展示
  通用:联合索引 + 唯一排序键

常见误区

  • 所有列表套同一个分页器:交互与规模不匹配。
  • 不压测深页:上线后才发现慢查询。

追问

  • 待确认点是什么?答:所选框架分页接口能力与方言分页语法,以版本文档和数据库文档为准。
  • 下一部分:N+1 与批量加载见 073 题起。

04.4.8.4-073 N+1 查询问题如何识别?

一句话结论

N+1 指先查 N 条主行,再对每行单独查一次关联,共 1+N 次查询;识别方式是看日志/SQL 数量随主表行数线性增长。

概念解释

典型代码:循环主表结果,每次进入关联查询。查询次数 = 1 次主查询 + N 次关联查询,N 大时数据库往返暴涨。识别:接口 SQL 日志出现同一条关联语句重复执行 N 次;慢在往返而非单条 SQL。ORM 不预加载关联时默认就是 N+1。修复方向:join 一次取出、批量 IN 查询、预加载机制。

原理流程

  1. 主查询返回 N 行。
  2. 循环内每行触发一次关联查询。
  3. 关联语句重复 N 次。
  4. 往返次数与 N 成正比,接口变慢。

代码或图示

N+1 形态:
  SELECT * FROM fruit;            -- 1 次
  for each fruit:
    SELECT * FROM basket WHERE fruit_id = ?;  -- N 次
识别:同一关联 SQL 在日志中重复 N 次

常见误区

  • 单条 SQL 都不慢就以为没问题:瓶颈在查询次数与往返。
  • 只看应用循环耗时:没意识到每次循环都查库。

追问

  • ORM 会自动批量关联吗?答:默认不会,需显式预加载或 join,未配置即 N+1。
  • 怎么在测试中暴露?答:开启 SQL 日志,构造多行数据用例,统计查询语句数量。

04.4.8.4-074 用 join 预取关联如何消除 N+1?

一句话结论

主表与关联表 join 一次查询取出两边字段,结果在内存装配;适合关联方向明确、结果集可控的场景。

概念解释

join 把关联数据随主行一次取出,减少往返。一对多 join 会使主行随关联行数膨胀,内存装配时按主行分组。join 条件、过滤与索引要评审,避免多表 join 导致计划恶化。可空关联用 left join。复杂多关联 join 过宽时,拆成批量查询装配可能更清晰。结果映射到自定义 DTO,而非硬塞主表 Model。

原理流程

  1. 确定主表与关联表 join 关系。
  2. 一次查询取主行与关联字段。
  3. 内存按主行分组装配。
  4. 返回聚合后的结构。

代码或图示

SELECT f.id, f.name, b.id AS basket_id, b.volume
FROM fruit f
LEFT JOIN basket b ON b.fruit_id = f.id
ORDER BY f.id;

常见误区

  • 一对多 join 后不分组:主行重复展开,计数与展示错误。
  • 多表大 join 无索引:执行计划恶化,比 N+1 更慢。

追问

  • join 预取与 ORM preload 关系?答:preload 内部可能是 join 或分批查询装配,实现方式按框架确认,目标都是消除逐行查询。
  • 关联很多怎么 join?答:按需取需要的关联,过宽查询拆成几次批量加载。

04.4.8.4-075 用 IN 批量查询消除 N+1 的思路是什么?

一句话结论

先收集主行外键集合,一次 IN (...) 批量取关联行,按外键在内存分组装配;适合一对多、关联表独立查询更清晰的场景。

概念解释

两步查询:主行一次查出,收集外键值;关联表按外键集合一次批量取出,内存映射回主行。查询次数固定为 2(每个关联方向一次),与主行数无关。IN 列表大小受参数数量限制,超大集合分批。相比 join,批量查询避免一对多行膨胀,装配逻辑在应用层。多关联方向可各自批量。

原理流程

  1. 主查询得到主行,收集外键集合。
  2. 关联表 WHERE foreign_key IN (...) 一次取出。
  3. 按外键分组建映射。
  4. 装配回主行结构。

代码或图示

-- 收集 fruit_id 后一次查篮子
SELECT * FROM basket WHERE fruit_id IN (1, 2, 3, 4);
-- 内存:按 fruit_id 分组挂到对应 fruit

常见误区

  • 外键集合为空仍发 IN () 语句:语法错误,先判空。
  • IN 列表过大:参数超限,分批处理。

追问

  • IN 批量与 join 怎么选?答:一对多、怕行膨胀选 IN 批量;一对一、字段平铺选 join;按查询模式实测。
  • 待确认点是什么?答:所选库/驱动参数数量上限与批量接口,以版本文档为准。

04.4.8.4-076 dataloader 思路如何按批次聚合关联查询?

一句话结论

dataloader 把同一轮内收集到的关联键汇总,去重后一次性批量查询,再按键分发回各个调用点;用批量队列消解分散的逐行查询。

概念解释

dataloader 模式常见于 GraphQL 与按需加载场景:调用方逐个请求关联对象,loader 不在当场查库,而是把键收集到本轮批次,触发时合并为一次批量查询(IN 或 join),结果按键映射分发。同一键去重避免重复查询。批次触发时机按调度节奏或数量阈值。Rust 工程可自行实现批量加载器,或选用对应库。本质仍是「收集外键 → 批量取 → 内存装配」,但封装了收集与分发环节。

原理流程

  1. 各调用点请求关联键,进入 loader 队列。
  2. 本轮结束触发批量加载。
  3. 键去重,一次批量查询取回结果。
  4. 按键分发回各调用点。

代码或图示

dataloader 流程:
  请求键 k1, k2, k1, k3
  去重 → IN (k1, k2, k3) 批量查
  结果映射 Map<Key, Value>
  各调用点取回对应值

常见误区

  • 收集批次后仍逐个查:没起到合并作用。
  • 键不去重:批量列表重复且浪费参数。

追问

  • 批次怎么触发?答:按事件循环帧、数量阈值或显式 flush,实现方式按所选库/自研方案确认。
  • 与普通 IN 批量区别?答:IN 批量由业务手动收集;dataloader 自动收集与分发,适合分散调用点。

04.4.8.4-077 各库批量插入的写法有何差异?

一句话结论

sqlx 用多行 INSERT 语句或批量 executor;SeaORM 用 insert_many;Diesel 用批量插入方法;rbatis 用 <foreach> 拼多值;底层都是多行 INSERT,分批大小按参数上限控制。

概念解释

批量插入抽象不同:ORM 接受模型集合生成多行语句,映射式框架在 SQL 模板拼 VALUES 列表,裸查询库手写多行 SQL。各库是否支持批量回填逐行主键取决于方言与接口。大批量必须分批,单批参数与包大小受限。批量失败按批次回滚或记录失败行。具体方法名与返回类型以各库当前版本为准。

原理流程

  1. 收集待插入行集合。
  2. 按批次大小切片。
  3. 各库批量接口生成多行 INSERT。
  4. 检查结果与错误,必要时重试批次。

代码或图示

// SeaORM:insert_many(方法名以版本为准)
// Entity::insert_many(models).exec(&db).await?;

// sqlx:手写多行 INSERT 或批量 executor(API 以版本为准)
// rbatis:<foreach> 拼 VALUES 行

常见误区

  • 成千上万行一批提交:参数/包超限,锁范围过大。
  • 期待批量逐行回填主键:能力按方言确认,不保证。

追问

  • 批量插入冲突怎么处理?答:按方言 upsert/on conflict,或捕获唯一冲突分批定位。
  • 待确认点是什么?答:各库批量插入返回值与主键回填支持,以版本文档为准。

04.4.8.4-078 批量更新如何实现,与逐行更新的取舍?

一句话结论

批量更新用一条 UPDATE ... WHERE key IN (...) 或按条件批量赋值,比循环单行更新往返少;但需要逐行不同值时,用 CASE 表达式或分批单行,注意参数数量与锁范围。

概念解释

同值批量更新(如状态改为已取消)一条条件语句即可。逐行不同值更新:可用 CASE WHEN 拼赋值,或按主键分批单行。批量语句锁范围一次性覆盖多行,要评估锁等待。大批量更新同样分批,避免长事务与大锁段。更新前确认条件命中范围,防止误更新全表。受影响行数用于核对是否全部命中。

原理流程

  1. 判断更新值是否相同。
  2. 同值:条件批量 UPDATE。
  3. 不同值:CASE 表达式或分批单行。
  4. 分批执行,检查影响行数。

代码或图示

-- 同值批量
UPDATE basket SET status = 'closed' WHERE id IN (1, 2, 3);

-- 不同值(示意)
UPDATE basket SET volume = CASE id
  WHEN 1 THEN 10 WHEN 2 THEN 20 END
WHERE id IN (1, 2);

常见误区

  • 不同值也用同值批量:覆盖错误数据。
  • 不带精确条件批量更新:误改大表。

追问

  • 大批量改历史数据怎么减小影响?答:按主键分段分批、错峰执行、每批独立提交,见批量事务粒度题目。
  • 待确认点是什么?答:所选库/ORM 批量更新接口与返回行数,以版本文档为准。

04.4.8.4-079 关联数据在内存中如何装配?

一句话结论

批量取出关联行后,按外键建立索引映射,再遍历主行把对应关联挂到结构上;装配在应用内存完成,避免再次查库。

概念解释

装配步骤:关联结果按外键分组(HashMap),主行遍历查映射填充。一对多映射到 Vec,一对一取单值。注意关联缺失时的空值处理。装配数据量受主行与关联规模约束,超大集合仍需分批。内存结构与 DTO 对齐,不把数据库 Model 直接暴露给接口。装配逻辑可封装在 repository 层。

原理流程

  1. 关联结果按外键分组为映射。
  2. 遍历主行查映射。
  3. 填充单值或集合。
  4. 输出装配后的 DTO 结构。

代码或图示

装配:
  Map<fruit_id, Vec<basket>>
  for fruit in main_rows:
      fruit.baskets = map.get(fruit.id).unwrap_or_default()

常见误区

  • 关联结果未分组,循环内再查找:O(N×M) 退化。
  • 装配结构直接复用数据库实体:字段暴露与耦合。

追问

  • 关联缺失怎么表示?答:一对一为 Option,一对多为空集合,与业务语义一致。
  • 多层关联怎么装配?答:逐层批量加载与装配,每层独立收集键集合。

04.4.8.4-080 IN 查询的参数大小受什么限制?

一句话结论

IN 列表参数数量受数据库协议、驱动与语句长度限制;集合过大必须分批,分批大小结合参数上限、网络包与执行计划评估。

概念解释

数据库对单条语句参数个数、SQL 文本长度有上限;驱动与代理也可能限制。超大 IN 导致语句报错或计划变差。分批后每批独立查询,结果在内存合并。替代方案:临时表/join 装载集合,按数据库能力选择。常见边界:主键集合、批量关联加载的批次大小。不要假设「IN 能放任意多值」。

原理流程

  1. 查数据库/驱动参数上限。
  2. 集合按批次切片。
  3. 每批 IN 查询,结果合并。
  4. 监控单批语句长度与计划。

代码或图示

限制来源:
  数据库参数个数 / SQL 文本长度
  驱动与代理协议限制
  执行计划对大 IN 的稳定性
处置:分批 + 内存合并,或临时表 join

常见误区

  • 把上万主键拼进一条 IN:语句超限或计划退化。
  • 分批后结果未去重:跨批重复值混入。

追问

  • 待确认点是什么?答:目标数据库与驱动的具体参数上限值,以数据库文档和驱动版本为准。
  • 大集合关联还有什么方案?答:临时表或派生表 join,按数据库支持与工程成本选择。

04.4.8.4-081 cache-aside(旁路缓存)的流程是什么?

一句话结论

读路径先查缓存,未命中查库并回填缓存;写路径先更新数据库,再删除(而非更新)缓存;这是应用侧最常见的缓存模式。

概念解释

cache-aside 由应用管理缓存,缓存不替代数据库。读:缓存命中返回,未命中读库、写缓存。写:更新库后失效缓存,下次读重建。与穿透式缓存区别在于缓存逻辑在应用代码。缓存键设计、TTL、空值缓存都属该模式细节。该模式下缓存与库存在短暂不一致窗口,靠失效策略与兜底控制。

原理流程

  1. 读:查缓存 → 命中返回;未命中查库 → 回填缓存。
  2. 写:更新数据库 → 删除缓存键。
  3. 下次读未命中再从库重建。
  4. 缓存设 TTL 作为最终一致兜底。

代码或图示

读:cache → miss → DB → 回填 cache
写:DB 更新 → 删 cache(不更新 cache)

常见误区

  • 写后更新缓存而非删除:并发下旧值覆盖新值风险更高。
  • 缓存不设 TTL:脏数据长期驻留。

追问

  • 为什么写操作删缓存而不是更新缓存?答:更新缓存涉及并发顺序与计算成本,删除让下次读惰性重建,争议更小。
  • 缓存键怎么设计?答:按业务实体 + 标识 + 必要维度,命名规范集中管理。

04.4.8.4-082 read-through 与 write-through/write-behind 有何区别?

一句话结论

read-through 由缓存层在未命中时代读库;write-through 写库同时写缓存(同步),write-behind 先写缓存异步落库;应用侧 cache-aside 最常见,穿透模式由缓存层封装。

概念解释

read-through:应用只跟缓存交互,缓存层负责未命中回源库。write-through:写路径同步写缓存与库,缓存始终有值,但写延迟叠加。write-behind(write-back):先写缓存,异步批量落库,吞吐好但宕机有丢失风险。模式选择看一致性要求、读写延迟与基础设施能力。Rust 工程多数用 cache-aside,专用缓存层才考虑穿透模式。

原理流程

  1. read-through:缓存未命中 → 缓存层回源 → 返回并缓存。
  2. write-through:写缓存 + 写库同步完成。
  3. write-behind:写缓存 → 异步刷库。
  4. 按模式承担各自一致性与风险。

代码或图示

模式:
  cache-aside  应用管理,读回源、写删缓存
  read-through  缓存层代读库
  write-through 同步写缓存与库
  write-behind  先缓存异步落库(有丢失风险)

常见误区

  • write-behind 当强一致:异步刷库期间缓存与库可能不一致。
  • 以为所有缓存都支持穿透模式:取决于缓存中间件与封装。

追问

  • 待确认点是什么?答:所用缓存中间件对穿透/写回模式的支持程度,以中间件文档为准。
  • 工程默认选哪种?答:cache-aside 简单可控;读多写少且回源逻辑复用时考虑 read-through。

04.4.8.4-083 先更新数据库还是先删缓存?

一句话结论

常规做法是「先更新库,再删缓存」;反向「先删缓存再更新库」在并发下更容易出现旧值回填,优先采用更新库后失效缓存。

概念解释

写路径两种顺序:先删缓存再更库、先更库再删缓存。并发场景分析:先删缓存后更库期间,并发读未命中把旧值回填;先更库后删缓存期间,并发读可能读到删前旧缓存,窗口更短且可接受。更稳妥的配套:延迟双删、订阅库变更失效、缓存 TTL。极端一致性仍需版本号或消息失效。缓存更新(写缓存)比删除争议更大,一般不采用。

原理流程

  1. 写请求更新数据库。
  2. 删除对应缓存键。
  3. 并发读未命中时从新库值重建。
  4. 必要时延迟双删或变更订阅兜底。

代码或图示

推荐顺序:
  UPDATE DB → DEL cache
风险窗口:删缓存前的并发读读到旧缓存
兜底:TTL / 延迟双删 / 变更事件失效

常见误区

  • 先删缓存再更库:旧值回填窗口更大。
  • 删除缓存失败不重试:脏缓存长期存在,要有失效重试与告警。

追问

  • 延迟双删怎么做?答:更库后删一次,短暂延迟再删一次,覆盖并发读回填窗口;延迟时长按读耗时评估。
  • 缓存删除失败怎么办?答:重试 + 消息补偿 + TTL 过期,不能静默丢弃。

04.4.8.4-084 缓存并发双写与失效竞态如何控制?

一句话结论

并发读写同一键时,可能出现旧值回填、缓存与库短暂不一致;控制手段:删而非更、版本号比对、变更事件失效、短 TTL 与关键数据不过度缓存。

概念解释

竞态场景:线程 A 读未命中,线程 B 写库删缓存,A 把旧值回填缓存。单靠应用顺序无法完全消除,需要:缓存值带版本/时间戳,回填时版本旧则不写;订阅 binlog/变更消息主动失效;关键强一致数据直接读库。多实例部署下本地缓存还要处理各实例失效通知。缓存一致性是最终一致,按业务容忍度设计兜底。

原理流程

  1. 写路径更新库并失效缓存。
  2. 读回填时比对版本/时间戳。
  3. 变更事件异步刷新各节点缓存。
  4. TTL 兜底收敛脏数据。

代码或图示

竞态控制:
  写后删除缓存
  回填版本校验,旧值不覆盖
  变更订阅主动失效
  TTL 兜底
  强一致数据不走缓存

常见误区

  • 依赖缓存永远与库一致:旁路缓存存在短暂窗口。
  • 多实例本地缓存无失效广播:各节点脏数据长期不同步。

追问

  • 版本号怎么带进缓存?答:缓存值结构含数据版本,回填前对比库版本,旧版本丢弃。
  • 待确认点是什么?答:所用缓存中间件的订阅/失效能力,以中间件文档为准。

04.4.8.4-085 缓存穿透、击穿、雪崩分别是什么?

一句话结论

穿透是查不存在的数据绕过缓存打库;击穿是热点键过期瞬间大量并发打库;雪崩是大批缓存同时失效集中回源;三者都冲击数据库,防控手段不同。

概念解释

穿透:请求键不存在(恶意或巧合),缓存永不命中,反复查库。防控:空值缓存、布隆过滤器、参数校验。击穿:单个热点 key 过期,并发同时未命中重建。防控:互斥重建、热点永不过期加异步刷新。雪崩:大量键同 TTL 同时失效。防控:TTL 加随机抖动、分批过期、限流降级。区分三者成因才能选对手段。

原理流程

  1. 识别回源流量模式:不存在键 / 单热点 / 大批同时失效。
  2. 穿透:空值缓存或布隆过滤。
  3. 击穿:重建加锁或热点保活。
  4. 雪崩:TTL 抖动 + 限流降级。

代码或图示

穿透:不存在 → 缓存空值 / 布隆过滤器
击穿:热点过期 → 互斥重建 / 永不过期
雪崩:批量失效 → TTL 随机抖动 / 限流降级

常见误区

  • 三种问题用同一手段:成因不同,布隆过滤器解决不了雪崩。
  • TTL 全部固定值:同一时刻集中过期。

追问

  • 互斥重建怎么实现?答:用锁/单飞模式保证只有一个请求回源,其余等待结果;具体原语按工程选型。
  • 空值缓存要注意什么?答:短 TTL,避免真实数据插入后长期返回空。

04.4.8.4-086 缓存与数据库一致性有哪些兜底措施?

一句话结论

兜底包括:TTL 自动过期、删除失败重试与消息补偿、变更事件订阅失效、版本号校验回填、关键数据直读库;按数据一致性等级选择组合。

概念解释

没有任何旁路缓存方案能保证强一致,兜底链路覆盖各种失效路径:写后删缓存失败有重试与补偿队列;各实例缓存由变更事件通知失效;回填时版本校验拒绝旧值;TTL 保证最终收敛。强一致要求的数据(余额、库存扣减)不缓存或只读缓存加数据库校验。一致性等级按业务划分:展示类可短暂不一致,交易类直读库。

原理流程

  1. 数据分级:一致要求高的不走缓存。
  2. 写路径删缓存 + 失败补偿。
  3. 变更事件驱动多节点失效。
  4. TTL 与版本校验兜底收敛。

代码或图示

兜底组合:
  TTL 过期收敛
  删除重试 / 补偿消息
  变更订阅失效
  回填版本校验
  关键数据直读库

常见误区

  • 只靠 TTL:脏数据驻留时间过长,写后不主动失效。
  • 补偿消息丢失不监控:失效链路断裂无感知。

追问

  • 缓存一致性怎么监控?答:采样比对缓存与库值、监控回源率与删除失败率。
  • 待确认点是什么?答:中间件提供的失效订阅与事件能力,以官方文档为准。

04.4.8.4-087 本地缓存与分布式缓存如何配合?

一句话结论

本地缓存(进程内)访问快但多实例不一致、容量受限;分布式缓存(Redis 等)共享一致但有网络开销;两级缓存按热点与一致性要求分层使用。

概念解释

本地缓存:无网络开销,命中极快,但每个实例各自一份,失效要广播;容量受进程内存限制。分布式缓存:全实例共享,容量大,每次访问走网络。两级架构:先查本地,未命中查分布式,再未命中查库。本地层 TTL 短、只放极热点;变更失效需要广播通知各节点。注意本地缓存容量淘汰策略与内存占用。Rust 工程本地缓存常用内存 Map + 过期策略,具体 crate 按选型确认。

原理流程

  1. 请求先查本地缓存。
  2. 未命中查分布式缓存。
  3. 再未命中查库并逐级回填。
  4. 数据变更广播失效各节点本地缓存。

代码或图示

两级:
  本地缓存(进程内,短 TTL,极热点)
  分布式缓存(共享,主要容量)
  数据库(回源)
  本地失效:变更广播通知

常见误区

  • 本地缓存不放失效机制:多实例数据长期不一致。
  • 本地缓存无容量上限:进程内存被缓存挤占。

追问

  • 待确认点是什么?答:所选本地缓存 crate 的淘汰策略与过期能力,以 docs.rs 为准。
  • 什么数据只放分布式?答:一致性要求高、容量大、多实例必须共享的数据。

04.4.8.4-088 缓存方案选型清单是什么?

一句话结论

按数据访问模式(读多写少/热点)、一致性等级、容量与失效复杂度选:是否缓存、缓存层级、失效策略与兜底;不要为所有数据加缓存。

概念解释

评估维度:读频次与回源成本、写频次(写多则缓存收益低)、一致性要求、数据规模、过期与失效复杂度。读多写少且容忍短暂不一致适合缓存;频繁写入或强一致数据直读库。清单先判断值不值得缓存,再选模式(aside/read-through)、层级(本地/分布式)、失效与兜底。缓存引入额外复杂度,命中不高的场景反而增加维护成本。

原理流程

  1. 统计读多写少程度与回源代价。
  2. 判定一致性容忍度。
  3. 选缓存模式、层级与键设计。
  4. 配置失效、兜底与监控指标。

代码或图示

选型清单:
  访问模式:读多写少 → 适合缓存
  一致性:强一致 → 直读库
  容量:本地 / 分布式 / 两级
  失效:写后删 + 事件 + TTL
  监控:命中率、回源率、删除失败

常见误区

  • 全量加缓存:写频繁的数据缓存收益低且一致性负担重。
  • 不评估命中率:低命中缓存等于额外一层开销。

追问

  • 缓存命中率多少值得保留?答:按回源成本与缓存维护成本测算,没有固定阈值,结合压测与监控。
  • 下一部分:数据库性能排查见 089 题起。

04.4.8.4-089 EXPLAIN 看哪些关键信息?

一句话结论

EXPLAIN 展示查询计划:访问类型、扫描索引、扫描行数、join 顺序与附加信息;重点看是否走索引、扫描行数与是否有全表扫描/排序。

概念解释

执行计划关键字段:访问方式(全表扫描/索引扫描/索引查找)、所用索引、预估扫描行数、表连接顺序、排序与临时表。预估行数与实际偏差大说明统计信息过期。计划是优化起点,不直接等于实际执行;需要时用 ANALYZE 看真实代价。不同数据库计划格式不同,但核心关注点一致:索引利用、扫描范围、排序与 join 顺序。

原理流程

  1. 对慢查询加 EXPLAIN。
  2. 读取访问类型与索引。
  3. 核对扫描行数与 join 顺序。
  4. 定位全表扫描、filesort、大表 join 等问题。

代码或图示

计划关注点:
  访问类型:全表扫描 / 索引扫描 / 唯一查找
  索引:是否命中预期索引
  行数:预估扫描规模
  排序:是否 filesort、是否临时表

常见误区

  • 只看计划不看实际执行:预估值可能与真实偏差大。
  • 计划走了索引就认为快:回表与扫描行数仍可能偏大。

追问

  • 待确认点是什么?答:目标库 EXPLAIN 输出字段含义,以数据库官方文档为准。
  • 预估行数偏差大怎么办?答:更新统计信息,见 098 题。

04.4.8.4-090 EXPLAIN ANALYZE 与普通 EXPLAIN 有何区别?

一句话结论

EXPLAIN ANALYZE 实际执行查询并输出真实行数、耗时与循环次数;普通 EXPLAIN 只给预估计划。分析慢查询优先用 ANALYZE 看真实瓶颈节点。

概念解释

ANALYZE 实际跑一遍语句,收集每个节点的真实行数、耗时与循环,能发现预估与实际不符的节点。注意:ANALYZE 会真实执行写操作需谨慎(按数据库支持,部分可包装回滚);大结果集语句要限制范围。对比预估与实际差异,定位高估/低估导致的计划选错。真实耗时分布告诉瓶颈在扫描、join 还是排序。

原理流程

  1. 在测试/受控环境对慢查询执行 ANALYZE。
  2. 读取各节点真实行数与耗时。
  3. 对比预估定位偏差节点。
  4. 针对瓶颈调整索引或语句。

代码或图示

EXPLAIN:预估计划,不执行
EXPLAIN ANALYZE:真实执行,输出实际行数/耗时/循环
注意:写语句与大结果集在受控环境执行

常见误区

  • 在生产直接 ANALYZE 大写查询:实际执行可能产生副作用。
  • 只看总耗时:不拆到节点,找不到瓶颈算子。

追问

  • 待确认点是什么?答:目标库 ANALYZE 是否支持回滚写语句、输出格式,以数据库文档为准。
  • 真实行数远大于预估说明什么?答:统计信息过期或索引选择失误,需更新统计或调整索引。

04.4.8.4-091 慢查询日志如何开启与定位问题语句?

一句话结论

数据库慢查询日志记录执行超过阈值的语句,配合行数、耗时与时间戳定位高频慢 SQL;应用侧日志补充语句参数与调用来源。

概念解释

慢日志是数据库侧记录阈值以上语句,包含语句文本、耗时、扫描行数等。阈值按基线设定,过松淹没问题,过严噪音多。分析方向:高频重复慢语句、单次大扫描、特定时间段峰值。数据库慢日志与应用 tracing 关联:语句文本 + 参数 + 调用链路。定期归档慢日志做趋势分析。注意日志不记录敏感明文参数。

原理流程

  1. 配置慢查询阈值与日志输出。
  2. 收集超过阈值的语句。
  3. 按频次/耗时排序定位 Top SQL。
  4. 结合应用日志与执行计划下钻。

代码或图示

慢日志要素:
  语句文本 / 耗时 / 扫描行数 / 时间
  频次聚合:高频 vs 单次重语句
  关联应用链路:来源接口与调用栈

常见误区

  • 只看最慢单条:高频中等耗时语句累计影响可能更大。
  • 慢日志不归档:无法看趋势与回归。

追问

  • 待确认点是什么?答:目标库慢日志开启参数与字段格式,以数据库官方文档为准。
  • 应用侧怎么补充上下文?答:tracing 记录语句模板、参数摘要与接口入口,与数据库日志按时间关联。

04.4.8.4-092 如何判断索引选择是否正确,常见扫描类型有哪些?

一句话结论

看计划中命中的索引是否匹配过滤与排序列;常见类型:全表扫描、索引扫描、唯一索引查找、索引覆盖扫描;选错索引表现为全表扫描、扫描行数大或回表多。

概念解释

理想计划:等值过滤走索引,排序列在索引中,返回列被索引覆盖。常见问题:过滤列无索引、联合索引顺序不匹配、优化器估算选错索引、索引未覆盖导致大量回表。扫描类型对照数据库文档术语。索引不是越多越好:写入维护成本上升。判断后再决定加索引、调整索引顺序或改写语句。

原理流程

  1. 读计划访问类型与索引名。
  2. 核对过滤/排序列是否在索引中。
  3. 评估扫描行数与回表次数。
  4. 必要时新增/调整索引或改写查询。

代码或图示

扫描类型(术语按数据库):
  全表扫描:无索引可用或优化器选择
  索引查找:等值命中少量行
  索引扫描:沿索引范围扫描
  覆盖索引:返回列全部在索引内,免回表

常见误区

  • 有索引就认为被使用:计划可能因估算选择全表扫描。
  • 只加单列索引:联合查询与排序需求未覆盖。

追问

  • 为什么有索引却不走?答:统计信息偏差、索引区分度低、语句条件不匹配索引列顺序,需结合计划分析。
  • 覆盖索引怎么判断?答:SELECT 返回列都在索引中,计划无回表步骤。

04.4.8.4-093 参数化查询与执行计划缓存是什么关系?

一句话结论

参数化(绑定变量)使语句文本稳定,数据库可复用解析与执行计划缓存;字符串拼接动态 SQL 导致语句种类膨胀,计划缓存命中率下降。

概念解释

预编译/参数化把语句模板与参数分离,相同模板复用计划。动态拼接出大量不同文本,每条重新解析生成计划,缓存失效。计划缓存还受参数值分布影响(绑定变量窥探)。应用层必须用绑定参数而非拼值,同时兼顾防注入。框架/驱动的语句缓存行为与数据库侧计划缓存是两层,分别确认。

原理流程

  1. 语句模板固定,参数绑定传入。
  2. 数据库缓存该模板执行计划。
  3. 同模板后续调用复用计划。
  4. 动态拼接文本绕开缓存,逐条解析。

代码或图示

参数化:
  模板固定 → 计划可缓存复用
  值绑定传入,防注入
拼接:
  文本多样 → 计划缓存命中率低,逐条解析

常见误区

  • 为了灵活性拼值进 SQL:既失缓存又有注入风险。
  • 以为参数化就一定复用计划:计划选择还受统计信息与参数分布影响。

追问

  • 待确认点是什么?答:目标数据库计划缓存机制与驱动语句缓存层级,以数据库与驱动文档为准。
  • 标识符能参数化吗?答:表名/列名不能绑定,需白名单控制后进入模板。

04.4.8.4-094 执行计划不稳定与绑定变量窥探如何理解?

一句话结论

同一模板不同参数值的数据分布差异大时,数据库可能为不同值选错计划;绑定变量窥探在首次参数基础上生成计划,后续值复用导致计划不优。

概念解释

执行计划依赖列选择性:某值匹配多行 vs 唯一行,最优计划不同。参数化计划缓存后,首个参数的窥探结果影响后续复用。分布倾斜的表容易出现计划不稳定。缓解:统计信息更新、必要时拆分语句、按数据库能力启用计划重优化。表现为同一语句有时快有时慢,与参数值相关。排查时用 ANALYZE 分别看不同参数计划。

原理流程

  1. 模板首次执行,数据库按首个参数估算计划。
  2. 计划缓存供后续参数复用。
  3. 分布倾斜时复用计划对其他值不优。
  4. 更新统计或调整语句/索引改善。

代码或图示

计划不稳定线索:
  同模板不同参数,耗时差异大
  计划随参数值切换索引/全表扫描
  统计信息陈旧导致估算偏差

常见误区

  • 计划慢就直接加索引:可能是参数分布导致计划选错。
  • 忽略统计信息更新:估算偏差持续存在。

追问

  • 待确认点是什么?答:目标库计划缓存、窥探与重优化策略,以数据库文档为准。
  • 怎么复现对比?答:用不同代表性参数分别 EXPLAIN ANALYZE,比较计划与行数。

04.4.8.4-095 连接等待排队如何与慢查询区分排查?

一句话结论

连接等待是池/代理层拿不到连接,表现为获取阶段耗时;慢查询是拿到连接后语句执行久。两者指标层级不同,根因分别在池容量/泄漏与数据库语句。

概念解释

排查先定位耗时阶段:获取连接前等待(池排队、代理满)还是语句执行中(数据库慢)。池指标看队列与等待时长;数据库侧看活跃语句与锁等待。连接等待常由慢查询/长事务占满连接间接导致,两者可能连锁:慢语句占连接 → 池耗尽 → 新请求排队。处置顺序先释放被占连接(优化慢语句),再谈扩容池。

原理流程

  1. 划分阶段:acquire 等待 vs 执行耗时。
  2. 池指标:队列长度、等待时长、借出占用。
  3. 数据库侧:活跃语句、锁等待、事务时长。
  4. 确定根因链条并处置。

代码或图示

分层排查:
  获取阶段:池排队 / 代理连接满
  执行阶段:慢 SQL / 锁等待 / 长事务
连锁:慢语句占连接 → 池耗尽 → 新请求排队

常见误区

  • 排队就调大池:根因是连接被慢语句占满,扩容只是延缓。
  • 只看应用耗时:不拆阶段,分不清池与库问题。

追问

  • 怎么看数据库活跃连接与语句?答:数据库侧视图查活跃会话、正在执行语句与等待事件,具体视图按方言。
  • 池指标与数据库指标如何对齐?答:按时间线关联应用等待高峰与数据库活跃会话峰值。

04.4.8.4-096 如何检查 ORM 生成的 SQL 是否符合预期?

一句话结论

开启语句日志打印生成 SQL 与参数,对照预期条件、join、排序与分页;重点检查多余 join、错误条件、N+1 与未走索引的语句。

概念解释

ORM 链式 API 与最终 SQL 之间存在转换层,风险:关联预加载产生 N+1、条件拼错、排序缺失、隐式 join。检查方式:开发/测试环境打印语句,评审核心接口生成 SQL;结合执行计划确认索引利用。复杂语句可退回原生 SQL 并映射 DTO。ORM 生成日志要在生产脱敏。每个新增查询接口在测试中观察 SQL 数量与文本。

原理流程

  1. 开启 ORM/驱动语句日志。
  2. 跑代表性请求,收集 SQL 序列。
  3. 核对条件、join、排序、limit 与查询次数。
  4. 慢语句过执行计划,必要时改写。

代码或图示

检查清单:
  WHERE 条件是否完整、参数是否绑定
  JOIN 是否多余或方向错误
  ORDER BY / LIMIT 是否正确
  查询次数:是否 N+1
  计划:索引是否命中

常见误区

  • 只看 Rust 代码不看 SQL:问题在生成层才暴露。
  • 上线后才发现 N+1:测试环境就应统计查询次数。

追问

  • 待确认点是什么?答:所选 ORM 语句日志开关与输出格式,以版本文档为准。
  • 生成 SQL 很差怎么办?答:先调整查询构造与预加载;表达不了的退回原生 SQL 出口。

04.4.8.4-097 如何识别缺失索引与冗余索引?

一句话结论

缺失索引表现为高频查询全表扫描或排序;冗余索引是重复或被其他索引前缀覆盖的索引,徒增写入成本;两者都要结合查询模式与写入开销评估。

概念解释

缺失:慢查询计划走全表扫描/ filesort,过滤与排序列无索引支撑。冗余:多个索引列前缀重叠,或从未被优化器选用。索引维护拖慢写入、占用存储。定期评审:列出高频查询需求对应索引,删除未使用与重复索引。联合索引设计避免单列堆叠。索引调整要在测试环境验证计划变化。

原理流程

  1. 从慢日志与查询统计提取高频条件/排序。
  2. 核对现有索引覆盖情况,补缺失索引。
  3. 检查重复前缀与长期未使用索引。
  4. 评估写入开销后删除冗余。

代码或图示

缺失信号:
  全表扫描、filesort、扫描行数大
冗余信号:
  索引前缀被另一索引覆盖
  长期零使用的索引

常见误区

  • 每个查询列都建单列索引:联合查询用不上,写入负担重。
  • 只加不删:索引越积越多,写入变慢。

追问

  • 待确认点是什么?答:目标库索引使用统计视图,以数据库文档为准。
  • 联合索引列顺序怎么定?答:等值过滤列在前,排序列在后,区分度结合查询模式评估。

04.4.8.4-098 统计信息过时为什么会导致计划选错?

一句话结论

优化器依赖表与列的统计信息(行数、分布、基数)估算代价;统计信息过期时估算偏差大,可能选择低效索引或全表扫描。

概念解释

统计信息记录表规模、列值分布、索引基数等。数据大量增删后统计未更新,估算行数与实际偏离,计划选择失误。表现为计划与实际行数不符(ANALYZE 可见偏差)。数据库自动统计刷新机制 + 手动更新命令结合。大表更新统计要评估锁与资源开销,按窗口执行。统计问题与索引缺失要区分:前者计划估算错,后者根本无索引可用。

原理流程

  1. 数据大量变更后统计滞后。
  2. 优化器按旧分布估算代价。
  3. 选择偏离实际的执行计划。
  4. 更新统计信息后重新评估。

代码或图示

统计信息:
  表行数 / 列基数 / 值分布 / 索引统计
  过期 → 估算偏差 → 计划选错
  处置:自动刷新 + 手动更新(按数据库方言命令)

常见误区

  • 计划差就以为缺索引:可能只是统计过期。
  • 大表随意手动更新统计:资源开销与锁影响需评估。

追问

  • 待确认点是什么?答:目标库统计信息自动刷新策略与手动更新命令,以数据库文档为准。
  • 怎么判断是统计问题?答:ANALYZE 实际行数与预估行数偏差显著,更新统计后计划改善。

04.4.8.4-099 常见的慢 SQL 模式有哪些?

一句话结论

高频慢模式:无索引过滤的全表扫描、深分页 offset、SELECT 取多余列、大表 join 无索引、函数包裹索引列、隐式类型转换、大事务批量写。

概念解释

逐类识别:条件列无索引;深 offset 扫描丢弃;宽行查询取大量列;多表 join 关联列无索引;WHERE func(col)=... 使索引失效;类型不匹配导致转换不走索引;一次性大批量写入持锁久。每种模式对应计划特征与改写方向。评审新 SQL 时对照清单排查。慢语句还要看数据量增长后的退化,小表测试不慢不代表上线快。

原理流程

  1. 从慢日志归类语句模式。
  2. 对照常见清单定位失效点。
  3. 改写语句或补索引。
  4. 测试数据量下验证计划。

代码或图示

慢模式清单:
  全表扫描 / filesort
  深 offset 分页
  多余列与大结果集
  join 关联列无索引
  函数/转换包裹索引列
  隐式类型转换
  大批量单事务写入

常见误区

  • 函数包裹列仍指望走索引:索引列被计算后无法直接使用。
  • 小表测试通过就上线:数据量增长后计划退化。

追问

  • 隐式类型转换怎么发现?答:计划中列被转换函数处理,或字段类型与参数类型不一致;核对表定义与参数类型。
  • SELECT * 有什么问题?答:取多余列增加回表与网络传输,应取必要列。

04.4.8.4-100 数据库性能与事务问题的综合排查清单是什么?

一句话结论

按「连接池 → 事务与锁 → 语句与计划 → 缓存兜底」逐层定位:先看连接是否耗尽与泄漏,再看长事务与锁等待,最后分析慢 SQL 执行计划,缓存层评估回源与一致性。

概念解释

综合清单把本文件各题串成完整链路:池指标区分获取排队与执行慢;数据库侧活跃事务、锁等待与慢日志定位持锁语句;EXPLAIN ANALYZE 定位计划问题;缓存回源率与一致性兜底。优化顺序:先消除泄漏与长事务,再修慢语句与索引,最后调缓存。所有结论以真实指标与执行计划为准,不凭感觉调参。

原理流程

  1. 连接层:池大小、空闲、队列、泄漏、健康检查。
  2. 事务层:事务时长、持锁、等待、死锁。
  3. 语句层:慢日志、计划、索引、参数化。
  4. 缓存层:命中率、回源、失效一致性。

代码或图示

综合排查顺序:
  1. 池:获取等待 / 泄漏 / 长持有
  2. 事务:边界、时长、锁等待、死锁重试
  3. SQL:慢日志 → EXPLAIN ANALYZE → 索引/改写
  4. 缓存:回源率、穿透击穿雪崩、一致性兜底

常见误区

  • 跳层排查:连接未通就优化语句。
  • 只调参数不改根因:扩容掩盖泄漏、长事务与慢查询。

追问

  • 数据访问库选型与写法差异见哪?答:SeaORM/rbatis/tokio-postgres 见 04.4.8.3;SQLx 见 04.4.8.1,Diesel 见 04.4.8.2。
  • 待确认内容如何收尾?答:标注「待确认」并给出数据库官方文档或 docs.rs 验证路径,不写死未经核实的版本行为。