04.4.8.4 连接池事务边界与分页优化
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.4 Rust / 04.4.8 数据访问
04.4.8.4-001 数据库访问为什么需要连接池?
一句话结论
建立 TCP 连接与数据库认证成本高、耗时不可忽略;连接池复用物理连接,避免每次请求重新握手认证,同时把并发连接数控制在数据库可承受范围内。
概念解释
数据库连接包含网络握手、认证、会话状态初始化等步骤,逐条新建在高并发下既慢又会耗尽数据库连接上限。池化把「创建—借出—归还—复用」闭环管理:空闲连接保存在队列,任务借出使用,用完归还而不是关闭。池同时承担容量控制、健康检查与失效重建。没有池化时,每个请求一条新连接,数据库侧连接数随流量线性膨胀。
原理流程
- 应用启动按初始容量建立一批连接。
- 请求到达从池借出空闲连接。
- 使用完毕归还入队,不关闭。
- 连接损坏或超期由池销毁并补建。
代码或图示
无池:请求 → 新建连接(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 当前版本文档为准,不臆造默认数字。
原理流程
- 构造
PoolOptions并设置参数。 connect(url)初始化池与初始连接。- 句柄克隆放入应用状态。
- 查询时获取连接,用完归还。
代码或图示
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 实现不当会把坏连接放回队列,导致后续任务拿到失效连接。
原理流程
- 实现 Manager:
create新建对象,recycle校验可复用性。 - 构造 Pool 并设容量与超时。
- 借出时取空闲对象,必要时
recycle检查。 - 归还入队;不可复用则销毁并补建。
代码或图示
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。
原理流程
- 实现后端 Manager。
builder(manager).max_size(n).build()建池。get()借出连接,结束归还。- 池后台按策略回收或重建连接。
代码或图示
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 这类裸客户端或多后端复用同一池化逻辑。配置能力三者相近:容量、超时、回收、健康检查。工程上不必同时引入两套池;混用会出现两组连接上限与两套监控指标。
原理流程
- 已用 sqlx 查询库:优先内置 Pool。
- 裸客户端后端:选 deadpool 或 bb8 独立池。
- 核对池配置项与后端 Manager 实现。
- 统一池指标与超时治理。
代码或图示
对比:
sqlx Pool 内置,绑定 sqlx 驱动与映射,配置随库
deadpool 通用 Manager 模型,独立池化框架
bb8 通用 Builder 模型,独立异步池
常见误区
- 同一进程同时跑两个池:连接数与监控重复,排错混乱。
- 把通用池的连接强行交给其他库驱动:类型不匹配。
追问
- 独立池能配合 sqlx 用吗?答:通常直接用 sqlx 内置池;独立池面向裸驱动,混用价值低且需自行适配。
- 待确认点是什么?答:三个池当前版本的配置项完整清单,以各自 docs.rs 文档为准。
04.4.8.4-006 连接池大小如何推算?
一句话结论
池大小要结合数据库 max_connections、应用实例数、CPU 核数与查询类型估算:不能盲目调大,目标是让数据库饱和但连接排队不过长。
概念解释
经典经验公式按核数估算连接需求,但真实负载要结合:每实例池上限 × 实例数 ≤ 数据库总连接余量;IO 密集型查询连接等待占比高,计算密集型连接占用 CPU。读多写少与批量任务的连接需求不同。推算方法:先压测观察连接占用、等待队列与数据库负载,再调整上限。预留连接给迁移、运维与其他实例。
原理流程
- 查数据库
max_connections与当前占用。 - 按实例数分摊可用连接余量。
- 压测单实例连接峰值与等待情况。
- 调整池上限并保留运维预留。
代码或图示
推算约束:
单实例池上限 × 实例数 + 其他客户端占用 ≤ max_connections
观察指标:连接利用率、获取等待时长、数据库 CPU/IO
批量任务池与在线请求池可分开设置
常见误区
- 池大小设成等于数据库最大连接:没有预留,运维与其他实例连不上。
- 按 CPU 核数直接套公式不压测:混合负载下偏差大。
追问
- 连接数越多吞吐越高吗?答:不是,超过数据库处理能力后上下文切换与锁竞争加剧,吞吐反而下降。
- 读写分离时池怎么配?答:读库与写库分别建池,按各自容量与流量配上限。
04.4.8.4-007 acquire_timeout 控制什么?
一句话结论
acquire_timeout 是从池获取连接的最长等待时间;池满且连接未及时归还时,请求在队列等待,超过该超时返回获取错误,避免无限挂起。
概念解释
池上限到达后,新请求进入等待队列排队。获取超时保护任务不被无限阻塞:超时后返回错误,上层可快速失败、重试或降级。超时设置要大于正常连接持有时长,又要小于请求整体超时。过短在峰值时误杀正常请求;过长导致请求堆积、资源占用久。该超时与单条查询语句超时是两层独立配置。
原理流程
- 请求尝试从池取连接。
- 有空闲立即返回;无空闲进入等待。
- 等待计时达到
acquire_timeout仍未获取则报错。 - 上层按错误类型决定重试或降级。
代码或图示
// 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 规定连接空闲多久后被池关闭回收;防止长期空闲连接占用名额,也减少被中间代理或数据库主动断开后留下的坏连接。
概念解释
空闲连接不是越留越好:长时间无流量的连接可能被数据库、防火墙或代理静默断开,下次借出才发现失效。空闲超时让池定期回收闲置连接,降低坏连接比例。设置过短会在流量波动时频繁新建连接,握手成本上升;过长则空闲连接堆积且易被断。空闲超时通常小于数据库与代理的空闲断开阈值。
原理流程
- 连接归还后开始空闲计时。
- 期间被复用则重置计时。
- 超过
idle_timeout未使用,池关闭该连接。 - 需要时按容量新建。
代码或图示
// 配置项名称以当前版本 PoolOptions 文档为准
.idle_timeout(std::time::Duration::from_secs(300))
常见误区
- 空闲超时设得比代理断连还长:借出时拿到已被代理关闭的连接。
- 流量低谷频繁建连:空闲过短导致反复握手。
追问
- 待确认点是什么?答:idle_timeout 的默认值与计时重置行为,以 docs.rs/sqlx 或所选池框架文档为准。
- 空闲连接健康检查靠什么?答:回收策略配合借出前
recycle校验,见健康检查题目。
04.4.8.4-009 max_lifetime 与连接最大寿命如何设置?
一句话结论
max_lifetime 限制连接从创建到销毁的总寿命,到期无论是否空闲都被回收重建;用于规避长期连接积累的状态漂移、内存增长与服务端侧老化问题。
概念解释
即使连接一直被复用,长时间存活也可能积累会话状态、临时对象与驱动侧资源。最大寿命让连接定期轮换,保持状态干净。寿命一般设为分钟到小时级,小于数据库侧连接回收策略。注意寿命到期时若连接正在使用,会等当前使用结束再销毁,不强制切断在途事务。设置过短重建频繁,过长失去轮换意义。
原理流程
- 连接创建时记录起始时间。
- 每次借出/归还检查存活时长。
- 达到
max_lifetime标记为待销毁。 - 归还后关闭,池补建新连接。
代码或图示
// 配置项名称以当前版本为准
.max_lifetime(std::time::Duration::from_secs(1800))
常见误区
- 把 max_lifetime 当空闲超时:一个按总寿命、一个按空闲时长,两者独立。
- 寿命到期强行断开在途事务:正确实现应等使用结束再销毁。
追问
- 待确认点是什么?答:到期连接是否等待归还、能否强制关闭,以所选池框架源码与文档为准。
- 为什么不依赖数据库自动断连?答:主动轮换可预测,避免借出时才遭遇服务端清理。
04.4.8.4-010 连接健康检查(recycle/ping)如何做?
一句话结论
借出或回收前对连接做轻量校验(如 SELECT 1 或后端 ping),确认连接仍可用;坏连接销毁重建,避免把失效连接交给业务任务。
概念解释
网络中断、数据库重启、代理超时清理都会让连接表面在队列里、实际已失效。健康检查在借出前或归还时探测:成功则复用,失败则丢弃补建。检查不能太重,否则放大每次获取成本;一般用最简探测语句。检查时机有借出前、归还时两种策略,不同池框架可配置。健康检查与空闲回收配合,覆盖不同断连场景。
原理流程
- 连接待借出或归还。
- 执行轻量探测。
- 探测通过:标记可用。
- 探测失败:销毁连接,按需新建补充。
代码或图示
健康检查策略:
借出前检查:拿到连接先 ping,失败重建后再给任务
归还时检查:归还入队前校验,坏连接不入队
探测语句:最小代价的 SELECT 1 类查询
常见误区
- 完全不检查:坏连接流出到业务,随机报错难复现。
- 检查语句过重:每次借出都跑复杂查询,抵消池化收益。
追问
- 待确认点是什么?答:所选池框架是否支持自定义 recycle 检查与检查时机配置,以 Manager/Builder 文档为准。
- 检查通过就一定可用吗?答:不绝对,检查到使用之间仍可能断连,语句执行错误仍需处理重连。
04.4.8.4-011 连接泄漏是怎么产生的,如何识别?
一句话结论
连接被借出后未归还(句柄被遗忘、事务未结束、任务提前退出)即为泄漏;表现为池占用持续上涨、最终获取超时,识别靠池指标计数与未归还连接追踪。
概念解释
正常路径连接句柄 Drop 时归还池;泄漏路径包括:句柄存入长生命周期结构、任务被取消后连接未释放、事务一直挂起、连接跨任务错误传递。泄漏连接不会自动回收,池上限被占满。识别指标:size 持续升高而 num_idle 趋零、获取等待增长。部分池框架提供泄漏警告(借出后长时间未归还的日志)。
原理流程
- 连接借出,句柄进入业务作用域。
- 作用域结束应 Drop 归还;若句柄被长期持有则不归还。
- 池内可用连接逐步耗尽。
- 新请求排队直至获取超时。
代码或图示
泄漏常见路径:
- 连接句柄存入全局/长生命周期容器
- await 被取消后句柄未清理
- 事务悬挂未提交/回滚
- 异步任务持有连接后不再归还
识别:池占用只增不减、空闲趋近 0、获取超时增多
常见误区
- 把数据库慢查询当成泄漏:慢查询是持有时间长,结束会归还;泄漏是永不归还。
- 泄漏后盲目调大池上限:延缓爆发,根因是未归还路径。
追问
- 池框架能定位泄漏句柄吗?答:部分实现记录借出位置并在超时未归还时告警,能力以当前版本为准。
- 临时缓解手段?答:重启实例释放连接,同时必须修复句柄生命周期。
04.4.8.4-012 池满时的等待队列如何工作?
一句话结论
池达到最大连接数后,新请求在队列等待空闲连接归还;队列按先后顺序唤醒,等待时长受 acquire_timeout 约束,超时返回错误。
概念解释
池内部维护等待者队列:无空闲连接且未达上限时新建;达上限后请求挂起等待。连接归还时唤醒队列首位等待者。队列长度与等待时长是容量信号:持续排队说明连接需求超过池容量。排队不会无限增长,超时机制兜底。不同池框架的公平性(FIFO)与唤醒实现以源码为准。
原理流程
- 请求获取连接:有空闲则借出。
- 无空闲且未满:新建连接。
- 已满:入等待队列挂起。
- 连接归还唤醒等待者;等待超时则报错。
代码或图示
获取流程:
空闲连接存在 → 借出
池未满 → 新建
池已满 → 入队等待 → 归还唤醒 / 超时失败
常见误区
- 排队请求也占用数据库连接:不占用,连接在池中,队列只是应用内等待。
- 忽略队列长度指标:只看连接数看不出排队压力。
追问
- 队列可以设上限吗?答:部分池实现有等待者限制配置,能力以框架文档为准;获取超时始终是兜底。
- 排队过长怎么优化?答:先查连接持有时长(慢查询/长事务/泄漏),再评估扩容。
04.4.8.4-013 池监控有哪些关键指标?
一句话结论
核心指标:当前大小、空闲连接数、已借出数、等待队列长度、获取等待时长、关闭状态;通过这些判断池是否耗尽、泄漏或配置过小。
概念解释
池指标把抽象的连接复用可视化:size 是池内总连接,num_idle 空闲,差值为已借出。等待队列与获取超时反映容量缺口。连接泄漏表现为借出数只增不减。池关闭后新获取直接失败。工程上把指标接可观测系统,设告警阈值(空闲过低、等待升高、超时增多)。具体方法名(size/num_idle/closed)以所选池框架版本为准。
原理流程
- 定期读取池内计数。
- 对比借出/空闲/队列趋势。
- 结合获取耗时与错误率。
- 异常时定位泄漏、慢查询或容量不足。
代码或图示
池指标清单:
size 池内连接总数
num_idle 空闲连接数
已借出 size - idle
waiting 等待队列长度
acquire wait 获取等待时长
closed 池是否已关闭
常见误区
- 只监控连接数不看等待:连接未满但排队已经发生。
- 不区分慢持有与泄漏:两者处置方向不同。
追问
- 待确认点是什么?答:各池框架暴露的指标方法名与是否提供事件钩子,以当前版本文档为准。
- 指标接入哪里?答:跟随工程 tracing/metrics 体系,见 04.4.12 可观测性主题。
04.4.8.4-014 连接断线后池如何重建恢复?
一句话结论
池通过健康检查识别坏连接并销毁补建;新连接按创建流程握手认证。应用层监控池关闭与建连错误,必要时触发重连与告警。
概念解释
数据库重启或网络中断后,池内存量连接全部失效。健康检查在借出时逐个探测,坏连接被替换;池在容量不足时自动补建新连接。若整库不可用,新建失败进入错误与重试循环,恢复后自动补回。重建期间在途请求失败,需要上层容错。连接重建不应由业务代码手工维护,池框架负责补建节奏。
原理流程
- 故障导致存量连接失效。
- 借出探测失败,销毁坏连接。
- 池按容量新建连接,失败则重试。
- 数据库恢复后连接逐步补齐。
代码或图示
恢复路径:
坏连接 → recycle 失败 → 销毁
容量缺口 → 新建连接 → 重试间隔
整库不可用 → 建连错误等待恢复 → 恢复后补齐
常见误区
- 断线后手工清池:正确做法是让池按探测结果替换,避免误删健康连接。
- 不重试新建:数据库恢复后池一直空着。
追问
- 应用启动时数据库还没起来怎么办?答:连接建立可配重试,或启动健康检查阻塞就绪,避免实例带病接流量。
- 待确认点是什么?答:池框架新建失败的重试策略与可配置项,以文档为准。
04.4.8.4-015 PgBouncer 在部署中解决什么问题?
一句话结论
PgBouncer 是 PostgreSQL 连接代理,在多个应用实例与数据库之间复用/汇聚连接,缓解数据库连接数压力;应用连接池与代理池可分层配合。
概念解释
PostgreSQL 每个物理连接有后端进程开销,实例多时直连会撑爆 max_connections。PgBouncer 在中间维护到数据库的连接池,应用连到代理,代理按模式复用后端连接。应用内池仍负责单实例内复用,代理负责跨实例汇聚。两层池大小都要规划,避免应用侧开很大、代理侧排队。PgBouncer 模式对 prepared statement 与会话特性有兼容约束,见后续题目。
原理流程
- 应用连接到 PgBouncer 代理地址。
- 代理按池模式管理到 PG 的后端连接。
- 请求复用或新建后端连接。
- 两层池容量分别规划。
代码或图示
分层:
应用实例 → 应用内连接池 → 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 官方文档为准。
原理流程
- 应用请求到达代理。
- 按模式决定何时绑定/释放后端连接。
- session:整会话持有;transaction:事务持有;statement:语句持有。
- 归还后连接可被其他请求复用。
代码或图示
模式对比:
session 粒度:会话;兼容性:高;复用率:低
transaction 粒度:事务;兼容性:中;复用率:中(常用)
statement 粒度:单语句;兼容性:低;复用率:高
常见误区
- 用 transaction 模式却依赖会话级状态:跨事务保留的设置在复用后丢失。
- 盲目选最细粒度:兼容性问题以难复现的随机错误出现。
追问
- 默认推荐哪种?答:多数应用 transaction pooling,前提是不依赖跨事务会话状态;具体按应用语句特征评估。
- 待确认点是什么?答:当前 PgBouncer 版本对各特性的兼容清单,以官方文档为准。
04.4.8.4-017 transaction pooling 与 prepared statement 有什么兼容问题?
一句话结论
命名 prepared statement 绑定会话后端连接;transaction 模式下连接在事务间被复用,语句归属的后端连接可能已更换,导致语句找不到或冲突;兼容方案是用未命名语句、禁用服务端预编译或切 session 模式。
概念解释
预编译语句是会话级状态:在某后端连接上准备,该连接复用到其他请求时不应被原请求继续引用。transaction pooling 归还连接后,下一个请求可能复用同一后端连接,残留命名语句造成冲突或失效。常见规避:驱动使用简单查询协议(不创建命名服务端语句)、语句只在单事务内使用、或对有需要的连接走 session 模式。应用框架的语句缓存行为要核对。
原理流程
- 连接在后端准备命名语句。
- 事务结束连接归还代理池。
- 另一请求复用该后端连接。
- 原语句引用失效/冲突,触发兼容问题。
代码或图示
兼容风险:
命名 prepared statement 绑定会话连接
transaction 模式连接跨事务复用
规避:未命名/简单查询协议、事务内使用、session 模式专用连接
常见误区
- 只在应用层做语句缓存就认为兼容:语句实际存在服务端会话连接上。
- 出问题时归为随机驱动错误:先核对代理模式与预编译使用方式。
追问
- sqlx 宏生成的语句受影响吗?答:取决于驱动是否创建服务端命名语句,具体行为以 sqlx 当前版本与代理配置为准,需实测验证。
- 待确认点是什么?答:所选客户端/驱动在 transaction pooling 下的语句策略,验证方式为连接日志与代理兼容文档。
04.4.8.4-018 哪些会话级特性在 transaction pooling 下必须注意?
一句话结论
advisory lock、会话级 SET/参数、临时表、会话游标、LISTEN 订阅、命名语句等绑定会话后端状态的特性,在细粒度池化下不能跨事务依赖;需要时走专用连接或 session 模式。
概念解释
这些特性的状态存在后端会话上,连接归还后被其他请求复用,状态不随之迁移。典型坑:事务外设置的参数下条语句失效;advisory lock 持有期间连接不能被归还;LISTEN 绑定连接,连接换道后通知收不到。排查这类问题先区分「数据库事务状态」与「会话状态」。需要强会话粘性的功能,单独建立走 session 模式的连接或固定连接。
原理流程
- 识别特性是否依赖会话状态。
- 评估代理池化模式是否允许状态跨请求保留。
- 不兼容时隔离专用连接。
- 其余普通请求走细粒度池化。
代码或图示
会话绑定特性清单:
advisory lock / 会话参数 SET / 临时表
会话游标 / LISTEN-NOTIFY 订阅 / 命名 prepared statement
处置:专用连接或 session 模式,不进事务池复用
常见误区
- 以为事务回滚会清理所有会话状态:部分会话设置独立于事务。
- 监听通知的连接被池回收:订阅随连接失效。
追问
- 全局参数应该设在哪?答:数据库默认值或连接初始化配置,不依赖请求会话临时设置。
- 待确认点是什么?答:PgBouncer 对各特性的兼容说明,以官方文档特性章节为准。
04.4.8.4-019 事务执行期间连接在池中处于什么状态?
一句话结论
事务开启后连接被该任务独占持有,不计入可复用空闲;事务提交或回滚后连接才归还池。长事务会长期占用连接,加剧池耗尽。
概念解释
借出的连接在事务期间不能被其他任务复用:事务涉及多条语句与一致性视图,共享连接会破坏原子性与隔离性。因此事务长度直接决定连接持有时间。事务内做外部调用、等待用户操作都会拉长占用。池监控看到的「已借出」包含在途事务连接。优化方向是缩短事务边界,而非单纯调大池。
原理流程
- 取连接并开启事务。
- 连接标记占用,不进空闲队列。
- 事务语句执行期间独占。
- 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 克隆后并发共享给多个任务。
原理流程
- Manager 新建连接并 spawn Connection 后台任务。
- 池借出客户端句柄给任务。
- 任务独占执行语句。
- 句柄 Drop 归还;坏连接连同后台任务销毁。
代码或图示
裸客户端池化要素:
Manager:create 建连 + spawn 后台任务,recycle 校验
Pool:队列与容量管理
任务:独占借出的 Client,不并发共享
常见误区
- 多个任务共用一个 Client:协议消息串扰,结果错乱。
- 归还时忘记停后台任务:连接泄漏伴随任务泄漏。
追问
- 池化客户端需要重新 prepare 吗?答:语句状态随连接走,复用连接保留缓存,跨连接需重新准备,见 04.4.8.3 语句缓存题目。
- 待确认点是什么?答:deadpool-postgres 当前版本连接封装与回收 API,以 docs.rs 为准。
04.4.8.4-021 每个请求取一次连接与长借用连接有什么区别?
一句话结论
短借用:每条语句或每个用例从池取连接、用完即还;长借用:连接在一段流程内持续持有。短借用池利用率高,长借用仅在事务等必须独占的场景使用。
概念解释
非事务的独立查询应随用随取,归还后其他任务复用。长借用连接会把池容量占在流程等待上,尤其跨 await 外部调用时。唯一合理的长借用是显式事务:事务内连接必须独占。架构上避免「取一条连接贯穿整个请求处理」,这等于退化成请求级独占连接,池化失效。
原理流程
- 独立查询:取连接 → 执行 → 归还。
- 事务用例:取连接 → BEGIN → 执行 → 结束 → 归还。
- 非事务流程中等待外部响应时不持有连接。
- 连接持有范围最小化。
代码或图示
推荐:
普通查询:即用即还
事务:事务期间独占,结束归还
不推荐:
请求开始取连接,处理完所有逻辑(含外部调用)才归还
常见误区
- 在 handler 入口取连接放状态里全程持有:池并发度被请求数锁死。
- 只读流程也长借用:白白占用名额。
追问
- 同一用例多条独立语句要同一连接吗?答:不需要,各自取连接即可;只有需要事务一致性时才独占。
- 连接可以在函数间传递吗?答:可以在事务边界内传递句柄,但不要传出事务作用域。
04.4.8.4-022 获取超时与语句查询超时是什么关系?
一句话结论
两层独立超时:acquire_timeout 等待获取连接的时间,语句超时控制单条 SQL 在数据库执行的时长;都需要配置,分别应对池排队与慢查询。
概念解释
获取阶段还没拿到连接,等待的是池;拿到连接后执行语句,等待的是数据库。两层超时叠加决定请求最坏耗时。只配获取超时,慢查询会长期占连接;只配语句超时,池满时任务无限排队。语句超时通过数据库侧设置(如配置项或语句级 SET)实现,能力按数据库方言。请求整体超时再外包一层(HTTP/任务超时)。
原理流程
- 获取连接:受 acquire_timeout 约束。
- 执行语句:受语句超时约束。
- 任一层超时返回对应错误。
- 外层请求超时兜底整体生命周期。
代码或图示
超时层级:
acquire_timeout → 池等待上限
语句超时 → 单条 SQL 执行上限(数据库/驱动配置)
请求/任务超时 → 整个用例上限
常见误区
- 认为配了池超时就覆盖慢查询:两层作用阶段不同。
- 语句超时设太长:慢查询占连接拖垮池。
追问
- 语句超时怎么设置?答:按数据库方言的语句超时参数或驱动选项,具体名称以数据库文档为准。
- 待确认点是什么?答:所选查询库是否暴露语句超时配置项,以当前版本文档为准。
04.4.8.4-023 应用池容量与数据库 max_connections 如何匹配?
一句话结论
所有实例应用池上限之和加其他客户端预留,必须小于数据库 max_connections;多层池(代理)容量也要纳入换算,避免总和超出数据库承载。
概念解释
连接预算从上往下分配:数据库总连接先扣除运维、迁移、其他服务预留,剩余按应用实例数分摊单实例池上限。有代理层时,代理到数据库的后端池是另一段预算。容量规划要考虑实例扩容上限,不能按当前实例数算满。数据库侧连接耗尽会拒绝新连接,应用表现为获取失败。上线前用压测验证连接峰值。
原理流程
- 读取数据库
max_connections与现有占用。 - 预留运维与其他客户端份额。
- 按实例数与扩容上限分摊应用池。
- 压测校验峰值连接不超预算。
代码或图示
连接预算:
max_connections
- 运维/迁移/其他服务预留
- 代理后端池占用(若有)
= 应用可用连接
应用可用 ÷ 实例数 ≈ 单实例池上限
常见误区
- 各实例独立设大池,总和超出数据库:整体连接拒绝。
- 忘记预留迁移/运维连接:高峰期 DBA 无法登录排查。
追问
- 扩容实例时池要下调吗?答:是,实例数增加后单实例池上限应同步下调,保持总预算不变。
- 数据库连接数能调大吗?答:受内存与进程开销约束,盲目调大反而降低稳定性。
04.4.8.4-024 连接串、TLS 与池配置如何组织?
一句话结论
连接信息按环境配置注入(环境变量/配置中心),池参数与连接串分离管理;TLS 配置随池建立一次生效,敏感凭据不写进代码与日志。
概念解释
池配置包括:连接地址凭据、池容量、各类超时、TLS 模式。开发、测试、生产环境参数不同,通过配置层注入。凭据属于敏感信息,不提交仓库、不打印日志。TLS 校验模式按环境区分:生产强制校验证书,本地开发可宽松但不得带入生产。池在启动时建立,配置变更需重启或重载连接。
原理流程
- 从配置源读取连接串与池参数。
- 构造 TLS 连接器。
- 建池并健康检查。
- 运行期凭据与日志保持脱敏。
代码或图示
配置分组:
连接:host/port/user/password/dbname/sslmode
池:max_connections / 超时 / 回收策略
TLS:证书与校验模式(生产严格)
常见误区
- 凭据写死在示例代码并提交:隐私泄露。
- 开发环境宽松 TLS 复制到生产:证书校验被绕过。
追问
- 待确认点是什么?答:所选池/驱动的 TLS 配置入口与支持的后端实现,以版本文档为准。
- 连接串里的密码会出现在错误日志吗?答:注意日志脱敏,错误信息与配置打印避免带凭据。
04.4.8.4-025 连接池问题的综合排查清单是什么?
一句话结论
按「连接能否建立 → 池容量是否耗尽 → 连接是否泄漏/长持有 → 健康检查是否生效 → 两层超时是否合理」顺序定位,先看指标再看语句。
概念解释
池问题表象分三类:建连失败(网络/认证/TLS/数据库满)、获取排队(容量不足或归还过慢)、使用时报错(坏连接/解码/语句)。排查先读池指标区分阶段,再下钻。不要在没看指标前盲目调大池或改语句。常见根因:连接泄漏、长事务、慢查询、代理兼容、配置超时不合理。
原理流程
- 检查建连:网络、凭据、TLS、数据库连接余量。
- 读池指标:size/idle/queue/等待时长。
- 区分泄漏(不归还)与长持有(慢/事务)。
- 核对健康检查、超时与代理兼容配置。
代码或图示
排查顺序:
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 层开事务,业务规则泄漏到接口层且难以复用。分层后事务策略可按用例统一调整。
原理流程
- handler 解析请求,调用 service 用例。
- service 开启事务,编排多个 repository 操作。
- 全部成功提交,任一失败回滚。
- 结果返回 handler 转换响应。
代码或图示
分层:
handler 请求/响应转换,不开事务
service 事务边界,编排用例步骤
repository 单表/单聚合数据访问,加入外层事务
常见误区
- repository 方法各自 commit:跨表写入部分成功。
- handler 里拼事务逻辑:业务用例换个入口就漏事务。
追问
- 一个 service 方法能调另一个带事务的 service 吗?答:嵌套时明确传播行为(加入外层事务还是新开),避免双重提交语义混乱。
- 只读用例需要事务吗?答:可走只读事务或普通查询,见只读事务题目。
04.4.8.4-027 事务内部不应该做哪些事情?
一句话结论
事务内避免外部 HTTP/RPC 调用、消息发送、等待人工确认、长耗时计算;这些操作拉长事务持有时长,占用连接与锁,放大死锁与池耗尽风险。
概念解释
事务持有数据库连接、行锁与一致性视图,事务越长这些资源占用越久。外部调用时长不可控(下游超时、重试),把它放进事务等于把数据库资源押在外部可用性上。正确顺序:事务内只做数据库读写,外部副作用在事务提交后执行;需要一致性时用 outbox/消息表模式补偿。批处理大事务也要拆分批次。
原理流程
- 开启事务前准备好所有入参与外部数据。
- 事务内只执行数据库读写。
- 提交后再发消息、调外部接口。
- 外部失败走补偿或重试机制。
代码或图示
事务内禁忌:
外部 HTTP / RPC / MQ 发送等待
人工审批等待
大段同步计算与文件处理
跨长时间的批量遍历
推荐:事务内短读写,副作用提交后处理
常见误区
- 「先调外部成功再开事务」:外部成功而库写入失败,产生不一致。
- 事务内循环发消息:消息发送失败回滚数据库,但已发消息无法撤回。
追问
- 必须先有外部单号怎么办?答:先取外部单号落库(短事务),主流程后续步骤再用;或设计补偿流程。
- 消息发送怎么保证与库一致?答:outbox 模式,见 034 题。
04.4.8.4-028 事务与 await 跨任务有什么注意事项?
一句话结论
事务连接绑定在持有它的任务上,不能把事务句柄随便传到其他 spawn 任务并发使用;跨任务传递会破坏连接独占性,任务取消也可能导致事务悬挂。
概念解释
异步事务句柄包含独占的数据库连接,连接不能被两个并发任务共享。spawn 出的任务若拿走事务连接,原任务与新任务交替使用同一连接,协议状态错乱。任务被取消时事务可能未提交也未回滚,连接悬挂占用。需要并行查询时各取独立连接;需要同事务的步骤顺序执行在同一任务内。异步运行时取消传播要能触发事务清理。
原理流程
- 事务在当前任务内开启。
- 事务内步骤顺序 await 执行。
- 不把事务句柄送入并发任务。
- 任务退出时确保 commit/rollback 路径执行。
代码或图示
// 错误倾向:把 tx 交给 spawn 的并发任务共享同一连接
// 正确:并行只读各自取连接;写步骤留在事务任务内顺序执行
常见误区
- 为了并发把事务连接 clone 到处传:协议状态串扰。
spawn的后台任务持有事务:主流程结束后事务悬挂。
追问
- 异步任务取消时事务会回滚吗?答:取决于句柄 Drop 行为与运行时取消传播,需核对框架实现;关键路径要有超时与回滚保障。
- 待确认点是什么?答:所选 ORM/驱动事务句柄的 Drop 语义,以当前版本文档为准。
04.4.8.4-029 事务与 HTTP 请求生命周期如何配合?
一句话结论
事务应在请求处理线程/任务内开启并在同一请求内结束,不跨越请求生命周期;请求结束时事务必须已提交或回滚,连接归还池。
概念解释
把事务挂在长生命周期状态里跨请求复用,会导致连接长期占用、隔离状态混乱,且下一请求看到未提交上下文。每个请求独立建立自己的事务边界:进入 service 开事务,响应返回前结束。异步任务/后台流程有自己的事务边界,不挂在请求对象上。请求超时中断时,事务要能被清理回滚。
原理流程
- 请求到达,进入 service 用例。
- 事务在请求任务内开启。
- 用例执行完提交/回滚。
- 响应返回前连接已归还池。
代码或图示
请求生命周期:
接收 → service 开事务 → 读写 → 结束事务 → 响应
禁止:事务存入应用状态跨请求保留
常见误区
- 连接/事务放全局状态:跨请求污染且泄漏。
- 响应已返回而事务仍在后台悬挂:连接不归还。
追问
- 后台发消息能借用请求事务吗?答:不能,后台任务用自己的连接与事务,请求事务提交后再投递。
- 请求超时后数据库事务状态?答:连接随任务清理回滚,需验证驱动 Drop 行为并设置语句/事务超时。
04.4.8.4-030 事务提交失败或连接断开时如何处理?
一句话结论
提交阶段失败原因可能是约束冲突、连接中断或数据库故障;此时事务状态不确定(未提交还是已提交),不能盲目重试写操作,需先查明状态再决定重试或补偿。
概念解释
执行语句阶段失败通常明确回滚;提交阶段失败更棘手:网络断在 COMMIT 前后,数据库可能已提交。应用层不能假设「提交失败就没写入」。处理:错误分类(约束可重试修正、连接断开需查状态)、关键写操作带幂等键、必要时回查业务状态。连接断开的事务由数据库/连接清理结束,不会半提交悬挂。
原理流程
- 提交调用返回错误。
- 区分错误类型:约束冲突 / 连接中断 / 数据库故障。
- 连接中断场景按业务键回查是否已落库。
- 未提交则重试;已提交则走后续步骤。
代码或图示
提交失败处置:
约束冲突 → 业务错误,不盲目重试
连接断开 → 回查状态,避免重复写入
数据库故障 → 有限重试 + 告警
写入操作带幂等键兜底
常见误区
- 提交失败直接重放整个写流程:可能产生重复订单/重复扣款。
- 不区分语句错误与提交错误:重试策略错误。
追问
- 怎么回查是否已提交?答:用唯一业务键查询目标行是否存在及状态,查询本身走新连接。
- 待确认点是什么?答:驱动在连接断开时对事务结束状态的报告方式,以错误文档为准。
04.4.8.4-031 嵌套事务与保存点在工程上怎么用?
一句话结论
嵌套业务步骤需要局部回滚时用保存点;绝大多数 service 编排用单一外层事务即可,嵌套事务不等于独立提交,提交边界仍由最外层决定。
概念解释
数据库没有真正嵌套事务,内层「事务」映射为保存点。工程上很少显式嵌套:service 调用链共享一个事务上下文。只有内层步骤需要失败重试且不影响外层已完成步骤时,才用保存点。过度嵌套增加排错复杂度。ORM 封装的嵌套事务行为(保存点、命名)按版本确认。
原理流程
- 外层事务 BEGIN。
- 需要隔离的步骤前建保存点。
- 内层失败回滚到保存点重试。
- 外层统一提交或整体回滚。
代码或图示
使用判断:
普通多步骤 → 单事务顺序执行
内层可重试隔离 → 保存点
独立一致性边界 → 新开事务(注意不是嵌套)
常见误区
- 以为内层 commit 会独立落库:外层未提交前都可整体回滚。
- 每层 service 都开事务:提交边界错乱。
追问
- 跨聚合的两个独立一致性边界怎么办?答:开两个事务,用 saga/补偿保证最终一致,见 042 题。
- 待确认点是什么?答:所选框架嵌套事务是否生成保存点及接口名称,以文档为准。
04.4.8.4-032 测试中如何用事务回滚隔离测试数据?
一句话结论
集成测试可在测试外层开一个大事务,每个用例在其中执行,结束回滚;或用保存点按用例回滚,避免测试数据污染彼此、加快清理。
概念解释
测试隔离常见方案:每个用例独立库/表、用例后清理、事务回滚。事务回滚方案:测试连接开启事务,用例内 repository 操作都在该事务内,用例结束整体 rollback,数据不落库。注意外部可见状态(缓存、MQ、搜索索引)不会随数据库回滚,需要单独清理。事务回滚方案要求测试代码能拿到同一事务连接。
原理流程
- 测试开始开启外层事务。
- 用例通过该事务连接执行业务代码。
- 断言验证结果。
- 用例结束回滚,下个用例从干净状态开始。
代码或图示
测试事务方案:
外层 BEGIN
用例 A 操作 → 断言 → ROLLBACK(或回滚到保存点)
用例 B 从干净状态开始
注意:缓存/MQ/索引状态需另行清理
常见误区
- 业务代码自己提交事务:测试外层回滚被内层 commit 打断。
- 以为回滚能清掉外部副作用:消息、缓存、文件不在数据库事务内。
追问
- 这种方案能测真实提交路径吗?答:部分掩盖 commit 行为,关键提交场景另写独立事务用例验证。
- 多线程测试能用同一事务连接吗?答:不能并发共享,测试并发要各自连接或独立库。
04.4.8.4-033 测试数据清理有哪些替代方案?
一句话结论
除事务回滚外,还有用例后按标记清理、每个用例独立 schema/库、预先准备固定数据集;按测试速度、隔离强度与副作用范围选择。
概念解释
清理方案对比:事务回滚最快但不覆盖外部副作用;按业务标记删除可清理落库数据但写删除逻辑;独立库/schema 隔离最彻底但初始化慢;固定数据集适合只读场景。集成测试与单元测试策略不同:repository 测试可落库清理,service 测试可用替身。方案要保证用例间不依赖执行顺序。
原理流程
- 识别测试涉及的存储与副作用。
- 选择回滚/清理/独立库方案。
- 准备数据集与清理钩子。
- 验证用例顺序无关性。
代码或图示
清理方案:
事务回滚 快,仅库内,外部副作用另清
标记删除 落库后清理,需写删除路径
独立库 隔离彻底,初始化成本高
固定数据集 只读场景复用
常见误区
- 用例依赖上一个用例残留数据:顺序一变就失败。
- 清理逻辑本身有 bug:测试数据越积越多影响后续。
追问
- 测试库能用生产同构 schema 吗?答:是,迁移在测试库执行一遍,保证结构一致。
- 外部副作用怎么隔离?答:测试环境用替身/沙箱,或独立队列与命名空间。
04.4.8.4-034 本地消息表(outbox)模式如何保证库写入与消息发送一致?
一句话结论
业务数据与待发消息写在同一个本地事务里(outbox 表),提交后由独立投递器读取未发消息发送 MQ/外部接口,失败重试;避免「库提交了消息没发」或「消息发了库回滚」。
概念解释
分布式一致性的本地方案:事务内同时写业务表与 outbox 消息记录,原子提交。后台任务扫描 outbox 表,投递成功后标记状态;投递失败重试,保证至少一次投递。消费端按幂等处理重复消息。outbox 把跨系统一致性拆成「本地事务一致 + 异步可靠投递」,不依赖分布式事务。消息顺序、重复投递、积压监控都要配套设计。
原理流程
- 业务事务内写业务行与 outbox 行(同事务提交)。
- 投递器轮询/订阅未发送消息。
- 发送成功标记已投递;失败重试并记录次数。
- 消费端幂等消费。
代码或图示
outbox 流程:
BEGIN → 写业务数据 + 写 outbox 消息 → COMMIT
后台:取 outbox 未发 → 投递 → 标记成功/重试
消费端:幂等处理重复消息
常见误区
- 事务内直接调 MQ:MQ 发送不参与数据库事务,失败即不一致。
- outbox 消息不标记状态:重复投递或反复扫描。
追问
- 消息顺序怎么保证?答:按业务键分区与排序投递,必要时消息带序号;具体取决于 MQ 能力。
- 至少一次投递带来重复怎么办?答:消费端用唯一业务键去重,见幂等设计题目。
04.4.8.4-035 事务消息与最终一致性的关系是什么?
一句话结论
本地事务保证库内一致,跨系统靠可靠消息 + 幂等消费达到最终一致;不追求跨库强一致,而是接受短暂不一致并通过重试与补偿收敛。
概念解释
分布式场景下跨库/跨服务强一致代价高,多数业务采用最终一致:本地事务先落库,消息驱动下游更新,失败重试,异常走补偿。最终一致需要:消息可靠投递、消费幂等、重试与死信、对账兜底。业务上明确哪些数据允许短暂不一致。不要把最终一致当成「不用管一致性」,仍要有收敛机制与监控。
原理流程
- 本地事务提交业务状态。
- 可靠通知下游(outbox/MQ 事务消息)。
- 下游幂等处理,失败重试。
- 对账任务发现不一致并补偿。
代码或图示
最终一致链路:
本地事务 → 可靠消息 → 幂等消费 → 重试/死信 → 对账补偿
常见误区
- 没有幂等就指望消息不重复:重试必然带来重复投递。
- 没有对账:失败消息静默积压,不一致长期存在。
追问
- 哪些场景必须强一致?答:资金扣减类核心约束按业务要求评估,仍可用本地事务 + 幂等 + 对账,跨库 2PC 慎用。
- 事务消息(MQ 半消息)方案与 outbox 区别?答:outbox 基于本地表轮询,MQ 事务消息依赖中间件能力,选型按基础设施确认。
04.4.8.4-036 跨库事务的 2PC 局限与本地方案如何取舍?
一句话结论
两阶段提交(2PC)理论上跨库强一致,但同步阻塞、性能差、协调者单点与故障恢复复杂;高并发业务通常放弃 2PC,改用本地事务 + outbox/ saga 补偿的最终一致方案。
概念解释
2PC 要求所有参与方预备后统一提交,协调者驱动;阻塞期间各库持锁,节点故障可能悬挂,扩展性差。Rust 生态中跨库 2PC 支持有限,工程上少见。替代方案:按业务边界拆分本地事务,事件驱动下游,失败补偿;资金等强约束场景用对账与幂等兜底。设计阶段先判断是否真的需要跨库原子性,多数「跨库一致」可拆为最终一致。
原理流程
- 评估一致性要求:强一致还是最终一致可接受。
- 强约束场景评估 2PC 成本与基础设施。
- 一般场景拆分本地事务 + 事件/补偿。
- 对账兜底残留不一致。
代码或图示
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 也是闭包式,闭包内用同一连接执行。无论哪种,事务内必须使用事务句柄对应的连接,不能混用池内其他连接。具体方法名、错误类型与闭包返回约束以各库当前版本为准。
原理流程
- 从池/连接开启事务。
- 事务句柄传入各数据访问调用。
- 闭包
Ok提交、Err回滚(句柄式需显式 commit/rollback)。 - 连接归还池。
代码或图示
// 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 写入、部分隔离优化),并在应用误写时直接拒绝;用于一致性读的批量查询场景。
概念解释
只读事务告诉数据库该事务只执行读操作,写语句被拒绝。它保证事务内多次读取处于一致快照(按隔离级别),适合批量导出、报表对账这类需要一致视图的查询。只读事务同样持有连接,仍需控制时长。开启方式按数据库方言与驱动支持,标记可能是事务属性或语句级设置。普通单条查询不必特意开只读事务。
原理流程
- 以只读模式开启事务。
- 事务内执行多条一致读取。
- 写操作被数据库拒绝。
- 提交/回滚释放连接。
代码或图示
只读事务适用:
批量导出需要一致快照
对账/报表多次读取保证视图一致
不适用:任何包含写入的用例
常见误区
- 只读事务当性能银弹:主要收益是一致视图与写保护,读性能提升有限。
- 只读事务内仍尝试写入:被拒绝后报错中断。
追问
- 待确认点是什么?答:所选驱动/ORM 开启只读事务的接口与数据库方言支持,以文档为准。
- 只读事务能避免长读锁吗?答:MVCC 下读通常不阻塞写,但仍受隔离级别与数据库实现约束。
04.4.8.4-039 事务内连接什么时候不会归还池?
一句话结论
连接在事务 commit/rollback 完成、事务句柄 Drop 后才归还;事务未结束、句柄仍被持有、任务悬挂或出错未清理时,连接一直被占用。
概念解释
归还时点容易被误判:返回了响应不代表连接已归还,关键看事务句柄生命周期。泄漏路径见连接池题目;事务场景下常见悬挂是:闭包提前 return 但句柄未清理、await 被取消、句柄存入长生命周期结构。监控上表现为借出数居高不下。代码评审要检查事务句柄的作用域退出路径。
原理流程
- 事务开启,连接借出占用。
- 正常结束 commit/rollback。
- 句柄 Drop,连接归还。
- 异常路径未清理则连接悬挂不归还。
代码或图示
不归还路径:
事务未结束句柄仍在作用域
任务取消后清理未执行
句柄被存入全局/长生命周期结构
出错路径漏了回滚
常见误区
- 以为查询结束连接就归还:显式事务内要等事务结束。
- 只测正常路径:异常取消路径才是泄漏高发处。
追问
- 如何发现悬挂事务?答:池指标借出不下降,数据库侧查看活跃事务与连接时长。
- 框架能自动回滚悬挂事务吗?答:句柄 Drop 语义与运行时取消行为需按驱动确认,不能依赖未验证的自动清理。
04.4.8.4-040 乐观重试与事务如何配合?
一句话结论
乐观锁冲突(版本号不匹配)通常回滚当前事务后,重新读取数据并重试用例;重试在事务外编排,事务内只做一次尝试,避免在事务里反复自旋等待。
概念解释
乐观并发控制:更新时检查版本,冲突则放弃本次事务。重试循环放在 service 层:重新取数、开新事务、再写。重试次数与退避有限制,区分可重试冲突与不可重试业务错误。事务内不做重试等待,否则长占用连接。重试必须保证整个用例幂等,重复执行不产生副作用。
原理流程
- service 读当前数据与版本。
- 开事务尝试写入,带版本条件。
- 版本冲突回滚,记录一次失败。
- 有限次重新开始用例,超限报错。
代码或图示
重试编排(事务外):
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 日志膨胀、锁范围大、失败整体回滚成本高、连接占用久。分批后每批独立提交,失败只回滚当前批,已提交批次保留并记录断点。批大小结合参数上限、锁影响与数据库负载实测调整。批间可短暂让出资源。批量任务还要记录进度,支持断点续跑。
原理流程
- 读取待处理集合与断点。
- 按批次切片。
- 每批开启事务、写入、提交。
- 失败回滚当前批,记录位置,重试或人工介入。
代码或图示
批量策略:
小批事务:锁范围小,回滚代价低
批次大小:参数上限 / 锁影响 / 实测吞吐
断点记录:失败续跑不重跑已提交批
常见误区
- 全量一个事务:长事务 + 大回滚段。
- 每行一个事务:往返过多,吞吐低。
追问
- 批次需要整体一致吗?答:业务要求全成功或全失败时才大事务;一般批处理接受部分成功 + 失败重试。
- 大批量迁移怎么减小锁影响?答:错峰执行、分批、控制每批行数,必要时在线变更方案。
04.4.8.4-042 saga 模式与补偿事务如何设计?
一句话结论
saga 把长业务流程拆成一系列本地事务,每步有对应补偿动作;某步失败时按相反顺序执行已完成步骤的补偿,达到最终一致。
概念解释
跨服务/跨聚合的长流程不持有一个全局事务,而是步骤化:每个步骤本地事务提交,记录步骤状态;失败触发补偿(退款、撤销、回滚库存)。补偿动作本身要幂等且可重试。saga 分编排式(中央协调器)与协同式(事件驱动)。不是所有动作都可补偿(如已对外发通知),设计时识别不可逆步骤并预留人工处理。
原理流程
- 定义流程步骤与各自补偿动作。
- 步骤本地事务提交,记录状态。
- 后续步骤失败,反向执行补偿。
- 补偿失败重试,超限转人工。
代码或图示
saga 顺序:
T1 提交 → T2 提交 → T3 失败
补偿:C2 → C1
每步与补偿都要幂等、可重试
常见误区
- 补偿动作不幂等:重复补偿造成二次撤销。
- 忽略不可逆步骤:补偿无法回退外部已生效动作。
追问
- saga 与 outbox 怎么配合?答:步骤间事件投递用 outbox 保证可靠,saga 协调状态推进流程。
- 补偿失败怎么办?答:重试 + 死信 + 人工干预队列,不能静默跳过。
04.4.8.4-043 审计日志写入应不应该放在业务事务内?
一句话结论
审计记录通常与业务数据同事务写入,保证业务变更与审计痕迹一致;但审计量大时可异步落库,接受审计最终一致并保证不丢。
概念解释
同事务写审计:业务回滚则审计不残留,一致性强,代价是多写一张表与事务时长。异步审计:业务提交后发事件写日志,吞吐好但可能短暂丢失,需要可靠投递。合规要求强的审计一般不允许丢失,优先同事务或 outbox。审计表只追加不改写,写入模型与业务表分离。注意审计内容不含敏感明文。
原理流程
- 业务事务内写业务行与审计行(同提交)。
- 或业务提交后经 outbox 投递审计事件。
- 审计只追加,保留变更前后值与操作主体。
- 异步方案监控投递积压。
代码或图示
审计方案:
同事务:一致性强,事务略重
outbox 异步:吞吐好,需可靠投递与积压监控
审计字段:变更前后值、操作人、时间、原因
常见误区
- 审计日志打印到应用日志就完事:应用日志可清理,合规审计需持久化存储。
- 同事务写大量审计明细:拖长核心事务。
追问
- 审计表需要业务索引吗?答:按查询主体/时间范围建索引,写入为主避免过多索引。
- 待确认点是什么?答:合规要求按业务场景确定,技术方案对齐审计留存周期与不可篡改要求。
04.4.8.4-044 为什么说「一个业务用例一个事务」?
一句话结论
事务边界应与业务用例的原子性需求对齐:一个用例内必须同生共死的操作放同一事务;用例之间独立事务,避免不必要的锁范围与耦合。
概念解释
判断哪些操作同属一个用例:它们是否必须一致成功或回滚。属于同一用例的多张表写入放一个事务;不同用例、可独立重试的操作分开。过宽事务把无关操作卷入,拉长锁与连接占用;过窄事务破坏用例原子性。用例划分来自业务领域,不是表数量。接口层只触发用例,不决定边界。
原理流程
- 梳理用例:触发动作、涉及写入、一致性要求。
- 必须原子的操作归入同一事务。
- 可独立成功的操作拆分。
- 跨用例一致性用消息/补偿方案。
代码或图示
用例边界判断:
必须同时成功/回滚 → 同事务
可独立提交、失败可补偿 → 分开事务
外部副作用 → 提交后异步
常见误区
- 按控制器接口划分事务:一个接口可能含多个独立用例。
- 按表划分事务:跨表用例被拆碎,失去原子性。
追问
- 用例边界不清楚怎么办?答:回到领域模型梳理聚合边界,聚合内强一致,跨聚合最终一致。
- 一个用例调多个 repository 会重复开事务吗?答:repository 不开关事务,加入 service 外层事务。
04.4.8.4-045 事务边界问题的综合排查清单是什么?
一句话结论
按「边界层级 → 事务内操作 → 连接归还 → 异常路径 → 一致性方案」排查:先确认事务开在哪层,再看事务内是否混入外部调用,最后核对失败回滚与跨系统补偿。
概念解释
事务问题表象:部分写入、连接占用高、重复提交、悬挂事务、跨系统不一致。排查从代码分层入手:边界是否在 service、事务句柄是否正确传递、异常与取消路径是否回滚、跨系统是否有可靠消息与补偿。结合数据库侧活跃事务列表与池指标定位长事务。
原理流程
- 检查事务开启位置与传播路径。
- 扫描事务内是否有外部调用/长等待。
- 核对异常、取消路径的回滚清理。
- 跨系统一致性核对 outbox/补偿/对账。
代码或图示
排查清单:
1. 事务边界:service 层,句柄正确传递
2. 事务内:无外部调用、无长等待、无大批量
3. 异常路径:回滚执行、连接归还
4. 跨系统:outbox 投递、幂等消费、补偿对账
5. 数据库侧:活跃事务时长、锁等待
常见误区
- 只看正常流程:异常取消路径才是悬挂与不一致来源。
- 应用层自查不查库:长事务与锁要结合数据库视图确认。
追问
- 长事务在数据库侧怎么查?答:查看活跃事务、运行时长与持锁语句,配合慢查询日志,见性能排查部分。
- 下一步:隔离级别与锁策略见 046 题起。
04.4.8.4-046 事务隔离级别有哪些,各自对应哪些并发现象?
一句话结论
ANSI 四级隔离:读未提交、读已提交、可重复读、串行化;逐级抑制脏读、不可重复读、幻读,级别越高并发越低、一致性越强。
概念解释
并发现象:脏读(读到未提交数据)、不可重复读(同一事务两次读同行结果不同)、幻读(两次范围查询行数变化)。读已提交阻止脏读;可重复读阻止脏读与不可重复读;串行化避免所有现象。各数据库默认级别与实现不同(如 PG 默认读已提交,MySQL InnoDB 默认可重复读,MVCC 实现细节有差异)。选型按业务一致性需求与并发承受度,不为所有事务开最高级别。
原理流程
- 确定业务允许的不一致现象。
- 选择匹配的隔离级别。
- 数据库按 MVCC/锁实现该级别。
- 高并发处评估级别对吞吐的影响。
代码或图示
级别 vs 现象:
读未提交:可能脏读
读已提交:阻止脏读
可重复读:阻止脏读 + 不可重复读
串行化:阻止脏读 + 不可重复读 + 幻读
常见误区
- 以为隔离级别越高越好:高级别并发下降、锁冲突与重试增多。
- 混淆数据库默认级别:跨库迁移时行为假设错误。
追问
- 待确认点是什么?答:目标数据库各级别实现与默认值,以数据库官方文档为准。
- 幻读在可重复读下完全避免吗?答:取决于数据库实现,MySQL/PG 行为不同,按文档与版本确认。
04.4.8.4-047 MVCC 多版本并发控制如何影响读写互不阻塞?
一句话结论
MVCC 为行保留多版本,读操作按一致性快照访问旧版本,写操作创建新版本,从而读写通常不互相阻塞;隔离级别决定快照可见范围。
概念解释
写不覆盖读所见的旧版本:读者看快照版本,写入产生新版本,并发读写不抢同一把读锁。版本链按事务可见性判断哪些版本可读。快照在事务内的建立时点由隔离级别决定:读已提交每条语句取新快照,可重复读事务内固定快照。MVCC 下写阻塞写(行锁/版本冲突),读一般不阻塞写。长期旧版本不清理会导致版本膨胀(如 vacuum 滞后)。
原理流程
- 写入创建行新版本,旧版本保留。
- 读取按事务快照可见性选版本。
- 读写各自基于版本,不阻塞对方。
- 旧版本由数据库清理机制回收。
代码或图示
MVCC 要点:
行多版本 + 可见性判断
读走快照,写产生新版本
写-写仍需锁/冲突控制
旧版本回收滞后会膨胀
常见误区
- 以为 MVCC 下完全没有锁:写并发仍冲突,更新同一行要等待。
- 忽略版本清理:长事务阻止旧版本回收,表膨胀。
追问
- 长事务为什么导致版本膨胀?答:旧版本对该长事务仍可见,清理机制不能回收,数据表与索引膨胀。
- MVCC 与隔离级别关系?答:级别决定快照时点与可见版本规则,见各后续题目。
04.4.8.4-048 读已提交(Read Committed)的行为特征是什么?
一句话结论
读已提交下每条语句看到的是语句开始时已提交的数据;防止脏读,但同一事务内两次读同一行可能得到不同结果(不可重复读)。
概念解释
每条语句用新快照,能读到其他事务已提交的最新值。适合大多数普通业务:读写并发好,一致性要求不极端。场景:单行读取展示、无一致性视图要求的查询。需要事务内多次读取结果一致时,该级别不够。写冲突仍按行锁/版本控制处理。PostgreSQL 默认级别即读已提交。
原理流程
- 事务开始。
- 每条语句执行时取当前已提交快照。
- 其他事务提交后,下一条语句可见新值。
- 防止读取未提交中间状态。
代码或图示
Read Committed:
语句级快照
无脏读
允许不可重复读
并发表现好,多数业务默认选择
常见误区
- 期待事务内两次读取一致:该级别不保证,会被其他提交改写。
- 以为读已提交会读到未提交数据:不会,脏读被阻止。
追问
- 高并发扣减用什么级别?答:隔离级别之外还要靠行锁或乐观锁控制写冲突,级别不解决写并发。
- 待确认点是什么?答:目标库 Read Committed 下语句快照的精确语义,以数据库文档为准。
04.4.8.4-049 可重复读(Repeatable Read)的行为特征是什么?
一句话结论
可重复读在事务内固定一致性快照,多次读取同一行结果不变;阻止不可重复读,幻读行为按数据库实现而定。
概念解释
事务快照在首次读时建立,整个事务访问同一版本视图,其他事务提交的修改在本事务内不可见。适合需要一致视图的对账、批量读取。代价:快照长期存在,旧版本不能及时清理;写冲突处理仍需锁或乐观控制。MySQL InnoDB 默认可重复读,其幻读抑制实现有专门机制,与其他库行为不完全相同。
原理流程
- 事务首次读取建立快照。
- 事务内所有读取沿用该快照。
- 其他事务提交对本事务不可见。
- 事务结束后快照释放,旧版本可回收。
代码或图示
Repeatable Read:
事务级快照
无脏读、无不可重复读
幻读抑制程度依数据库实现
长事务持有快照,注意版本膨胀
常见误区
- 认为可重复读下写入也基于旧版本无冲突:写仍受当前行锁与约束影响。
- 跨库沿用幻读假设:各库 RR 实现差异需核对。
追问
- 可重复读事务看到自己的写入吗?答:本事务自身修改可见,快照过滤的是其他事务版本。
- 待确认点是什么?答:目标库 RR 对幻读与快照建立时机的定义,以官方文档为准。
04.4.8.4-050 串行化(Serializable)隔离级别适合什么场景,代价是什么?
一句话结论
串行化保证事务并发执行等价于某种串行顺序,避免所有并发异常;代价是更高的冲突检测、重试概率与并发下降,仅用于一致性要求极高且冲突可控的场景。
概念解释
串行化通过强约束或乐观冲突检测防止并发写出现异常结果。数据库可能在提交时检测到写倾斜/读写依赖冲突而中止事务,应用必须重试。普通业务用不到该级别;金融、库存强约束等关键场景才评估。串行化不等于加全表锁,实现方式(悲观锁或可串行化快照检测)依数据库而定。重试压力大时说明并发模型需要重新设计。
原理流程
- 关键用例声明串行化级别。
- 数据库检测并发依赖是否可串行。
- 检测到冲突中止事务,应用重试。
- 无冲突事务正常提交。
代码或图示
Serializable:
等价串行执行,无并发异常
冲突中止 + 应用重试
并发吞吐下降
适用:极高一致性、低冲突关键流程
常见误区
- 全局开串行化:普通查询也被拖慢,重试风暴。
- 被中止后不重试:事务失败直接暴露给用户。
追问
- 串行化与显式加锁哪个可控?答:按场景评估;显式悲观锁范围明确,串行化由数据库检测,行为可预测性不同。
- 待确认点是什么?答:目标库串行化的实现(锁/SSI)与冲突错误码,以数据库文档为准。
04.4.8.4-051 FOR UPDATE 悲观锁如何使用,各框架写法有何差异?
一句话结论
SELECT ... FOR UPDATE 对命中行加排他行锁,事务内持有到提交;SQLx/裸客户端直接写语句,ORM 在查询链上加锁方法,写法不同但底层都是数据库行锁。
概念解释
悲观锁假设冲突会发生,读取关键行时锁定,其他事务更新或再锁需等待。典型场景:库存扣减、余额更新前先锁行。锁在事务内有效,事务结束释放。框架差异:裸客户端/tokio-postgres 在 SQL 文本写 FOR UPDATE;sqlx 直接执行带锁语句;ORM 提供查询构造器的锁定方法(方法名按版本确认)。FOR UPDATE 不锁不匹配的行,范围查询加锁范围要评估。
原理流程
- 事务内查询目标行并带
FOR UPDATE。 - 数据库对命中行加排他锁。
- 当前事务读取并更新。
- 提交/回滚释放锁。
代码或图示
// 裸客户端 / 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 行锁粒度与锁等待如何分析?
一句话结论
行锁只锁定匹配的具体行,不锁整表(索引选择决定实际锁定范围);其他事务访问锁定行时排队等待,等待时长与死锁由数据库监控。
概念解释
行锁粒度依赖查询用到的索引:走唯一索引锁单行,索引失效可能退化为锁更多行甚至表级锁定。锁等待表现为并发事务阻塞,等待队列在数据库侧可见。分析锁要结合执行计划:命中哪些索引、锁定哪些行。锁持有时间等于事务时长,缩短事务是降低等待的根本手段。锁等待与死锁视图在数据库侧查询。
原理流程
- 带锁查询走执行计划确定索引。
- 数据库锁定匹配行。
- 冲突事务排队等待。
- 提交释放;等待超时报错或死锁被检出。
代码或图示
锁分析:
执行计划 → 索引是否命中 → 锁定行数
锁等待 → 谁持有、谁等待、等待时长
优化 → 索引精确、事务缩短、热点拆分
常见误区
- 以为行锁永远只锁一行:索引不匹配时锁定范围扩大。
- 锁等待归为数据库慢:根因可能是事务长持有。
追问
- 数据库侧怎么看锁?答:查锁等待与活跃事务视图,结合慢查询日志;具体视图按数据库方言。
- 行锁会升级成表锁吗?答:部分数据库在特定场景有锁升级或表锁策略,按方言文档确认。
04.4.8.4-053 版本号乐观锁如何实现?
一句话结论
表加版本号列,更新时带版本条件 WHERE id=? AND version=?,影响行数为 0 说明并发冲突;冲突后重新读取并重试,无需预先加锁。
概念解释
乐观锁假设冲突少发生:读数据时记录版本,写入时校验版本是否仍为读取值。更新语句同时递增版本号。影响行数 0 表示期间被其他事务改过,本次写入放弃重试。相比悲观锁不阻塞读,适合冲突概率低的场景。实现要在实体/查询中带版本条件,不能只在应用层判断。版本号也可用更新时间戳代替,但时间精度与并发判断弱于整数版本。
原理流程
- 读取业务行与当前版本号。
- 构造更新:主键 + 旧版本条件,版本 +1。
- 执行更新,检查影响行数。
- 0 行:冲突,重新取数重试;成功则提交。
代码或图示
UPDATE product
SET stock = $1, version = version + 1
WHERE id = $2 AND version = $3
常见误区
- 只在应用层比对版本,SQL 不带条件:并发下校验形同虚设。
- 冲突后不重读直接重试:仍基于旧数据,再次冲突。
追问
- 乐观锁冲突怎么反馈?答:service 层识别 0 行更新,转为可重试冲突或业务提示。
- 版本号类型用什么?答:整数递增最直接;时间戳方案注意精度与同毫秒并发。
04.4.8.4-054 唯一约束如何作为并发兜底?
一句话结论
对业务上必须唯一的字段(订单号、手机号、业务键)建数据库唯一约束;并发插入重复时数据库拒绝,应用捕获唯一冲突转为业务错误,比应用层先查后插更可靠。
概念解释
「先查询再插入」在并发下有竞态:两个事务同时查到不存在,都插入导致重复。唯一约束在数据库层兜底,重复写入直接冲突失败。应用层先查用于友好提示,最终保证靠约束。唯一冲突错误要识别并映射,不能当成系统故障。软删除场景唯一索引需兼容残留行(部分索引或带标记列)。约束命名与错误码按数据库识别。
原理流程
- 表上建唯一索引/约束。
- 应用插入并发行。
- 数据库拒绝重复键。
- 捕获唯一冲突错误,返回业务提示或触发更新分支。
代码或图示
兜底链路:
应用先查(体验优化,不保证唯一)
数据库唯一约束(最终保证)
捕获冲突 → 业务错误 / upsert 分支
常见误区
- 只靠应用层查重:并发竞态下重复落库。
- 唯一冲突一律 500:应转为可预期的业务状态。
追问
- upsert(冲突时更新)怎么实现?答:按方言用
ON CONFLICT/ON DUPLICATE KEY语法,ORM 是否暴露对应接口待确认。 - 软删除行占用唯一键怎么办?答:部分唯一索引(仅未删除行唯一)或唯一键拼接删除标记,按方言支持选择。
04.4.8.4-055 死锁是如何产生的,数据库如何检测?
一句话结论
两个以上事务以不同顺序持有并等待对方的锁,形成循环等待即死锁;数据库周期性检测等待环,中止其中一个事务打破死锁。
概念解释
死锁四条件:互斥、持有等待、不可剥夺、循环等待。典型场景:事务 A 锁行 1 等行 2,事务 B 锁行 2 等行 1。数据库死锁检测器发现循环后选牺牲品回滚。应用应保持多事务加锁顺序一致,降低交叉等待。死锁与锁等待不同:死锁是循环阻塞,等待是单向排队。日志中死锁错误与普通锁超时要区分处理。
原理流程
- 事务按不同顺序锁定资源。
- 互相持有对方需要的锁。
- 数据库检测到等待环。
- 中止一个事务,另一个继续。
代码或图示
死锁示例:
T1: 锁行 A → 等待行 B
T2: 锁行 B → 等待行 A
检测到环 → 回滚 T1 或 T2
规避:统一加锁顺序、缩短事务、减少交叉更新
常见误区
- 死锁靠无限重试解决:不改变加锁顺序,死锁会反复发生。
- 死锁错误当成系统故障告警:属于可重试并发冲突,但频繁出现要分析顺序。
追问
- 怎么统一加锁顺序?答:多表/多行更新按固定排序(如主键升序)锁定,避免相反顺序。
- 待确认点是什么?答:目标库死锁检测周期、牺牲品选择策略与错误码,以数据库文档为准。
04.4.8.4-056 死锁与锁等待冲突的重试策略怎么定?
一句话结论
死锁牺牲品与短暂锁等待可有限次重试,重试前重新读取数据;重试次数与退避设上限,持续冲突要分析加锁顺序与热点,不能无限自旋。
概念解释
可重试错误:死锁回滚、锁等待超时(短暂排队后失败)。不可盲目重试:约束冲突、业务参数错误不应重试。重试循环在事务外,每次重试开新事务。退避避免冲突事务同时重试加剧竞争。重试次数耗尽后上报,结合死锁日志定位根因。幂等性保证重复重试不产生副作用。
原理流程
- 执行业务事务。
- 识别死锁/锁等待错误为可重试。
- 有限次重试,重读数据,新事务执行。
- 超限报错并记录冲突上下文。
代码或图示
重试策略:
可重试:死锁、短暂锁等待
不重试:唯一冲突、参数错误、约束失败
每次重试:重读 + 新事务 + 幂等
上限:次数 + 退避 + 告警
常见误区
- 事务内自旋重试:长占锁加剧死锁。
- 所有数据库错误都重试:不可恢复错误被反复放大。
追问
- 重试退避怎么设?答:少量立即重试 + 短暂退避,持续冲突快速失败告警,不做长循环。
- 怎么判断是死锁还是慢查询持锁?答:死锁有循环等待检测记录;慢持锁表现为单向等待,结合事务时长分析。
04.4.8.4-057 悲观锁与乐观锁如何选型?
一句话结论
冲突频繁、临界资源关键选悲观锁(先锁再改);冲突概率低、读多写少选乐观锁(版本校验 + 重试);热点高并发场景还要考虑拆分与队列化。
概念解释
选型维度:冲突频率、事务持锁成本、失败重试代价。悲观锁阻塞并发写,实现直观,但锁等待与死锁风险;乐观锁不阻塞读,冲突时放弃重试,适合低冲突。库存秒杀这类高热点两者都吃力,需队列、预扣、分桶等设计。选择依据是实测冲突率,不是偏好。混合方案:读用乐观校验,关键写入短事务悲观锁。
原理流程
- 估算业务并发冲突率。
- 高冲突/关键约束 → 悲观锁 + 短事务。
- 低冲突 → 乐观锁 + 有限重试。
- 热点瓶颈 → 业务层拆分/排队,而非只换锁策略。
代码或图示
对比:
悲观锁:先加锁,阻塞等待,适合高冲突
乐观锁:版本校验,冲突重试,适合低冲突
热点:分桶/队列/预扣,缓解行级争用
常见误区
- 低冲突也上悲观锁:不必要的阻塞。
- 高冲突用乐观锁:重试风暴反而更差。
追问
- 两种锁能一起用吗?答:可以分层,但同一写入路径保持策略一致,避免语义混乱。
- 待确认点是什么?答:数据库行锁与乐观约束的实际表现,以压测结果为准。
04.4.8.4-058 MySQL 的间隙锁与 next-key lock 是什么?
一句话结论
InnoDB 在可重复读下用 next-key lock(行锁 + 间隙锁)防止范围查询幻读,锁定记录及其间隙;可能阻塞范围内的插入,是 MySQL 特有的锁机制。
概念解释
间隙锁锁定索引记录之间的区间,阻止其他事务在区间插入;next-key lock 是行锁加间隙锁的组合。范围查询、条件未走唯一索引时可能锁定较大间隙,并发插入被阻塞。其他数据库(如 PostgreSQL)幻读抑制机制不同,不能照搬 MySQL 锁结论。MySQL 锁分析要结合索引与隔离级别;减少间隙锁影响:查询走精确唯一索引、降低范围锁范围。
原理流程
- 范围查询在 RR 级别走索引扫描。
- 对扫描记录与间隙加 next-key lock。
- 其他事务向间隙插入被阻塞。
- 事务提交释放。
代码或图示
MySQL InnoDB:
记录锁:锁定具体行
间隙锁:锁定记录间区间,阻止插入
next-key:行锁 + 间隙锁组合
注意:其他数据库机制不同,勿跨库套用
常见误区
- 把 MySQL 间隙锁结论套到 PG:PG 用 MVCC 与其他机制控制幻读。
- 范围条件不走索引:间隙锁定范围扩大,阻塞更多插入。
追问
- 待确认点是什么?答:当前 MySQL 版本各语句加锁规则与间隙锁行为,以官方锁文档为准。
- 如何降低间隙锁影响?答:等值查询走唯一索引、避免大范围扫描、评估隔离级别是否必须 RR。
04.4.8.4-059 幂等设计如何与唯一键、重试配合?
一句话结论
写操作带唯一业务键,重试/重复请求用同一键落库被唯一约束识别;消费端按业务键去重,使多次执行结果等价一次执行。
概念解释
幂等保证同一请求执行多次与一次效果相同。手段:客户端生成唯一请求号/业务键;服务端落库前查或靠唯一约束冲突识别重复;消息消费按业务键记录已处理状态。接口重试、MQ 重复投递、用户重复提交都依赖幂等兜底。幂等键要贯穿请求、库表、消息链路。不能只依赖前端按钮置灰。
原理流程
- 请求携带唯一业务键。
- 写入时业务键入唯一约束。
- 重复执行命中冲突,返回首次结果或忽略。
- 消费端记录处理状态去重。
代码或图示
幂等链路:
请求唯一键 → 库表唯一约束 → 冲突识别
消息消费 → 已处理记录表 → 重复跳过
重复执行:结果等价,不产生重复副作用
常见误区
- 重试场景不设计幂等:重复扣款、重复下单。
- 幂等键每次请求重新生成:去重失效。
追问
- 幂等记录放哪?答:业务表唯一键或独立去重表,按写操作类型选择;消息消费用消费记录表。
- 超时后重试如何避免部分成功?答:回查业务状态 + 幂等键,见提交失败处理题目。
04.4.8.4-060 隔离级别与锁策略的选型清单是什么?
一句话结论
先按业务一致性要求选隔离级别,再按冲突率选锁策略;默认读已提交 + 乐观锁/唯一约束,强一致关键流程评估更高级别或悲观锁,全程配合短事务与索引。
概念解释
清单顺序:识别用例一致性需求 → 选隔离级别 → 评估并发冲突 → 选乐观/悲观/约束兜底 → 配合索引与短事务。不要全局拉高隔离级别,也不要在无保护下做并发写。每个关键写入路径明确:一致性要求、冲突概率、兜底约束、重试策略。选型结论要能解释给面试官:为什么这个用例用这个级别。
原理流程
- 梳理用例:读取一致性、写入并发、失败补偿需求。
- 默认读已提交,特殊场景升级。
- 低冲突乐观锁,高冲突悲观锁,唯一约束兜底。
- 压测验证冲突率与锁等待。
代码或图示
选型清单:
一致性要求 → 隔离级别
冲突概率 → 乐观 / 悲观锁
唯一性 → 数据库唯一约束
重试 → 幂等 + 有限退避
基础保障 → 短事务、精确索引、固定加锁顺序
常见误区
- 跳过一致性分析直接套默认配置:关键用例保护不足。
- 锁策略与隔离级别割裂考虑:两者共同决定并发行为。
追问
- 待确认点是什么?答:目标数据库各级别与锁的精确语义,以官方文档为准。
- 下一部分是什么?答:分页与深分页优化见 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,无限滚动优先游标。
原理流程
- 按排序条件扫描候选行。
- 排序(若索引不覆盖)。
- 跳过前 offset 行。
- 返回 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 估算或不展示总数。业务上识别哪些场景允许「只往下翻」,哪些必须跳页。
原理流程
- 深页码到达,offset 增大。
- 扫描与丢弃成本上升。
- 期间数据增删,位置漂移。
- 响应变慢且结果不稳定。
代码或图示
深分页症状:
扫描行数随 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 流。
原理流程
- 第一页按固定排序取 limit 行。
- 记录末行排序键作为游标。
- 下一页条件:排序键 > 游标值。
- 从游标位置继续取,无 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)存在同值多行,游标无法区分先后,翻页重复或漏行。末位追加唯一键(主键)作为兜底排序列。排序键要有对应索引,否则游标条件仍触发全表扫描。排序方向固定,不能每页切换。排序键值不可变(主键或不可变时间戳),更新排序列会导致行位置跳动。
原理流程
- 选择排序列,末位补唯一主键。
- 建立对应联合索引。
- 每页末行提取完整排序键作游标。
- 下一页按键值比较取后续行。
代码或图示
游标键要求:
唯一:并列值可区分
有序:索引顺序与 ORDER BY 一致
稳定:排序列不被更新
复合:多列排序全部进游标
常见误区
- 排序列允许更新:行在分页中途移动位置。
- 只有普通索引无联合索引:游标条件走不到索引。
追问
- 按热度等动态排序能游标分页吗?答:排序值频繁变化时位置不稳定,需要快照排序或接受抖动。
- 游标编码怎么传递?答:多列键组合编码为不透明游标,服务端解码,不要暴露内部结构。
04.4.8.4-065 分页 count 查询的代价是什么?
一句话结论
COUNT(*) 在大表或复杂条件下要扫描满足条件的行,与列表查询成本接近甚至更高;深分页场景每次翻页都 count 会重复付出代价。
概念解释
总数用于显示「共多少条、多少页」。count 要统计所有满足条件的行,不能用 limit 截断;复杂 join、聚合、非索引条件下成本高。每次翻页重算 count 放大开销。缓解:缓存总数、估算行数、只在首屏取总数、前端不显示总数。count 走索引的程度取决于条件与索引设计。
原理流程
- 按相同条件执行 count 统计。
- 数据库扫描匹配行计数。
- 结果换算总页数。
- 翻页时是否重复 count 按策略决定。
代码或图示
-- 与列表同条件的计数
SELECT COUNT(*) FROM fruit WHERE kind = 'tropical';
常见误区
- 每页翻页都实时 count:重复扫描大表。
- count 条件与列表条件不一致:总数与页内容对不上。
追问
- count 能走索引吗?答:覆盖索引且条件可索引时成本较低;复杂条件仍需扫描。
- 待确认点是什么?答:目标库 count 优化(近似统计、索引计数)能力,以数据库文档为准。
04.4.8.4-066 不精确总数与估算方案有哪些?
一句话结论
可接受不精确时用数据库统计信息估算行数、缓存总数一段时间、或前端不展示总数;牺牲精确性换取分页性能。
概念解释
方案层级:精确 count(准确但慢)、缓存 count(短暂一致,定时刷新)、数据库估算(基于统计信息,偏差随数据波动)、不展示总数(只提供下一页)。按业务容忍度选择:管理后台可精确,feed 流可不显示总数。估算值要标注口径,避免被当成精确数字。缓存 count 要在数据变更后考虑失效策略。
原理流程
- 评估业务是否需要精确总数。
- 需要精确:优化 count 条件与索引。
- 可容忍偏差:缓存或估算。
- 不需要:只返回当前页与是否有下一页。
代码或图示
总数方案:
精确 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 方言分页」两层。
原理流程
- 确定分页方案:offset 还是游标。
- 框架提供的分页器直接配置页大小。
- 裸 SQL 手写 limit/offset/游标条件。
- 总数按所选方案获取。
代码或图示
// 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 循环深分页成本高。大批量任务记录最后键值作为断点,失败续跑不重跑。批次大小结合内存、事务与数据库负载。遍历过程中数据可能被修改,按业务决定是否需要快照一致视图。
原理流程
- 选择遍历方式:游标分批优先。
- 按批次大小取数处理。
- 记录断点键值。
- 失败从断点续跑。
代码或图示
全量遍历:
游标分批:每批独立,断点清晰
流式读取:边读边处理,连接占用久
offset 循环:深批成本高,不推荐
常见误区
- 一次性查全表到内存:内存峰值随表增长。
- 遍历任务无断点:失败从头重跑。
追问
- 遍历期间数据变更怎么处理?答:按业务接受快照视图或新数据;需要一致视图用可重复读事务,但注意快照与版本膨胀。
- 大批量导出走文件还是流式响应?答:按接口能力选择,分批写入避免内存堆积。
04.4.8.4-069 分页查询如何配合索引设计?
一句话结论
分页排序列与过滤条件应进联合索引,使游标/排序走索引顺序扫描;缺少索引时分页退化为全表扫描加排序,深页尤其慢。
概念解释
列表查询的索引覆盖:过滤条件列、排序列、返回列尽量被联合索引覆盖。游标分页要求索引顺序与排序一致。联合索引列顺序按过滤等值在前、排序在后设计。索引过度也影响写入,按列表查询模式平衡。慢分页先看执行计划:是否走索引、是否 filesort、扫描行数多少。
原理流程
- 提取列表查询的过滤与排序列。
- 设计联合索引(等值列 + 排序列)。
- 验证执行计划命中索引。
- 游标条件沿索引定位位置。
代码或图示
索引配合:
WHERE 等值列 → 索引前导列
ORDER BY 列 → 索引后续列,顺序一致
覆盖索引:减少回表
常见误区
- 只给排序列建索引:过滤条件仍全表扫描。
- 索引列顺序与查询不匹配:索引不生效。
追问
- 回表是什么?答:索引未覆盖返回列时,按索引回表取整行,额外随机 IO。
- 待确认点是什么?答:目标库联合索引最左前缀与索引跳跃扫描规则,以数据库文档为准。
04.4.8.4-070 翻页期间数据增删为什么会导致重复或遗漏?
一句话结论
offset 按当前时刻行位置计数,翻页之间新行插入或旧行删除会使位置平移,导致下一页重复看到上一页行或跳过某些行;游标分页按键值定位,受中间增删影响更小。
概念解释
offset 方案:第一页后有行插入,后续行位置后移,下一页 offset 落到错位位置,重复或遗漏。游标方案按 id > last_id 定位,新插入更小/更大键值的行不影响当前游标之后的顺序(仍取决于键值设计)。删除行使 offset 前移同理。对一致性要求高的列表要么接受短暂漂移,要么用游标 + 固定排序键。
原理流程
- 第一页读取并记录位置/游标。
- 期间其他事务增删行。
- offset 位置相对漂移。
- 下一页结果出现重复或遗漏。
代码或图示
offset 漂移:
翻页间插入 → 行后移 → 重复/跳过
翻页间删除 → 行前移 → 跳过
游标:按键值比较,中间增删对定位影响较小
常见误区
- 假设列表在翻页期间不变:活跃业务必然有变更。
- 用 offset 又要求严格不重不漏:方案不匹配。
追问
- 订单类列表怎么防漂移?答:游标按创建时间 + 主键排序,或接受业务可接受的轻微重复并以前端去重兜底。
- 快照一致列表怎么做?答:可重复读事务内完成分页,但长事务代价高,适合小批量导出。
04.4.8.4-071 排序不稳定时如何保证分页结果确定?
一句话结论
排序必须有唯一兜底列(主键),使任意两行有确定先后顺序;避免仅按非唯一列排序导致同值行顺序在两次查询间变化。
概念解释
数据库不保证同值行的返回顺序,只按声明的排序列排序。非唯一列(状态、时间、名称)同值多行顺序不稳定,分页边界处来回跳动。末位补主键后顺序完全确定。排序列更新会改变行位置,设计分页时选择不常更新的排序键。动态排序(用户选列)要保证每次查询排序规则一致。
原理流程
- 主排序列 + 唯一兜底列。
- 查询按完整排序规则返回。
- 同值行按兜底列确定顺序。
- 游标携带完整排序键。
代码或图示
-- 不稳定:同 created_at 多行顺序不定
ORDER BY created_at
-- 稳定:主键兜底
ORDER BY created_at, id
常见误区
- 排序只写业务列:边界行顺序随机。
- 排序列频繁更新:行位置中途跳动。
追问
- 用户可切换排序列怎么办?答:每次都带主键兜底,游标按所选排序规则生成。
- 待确认点是什么?答:目标库对相等键的返回顺序保证,以文档为准;不依赖未定义行为。
04.4.8.4-072 分页场景选型清单是什么?
一句话结论
按交互模式选:浅页码后台管理用 offset 分页器;无限滚动/深层列表用 keyset 游标;总数按业务容忍度选精确/估算/不展示;所有方案配合索引与唯一排序键。
概念解释
选型决策树:是否需要跳页(offset)还是只往下翻(游标);结果集大小;总数是否必须精确;排序键是否稳定。列表查询还要评审索引。混合场景:首屏 offset 取前几页,深翻转游标。方案落地前用真实数据量压测深页表现。接口设计返回页数据、游标与是否有下一页,总数按方案返回。
原理流程
- 识别交互:跳页 / 连续滚动。
- 识别结果集规模与总数要求。
- 选 offset、游标或混合方案。
- 核对索引、排序键与总数策略。
代码或图示
决策:
跳页 + 浅规模 → 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 查询、预加载机制。
原理流程
- 主查询返回 N 行。
- 循环内每行触发一次关联查询。
- 关联语句重复 N 次。
- 往返次数与 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。
原理流程
- 确定主表与关联表 join 关系。
- 一次查询取主行与关联字段。
- 内存按主行分组装配。
- 返回聚合后的结构。
代码或图示
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,批量查询避免一对多行膨胀,装配逻辑在应用层。多关联方向可各自批量。
原理流程
- 主查询得到主行,收集外键集合。
- 关联表
WHERE foreign_key IN (...)一次取出。 - 按外键分组建映射。
- 装配回主行结构。
代码或图示
-- 收集 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 工程可自行实现批量加载器,或选用对应库。本质仍是「收集外键 → 批量取 → 内存装配」,但封装了收集与分发环节。
原理流程
- 各调用点请求关联键,进入 loader 队列。
- 本轮结束触发批量加载。
- 键去重,一次批量查询取回结果。
- 按键分发回各调用点。
代码或图示
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。各库是否支持批量回填逐行主键取决于方言与接口。大批量必须分批,单批参数与包大小受限。批量失败按批次回滚或记录失败行。具体方法名与返回类型以各库当前版本为准。
原理流程
- 收集待插入行集合。
- 按批次大小切片。
- 各库批量接口生成多行 INSERT。
- 检查结果与错误,必要时重试批次。
代码或图示
// 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 拼赋值,或按主键分批单行。批量语句锁范围一次性覆盖多行,要评估锁等待。大批量更新同样分批,避免长事务与大锁段。更新前确认条件命中范围,防止误更新全表。受影响行数用于核对是否全部命中。
原理流程
- 判断更新值是否相同。
- 同值:条件批量 UPDATE。
- 不同值:CASE 表达式或分批单行。
- 分批执行,检查影响行数。
代码或图示
-- 同值批量
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 层。
原理流程
- 关联结果按外键分组为映射。
- 遍历主行查映射。
- 填充单值或集合。
- 输出装配后的 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 能放任意多值」。
原理流程
- 查数据库/驱动参数上限。
- 集合按批次切片。
- 每批
IN查询,结果合并。 - 监控单批语句长度与计划。
代码或图示
限制来源:
数据库参数个数 / SQL 文本长度
驱动与代理协议限制
执行计划对大 IN 的稳定性
处置:分批 + 内存合并,或临时表 join
常见误区
- 把上万主键拼进一条 IN:语句超限或计划退化。
- 分批后结果未去重:跨批重复值混入。
追问
- 待确认点是什么?答:目标数据库与驱动的具体参数上限值,以数据库文档和驱动版本为准。
- 大集合关联还有什么方案?答:临时表或派生表 join,按数据库支持与工程成本选择。
04.4.8.4-081 cache-aside(旁路缓存)的流程是什么?
一句话结论
读路径先查缓存,未命中查库并回填缓存;写路径先更新数据库,再删除(而非更新)缓存;这是应用侧最常见的缓存模式。
概念解释
cache-aside 由应用管理缓存,缓存不替代数据库。读:缓存命中返回,未命中读库、写缓存。写:更新库后失效缓存,下次读重建。与穿透式缓存区别在于缓存逻辑在应用代码。缓存键设计、TTL、空值缓存都属该模式细节。该模式下缓存与库存在短暂不一致窗口,靠失效策略与兜底控制。
原理流程
- 读:查缓存 → 命中返回;未命中查库 → 回填缓存。
- 写:更新数据库 → 删除缓存键。
- 下次读未命中再从库重建。
- 缓存设 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,专用缓存层才考虑穿透模式。
原理流程
- read-through:缓存未命中 → 缓存层回源 → 返回并缓存。
- write-through:写缓存 + 写库同步完成。
- write-behind:写缓存 → 异步刷库。
- 按模式承担各自一致性与风险。
代码或图示
模式:
cache-aside 应用管理,读回源、写删缓存
read-through 缓存层代读库
write-through 同步写缓存与库
write-behind 先缓存异步落库(有丢失风险)
常见误区
- write-behind 当强一致:异步刷库期间缓存与库可能不一致。
- 以为所有缓存都支持穿透模式:取决于缓存中间件与封装。
追问
- 待确认点是什么?答:所用缓存中间件对穿透/写回模式的支持程度,以中间件文档为准。
- 工程默认选哪种?答:cache-aside 简单可控;读多写少且回源逻辑复用时考虑 read-through。
04.4.8.4-083 先更新数据库还是先删缓存?
一句话结论
常规做法是「先更新库,再删缓存」;反向「先删缓存再更新库」在并发下更容易出现旧值回填,优先采用更新库后失效缓存。
概念解释
写路径两种顺序:先删缓存再更库、先更库再删缓存。并发场景分析:先删缓存后更库期间,并发读未命中把旧值回填;先更库后删缓存期间,并发读可能读到删前旧缓存,窗口更短且可接受。更稳妥的配套:延迟双删、订阅库变更失效、缓存 TTL。极端一致性仍需版本号或消息失效。缓存更新(写缓存)比删除争议更大,一般不采用。
原理流程
- 写请求更新数据库。
- 删除对应缓存键。
- 并发读未命中时从新库值重建。
- 必要时延迟双删或变更订阅兜底。
代码或图示
推荐顺序:
UPDATE DB → DEL cache
风险窗口:删缓存前的并发读读到旧缓存
兜底:TTL / 延迟双删 / 变更事件失效
常见误区
- 先删缓存再更库:旧值回填窗口更大。
- 删除缓存失败不重试:脏缓存长期存在,要有失效重试与告警。
追问
- 延迟双删怎么做?答:更库后删一次,短暂延迟再删一次,覆盖并发读回填窗口;延迟时长按读耗时评估。
- 缓存删除失败怎么办?答:重试 + 消息补偿 + TTL 过期,不能静默丢弃。
04.4.8.4-084 缓存并发双写与失效竞态如何控制?
一句话结论
并发读写同一键时,可能出现旧值回填、缓存与库短暂不一致;控制手段:删而非更、版本号比对、变更事件失效、短 TTL 与关键数据不过度缓存。
概念解释
竞态场景:线程 A 读未命中,线程 B 写库删缓存,A 把旧值回填缓存。单靠应用顺序无法完全消除,需要:缓存值带版本/时间戳,回填时版本旧则不写;订阅 binlog/变更消息主动失效;关键强一致数据直接读库。多实例部署下本地缓存还要处理各实例失效通知。缓存一致性是最终一致,按业务容忍度设计兜底。
原理流程
- 写路径更新库并失效缓存。
- 读回填时比对版本/时间戳。
- 变更事件异步刷新各节点缓存。
- TTL 兜底收敛脏数据。
代码或图示
竞态控制:
写后删除缓存
回填版本校验,旧值不覆盖
变更订阅主动失效
TTL 兜底
强一致数据不走缓存
常见误区
- 依赖缓存永远与库一致:旁路缓存存在短暂窗口。
- 多实例本地缓存无失效广播:各节点脏数据长期不同步。
追问
- 版本号怎么带进缓存?答:缓存值结构含数据版本,回填前对比库版本,旧版本丢弃。
- 待确认点是什么?答:所用缓存中间件的订阅/失效能力,以中间件文档为准。
04.4.8.4-085 缓存穿透、击穿、雪崩分别是什么?
一句话结论
穿透是查不存在的数据绕过缓存打库;击穿是热点键过期瞬间大量并发打库;雪崩是大批缓存同时失效集中回源;三者都冲击数据库,防控手段不同。
概念解释
穿透:请求键不存在(恶意或巧合),缓存永不命中,反复查库。防控:空值缓存、布隆过滤器、参数校验。击穿:单个热点 key 过期,并发同时未命中重建。防控:互斥重建、热点永不过期加异步刷新。雪崩:大量键同 TTL 同时失效。防控:TTL 加随机抖动、分批过期、限流降级。区分三者成因才能选对手段。
原理流程
- 识别回源流量模式:不存在键 / 单热点 / 大批同时失效。
- 穿透:空值缓存或布隆过滤。
- 击穿:重建加锁或热点保活。
- 雪崩:TTL 抖动 + 限流降级。
代码或图示
穿透:不存在 → 缓存空值 / 布隆过滤器
击穿:热点过期 → 互斥重建 / 永不过期
雪崩:批量失效 → TTL 随机抖动 / 限流降级
常见误区
- 三种问题用同一手段:成因不同,布隆过滤器解决不了雪崩。
- TTL 全部固定值:同一时刻集中过期。
追问
- 互斥重建怎么实现?答:用锁/单飞模式保证只有一个请求回源,其余等待结果;具体原语按工程选型。
- 空值缓存要注意什么?答:短 TTL,避免真实数据插入后长期返回空。
04.4.8.4-086 缓存与数据库一致性有哪些兜底措施?
一句话结论
兜底包括:TTL 自动过期、删除失败重试与消息补偿、变更事件订阅失效、版本号校验回填、关键数据直读库;按数据一致性等级选择组合。
概念解释
没有任何旁路缓存方案能保证强一致,兜底链路覆盖各种失效路径:写后删缓存失败有重试与补偿队列;各实例缓存由变更事件通知失效;回填时版本校验拒绝旧值;TTL 保证最终收敛。强一致要求的数据(余额、库存扣减)不缓存或只读缓存加数据库校验。一致性等级按业务划分:展示类可短暂不一致,交易类直读库。
原理流程
- 数据分级:一致要求高的不走缓存。
- 写路径删缓存 + 失败补偿。
- 变更事件驱动多节点失效。
- TTL 与版本校验兜底收敛。
代码或图示
兜底组合:
TTL 过期收敛
删除重试 / 补偿消息
变更订阅失效
回填版本校验
关键数据直读库
常见误区
- 只靠 TTL:脏数据驻留时间过长,写后不主动失效。
- 补偿消息丢失不监控:失效链路断裂无感知。
追问
- 缓存一致性怎么监控?答:采样比对缓存与库值、监控回源率与删除失败率。
- 待确认点是什么?答:中间件提供的失效订阅与事件能力,以官方文档为准。
04.4.8.4-087 本地缓存与分布式缓存如何配合?
一句话结论
本地缓存(进程内)访问快但多实例不一致、容量受限;分布式缓存(Redis 等)共享一致但有网络开销;两级缓存按热点与一致性要求分层使用。
概念解释
本地缓存:无网络开销,命中极快,但每个实例各自一份,失效要广播;容量受进程内存限制。分布式缓存:全实例共享,容量大,每次访问走网络。两级架构:先查本地,未命中查分布式,再未命中查库。本地层 TTL 短、只放极热点;变更失效需要广播通知各节点。注意本地缓存容量淘汰策略与内存占用。Rust 工程本地缓存常用内存 Map + 过期策略,具体 crate 按选型确认。
原理流程
- 请求先查本地缓存。
- 未命中查分布式缓存。
- 再未命中查库并逐级回填。
- 数据变更广播失效各节点本地缓存。
代码或图示
两级:
本地缓存(进程内,短 TTL,极热点)
分布式缓存(共享,主要容量)
数据库(回源)
本地失效:变更广播通知
常见误区
- 本地缓存不放失效机制:多实例数据长期不一致。
- 本地缓存无容量上限:进程内存被缓存挤占。
追问
- 待确认点是什么?答:所选本地缓存 crate 的淘汰策略与过期能力,以 docs.rs 为准。
- 什么数据只放分布式?答:一致性要求高、容量大、多实例必须共享的数据。
04.4.8.4-088 缓存方案选型清单是什么?
一句话结论
按数据访问模式(读多写少/热点)、一致性等级、容量与失效复杂度选:是否缓存、缓存层级、失效策略与兜底;不要为所有数据加缓存。
概念解释
评估维度:读频次与回源成本、写频次(写多则缓存收益低)、一致性要求、数据规模、过期与失效复杂度。读多写少且容忍短暂不一致适合缓存;频繁写入或强一致数据直读库。清单先判断值不值得缓存,再选模式(aside/read-through)、层级(本地/分布式)、失效与兜底。缓存引入额外复杂度,命中不高的场景反而增加维护成本。
原理流程
- 统计读多写少程度与回源代价。
- 判定一致性容忍度。
- 选缓存模式、层级与键设计。
- 配置失效、兜底与监控指标。
代码或图示
选型清单:
访问模式:读多写少 → 适合缓存
一致性:强一致 → 直读库
容量:本地 / 分布式 / 两级
失效:写后删 + 事件 + TTL
监控:命中率、回源率、删除失败
常见误区
- 全量加缓存:写频繁的数据缓存收益低且一致性负担重。
- 不评估命中率:低命中缓存等于额外一层开销。
追问
- 缓存命中率多少值得保留?答:按回源成本与缓存维护成本测算,没有固定阈值,结合压测与监控。
- 下一部分:数据库性能排查见 089 题起。
04.4.8.4-089 EXPLAIN 看哪些关键信息?
一句话结论
EXPLAIN 展示查询计划:访问类型、扫描索引、扫描行数、join 顺序与附加信息;重点看是否走索引、扫描行数与是否有全表扫描/排序。
概念解释
执行计划关键字段:访问方式(全表扫描/索引扫描/索引查找)、所用索引、预估扫描行数、表连接顺序、排序与临时表。预估行数与实际偏差大说明统计信息过期。计划是优化起点,不直接等于实际执行;需要时用 ANALYZE 看真实代价。不同数据库计划格式不同,但核心关注点一致:索引利用、扫描范围、排序与 join 顺序。
原理流程
- 对慢查询加 EXPLAIN。
- 读取访问类型与索引。
- 核对扫描行数与 join 顺序。
- 定位全表扫描、filesort、大表 join 等问题。
代码或图示
计划关注点:
访问类型:全表扫描 / 索引扫描 / 唯一查找
索引:是否命中预期索引
行数:预估扫描规模
排序:是否 filesort、是否临时表
常见误区
- 只看计划不看实际执行:预估值可能与真实偏差大。
- 计划走了索引就认为快:回表与扫描行数仍可能偏大。
追问
- 待确认点是什么?答:目标库 EXPLAIN 输出字段含义,以数据库官方文档为准。
- 预估行数偏差大怎么办?答:更新统计信息,见 098 题。
04.4.8.4-090 EXPLAIN ANALYZE 与普通 EXPLAIN 有何区别?
一句话结论
EXPLAIN ANALYZE 实际执行查询并输出真实行数、耗时与循环次数;普通 EXPLAIN 只给预估计划。分析慢查询优先用 ANALYZE 看真实瓶颈节点。
概念解释
ANALYZE 实际跑一遍语句,收集每个节点的真实行数、耗时与循环,能发现预估与实际不符的节点。注意:ANALYZE 会真实执行写操作需谨慎(按数据库支持,部分可包装回滚);大结果集语句要限制范围。对比预估与实际差异,定位高估/低估导致的计划选错。真实耗时分布告诉瓶颈在扫描、join 还是排序。
原理流程
- 在测试/受控环境对慢查询执行 ANALYZE。
- 读取各节点真实行数与耗时。
- 对比预估定位偏差节点。
- 针对瓶颈调整索引或语句。
代码或图示
EXPLAIN:预估计划,不执行
EXPLAIN ANALYZE:真实执行,输出实际行数/耗时/循环
注意:写语句与大结果集在受控环境执行
常见误区
- 在生产直接 ANALYZE 大写查询:实际执行可能产生副作用。
- 只看总耗时:不拆到节点,找不到瓶颈算子。
追问
- 待确认点是什么?答:目标库 ANALYZE 是否支持回滚写语句、输出格式,以数据库文档为准。
- 真实行数远大于预估说明什么?答:统计信息过期或索引选择失误,需更新统计或调整索引。
04.4.8.4-091 慢查询日志如何开启与定位问题语句?
一句话结论
数据库慢查询日志记录执行超过阈值的语句,配合行数、耗时与时间戳定位高频慢 SQL;应用侧日志补充语句参数与调用来源。
概念解释
慢日志是数据库侧记录阈值以上语句,包含语句文本、耗时、扫描行数等。阈值按基线设定,过松淹没问题,过严噪音多。分析方向:高频重复慢语句、单次大扫描、特定时间段峰值。数据库慢日志与应用 tracing 关联:语句文本 + 参数 + 调用链路。定期归档慢日志做趋势分析。注意日志不记录敏感明文参数。
原理流程
- 配置慢查询阈值与日志输出。
- 收集超过阈值的语句。
- 按频次/耗时排序定位 Top SQL。
- 结合应用日志与执行计划下钻。
代码或图示
慢日志要素:
语句文本 / 耗时 / 扫描行数 / 时间
频次聚合:高频 vs 单次重语句
关联应用链路:来源接口与调用栈
常见误区
- 只看最慢单条:高频中等耗时语句累计影响可能更大。
- 慢日志不归档:无法看趋势与回归。
追问
- 待确认点是什么?答:目标库慢日志开启参数与字段格式,以数据库官方文档为准。
- 应用侧怎么补充上下文?答:tracing 记录语句模板、参数摘要与接口入口,与数据库日志按时间关联。
04.4.8.4-092 如何判断索引选择是否正确,常见扫描类型有哪些?
一句话结论
看计划中命中的索引是否匹配过滤与排序列;常见类型:全表扫描、索引扫描、唯一索引查找、索引覆盖扫描;选错索引表现为全表扫描、扫描行数大或回表多。
概念解释
理想计划:等值过滤走索引,排序列在索引中,返回列被索引覆盖。常见问题:过滤列无索引、联合索引顺序不匹配、优化器估算选错索引、索引未覆盖导致大量回表。扫描类型对照数据库文档术语。索引不是越多越好:写入维护成本上升。判断后再决定加索引、调整索引顺序或改写语句。
原理流程
- 读计划访问类型与索引名。
- 核对过滤/排序列是否在索引中。
- 评估扫描行数与回表次数。
- 必要时新增/调整索引或改写查询。
代码或图示
扫描类型(术语按数据库):
全表扫描:无索引可用或优化器选择
索引查找:等值命中少量行
索引扫描:沿索引范围扫描
覆盖索引:返回列全部在索引内,免回表
常见误区
- 有索引就认为被使用:计划可能因估算选择全表扫描。
- 只加单列索引:联合查询与排序需求未覆盖。
追问
- 为什么有索引却不走?答:统计信息偏差、索引区分度低、语句条件不匹配索引列顺序,需结合计划分析。
- 覆盖索引怎么判断?答:SELECT 返回列都在索引中,计划无回表步骤。
04.4.8.4-093 参数化查询与执行计划缓存是什么关系?
一句话结论
参数化(绑定变量)使语句文本稳定,数据库可复用解析与执行计划缓存;字符串拼接动态 SQL 导致语句种类膨胀,计划缓存命中率下降。
概念解释
预编译/参数化把语句模板与参数分离,相同模板复用计划。动态拼接出大量不同文本,每条重新解析生成计划,缓存失效。计划缓存还受参数值分布影响(绑定变量窥探)。应用层必须用绑定参数而非拼值,同时兼顾防注入。框架/驱动的语句缓存行为与数据库侧计划缓存是两层,分别确认。
原理流程
- 语句模板固定,参数绑定传入。
- 数据库缓存该模板执行计划。
- 同模板后续调用复用计划。
- 动态拼接文本绕开缓存,逐条解析。
代码或图示
参数化:
模板固定 → 计划可缓存复用
值绑定传入,防注入
拼接:
文本多样 → 计划缓存命中率低,逐条解析
常见误区
- 为了灵活性拼值进 SQL:既失缓存又有注入风险。
- 以为参数化就一定复用计划:计划选择还受统计信息与参数分布影响。
追问
- 待确认点是什么?答:目标数据库计划缓存机制与驱动语句缓存层级,以数据库与驱动文档为准。
- 标识符能参数化吗?答:表名/列名不能绑定,需白名单控制后进入模板。
04.4.8.4-094 执行计划不稳定与绑定变量窥探如何理解?
一句话结论
同一模板不同参数值的数据分布差异大时,数据库可能为不同值选错计划;绑定变量窥探在首次参数基础上生成计划,后续值复用导致计划不优。
概念解释
执行计划依赖列选择性:某值匹配多行 vs 唯一行,最优计划不同。参数化计划缓存后,首个参数的窥探结果影响后续复用。分布倾斜的表容易出现计划不稳定。缓解:统计信息更新、必要时拆分语句、按数据库能力启用计划重优化。表现为同一语句有时快有时慢,与参数值相关。排查时用 ANALYZE 分别看不同参数计划。
原理流程
- 模板首次执行,数据库按首个参数估算计划。
- 计划缓存供后续参数复用。
- 分布倾斜时复用计划对其他值不优。
- 更新统计或调整语句/索引改善。
代码或图示
计划不稳定线索:
同模板不同参数,耗时差异大
计划随参数值切换索引/全表扫描
统计信息陈旧导致估算偏差
常见误区
- 计划慢就直接加索引:可能是参数分布导致计划选错。
- 忽略统计信息更新:估算偏差持续存在。
追问
- 待确认点是什么?答:目标库计划缓存、窥探与重优化策略,以数据库文档为准。
- 怎么复现对比?答:用不同代表性参数分别 EXPLAIN ANALYZE,比较计划与行数。
04.4.8.4-095 连接等待排队如何与慢查询区分排查?
一句话结论
连接等待是池/代理层拿不到连接,表现为获取阶段耗时;慢查询是拿到连接后语句执行久。两者指标层级不同,根因分别在池容量/泄漏与数据库语句。
概念解释
排查先定位耗时阶段:获取连接前等待(池排队、代理满)还是语句执行中(数据库慢)。池指标看队列与等待时长;数据库侧看活跃语句与锁等待。连接等待常由慢查询/长事务占满连接间接导致,两者可能连锁:慢语句占连接 → 池耗尽 → 新请求排队。处置顺序先释放被占连接(优化慢语句),再谈扩容池。
原理流程
- 划分阶段:acquire 等待 vs 执行耗时。
- 池指标:队列长度、等待时长、借出占用。
- 数据库侧:活跃语句、锁等待、事务时长。
- 确定根因链条并处置。
代码或图示
分层排查:
获取阶段:池排队 / 代理连接满
执行阶段:慢 SQL / 锁等待 / 长事务
连锁:慢语句占连接 → 池耗尽 → 新请求排队
常见误区
- 排队就调大池:根因是连接被慢语句占满,扩容只是延缓。
- 只看应用耗时:不拆阶段,分不清池与库问题。
追问
- 怎么看数据库活跃连接与语句?答:数据库侧视图查活跃会话、正在执行语句与等待事件,具体视图按方言。
- 池指标与数据库指标如何对齐?答:按时间线关联应用等待高峰与数据库活跃会话峰值。
04.4.8.4-096 如何检查 ORM 生成的 SQL 是否符合预期?
一句话结论
开启语句日志打印生成 SQL 与参数,对照预期条件、join、排序与分页;重点检查多余 join、错误条件、N+1 与未走索引的语句。
概念解释
ORM 链式 API 与最终 SQL 之间存在转换层,风险:关联预加载产生 N+1、条件拼错、排序缺失、隐式 join。检查方式:开发/测试环境打印语句,评审核心接口生成 SQL;结合执行计划确认索引利用。复杂语句可退回原生 SQL 并映射 DTO。ORM 生成日志要在生产脱敏。每个新增查询接口在测试中观察 SQL 数量与文本。
原理流程
- 开启 ORM/驱动语句日志。
- 跑代表性请求,收集 SQL 序列。
- 核对条件、join、排序、limit 与查询次数。
- 慢语句过执行计划,必要时改写。
代码或图示
检查清单:
WHERE 条件是否完整、参数是否绑定
JOIN 是否多余或方向错误
ORDER BY / LIMIT 是否正确
查询次数:是否 N+1
计划:索引是否命中
常见误区
- 只看 Rust 代码不看 SQL:问题在生成层才暴露。
- 上线后才发现 N+1:测试环境就应统计查询次数。
追问
- 待确认点是什么?答:所选 ORM 语句日志开关与输出格式,以版本文档为准。
- 生成 SQL 很差怎么办?答:先调整查询构造与预加载;表达不了的退回原生 SQL 出口。
04.4.8.4-097 如何识别缺失索引与冗余索引?
一句话结论
缺失索引表现为高频查询全表扫描或排序;冗余索引是重复或被其他索引前缀覆盖的索引,徒增写入成本;两者都要结合查询模式与写入开销评估。
概念解释
缺失:慢查询计划走全表扫描/ filesort,过滤与排序列无索引支撑。冗余:多个索引列前缀重叠,或从未被优化器选用。索引维护拖慢写入、占用存储。定期评审:列出高频查询需求对应索引,删除未使用与重复索引。联合索引设计避免单列堆叠。索引调整要在测试环境验证计划变化。
原理流程
- 从慢日志与查询统计提取高频条件/排序。
- 核对现有索引覆盖情况,补缺失索引。
- 检查重复前缀与长期未使用索引。
- 评估写入开销后删除冗余。
代码或图示
缺失信号:
全表扫描、filesort、扫描行数大
冗余信号:
索引前缀被另一索引覆盖
长期零使用的索引
常见误区
- 每个查询列都建单列索引:联合查询用不上,写入负担重。
- 只加不删:索引越积越多,写入变慢。
追问
- 待确认点是什么?答:目标库索引使用统计视图,以数据库文档为准。
- 联合索引列顺序怎么定?答:等值过滤列在前,排序列在后,区分度结合查询模式评估。
04.4.8.4-098 统计信息过时为什么会导致计划选错?
一句话结论
优化器依赖表与列的统计信息(行数、分布、基数)估算代价;统计信息过期时估算偏差大,可能选择低效索引或全表扫描。
概念解释
统计信息记录表规模、列值分布、索引基数等。数据大量增删后统计未更新,估算行数与实际偏离,计划选择失误。表现为计划与实际行数不符(ANALYZE 可见偏差)。数据库自动统计刷新机制 + 手动更新命令结合。大表更新统计要评估锁与资源开销,按窗口执行。统计问题与索引缺失要区分:前者计划估算错,后者根本无索引可用。
原理流程
- 数据大量变更后统计滞后。
- 优化器按旧分布估算代价。
- 选择偏离实际的执行计划。
- 更新统计信息后重新评估。
代码或图示
统计信息:
表行数 / 列基数 / 值分布 / 索引统计
过期 → 估算偏差 → 计划选错
处置:自动刷新 + 手动更新(按数据库方言命令)
常见误区
- 计划差就以为缺索引:可能只是统计过期。
- 大表随意手动更新统计:资源开销与锁影响需评估。
追问
- 待确认点是什么?答:目标库统计信息自动刷新策略与手动更新命令,以数据库文档为准。
- 怎么判断是统计问题?答:ANALYZE 实际行数与预估行数偏差显著,更新统计后计划改善。
04.4.8.4-099 常见的慢 SQL 模式有哪些?
一句话结论
高频慢模式:无索引过滤的全表扫描、深分页 offset、SELECT 取多余列、大表 join 无索引、函数包裹索引列、隐式类型转换、大事务批量写。
概念解释
逐类识别:条件列无索引;深 offset 扫描丢弃;宽行查询取大量列;多表 join 关联列无索引;WHERE func(col)=... 使索引失效;类型不匹配导致转换不走索引;一次性大批量写入持锁久。每种模式对应计划特征与改写方向。评审新 SQL 时对照清单排查。慢语句还要看数据量增长后的退化,小表测试不慢不代表上线快。
原理流程
- 从慢日志归类语句模式。
- 对照常见清单定位失效点。
- 改写语句或补索引。
- 测试数据量下验证计划。
代码或图示
慢模式清单:
全表扫描 / filesort
深 offset 分页
多余列与大结果集
join 关联列无索引
函数/转换包裹索引列
隐式类型转换
大批量单事务写入
常见误区
- 函数包裹列仍指望走索引:索引列被计算后无法直接使用。
- 小表测试通过就上线:数据量增长后计划退化。
追问
- 隐式类型转换怎么发现?答:计划中列被转换函数处理,或字段类型与参数类型不一致;核对表定义与参数类型。
SELECT *有什么问题?答:取多余列增加回表与网络传输,应取必要列。
04.4.8.4-100 数据库性能与事务问题的综合排查清单是什么?
一句话结论
按「连接池 → 事务与锁 → 语句与计划 → 缓存兜底」逐层定位:先看连接是否耗尽与泄漏,再看长事务与锁等待,最后分析慢 SQL 执行计划,缓存层评估回源与一致性。
概念解释
综合清单把本文件各题串成完整链路:池指标区分获取排队与执行慢;数据库侧活跃事务、锁等待与慢日志定位持锁语句;EXPLAIN ANALYZE 定位计划问题;缓存回源率与一致性兜底。优化顺序:先消除泄漏与长事务,再修慢语句与索引,最后调缓存。所有结论以真实指标与执行计划为准,不凭感觉调参。
原理流程
- 连接层:池大小、空闲、队列、泄漏、健康检查。
- 事务层:事务时长、持锁、等待、死锁。
- 语句层:慢日志、计划、索引、参数化。
- 缓存层:命中率、回源、失效一致性。
代码或图示
综合排查顺序:
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 验证路径,不写死未经核实的版本行为。