面试题集锦:分布式事务与数据一致性

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
目标岗位:大型加密货币交易所 · 后端(风控方向)
题目数:22 题
核心主题:缓存一致性、分布式事务(TCC/Saga/AT)、最终一致性 vs 强一致性、对账补偿
Q1:缓存与数据库一致性
TL;DR
缓存一致性最经典方案:Cache Aside(先写 DB,再删缓存)+ 延时双删(写 DB → 删缓存 → 等 500ms → 再删一次)。核心思路:放弃短暂不一致,保证最终一致。
类比
📒 记账本 vs 钱包余额:DB = 账本(权威),Redis = 你脑中记的余额(快捷但不一定准)。花了 100 块→先记账本(写 DB)→再更新脑中的数字(删缓存下次重算)。如果有人查余额,发现脑中数字不对,去翻账本(缓存 miss 查 DB)。
四种缓存策略
| 策略 | 写操作 | 读操作 | 适用 |
|---|---|---|---|
| Cache Aside | 写 DB → 删缓存 | 读缓存 → miss → 读 DB → 写缓存 | 最常用 |
| Read Through | 缓存层自动读 DB | 同 Cache Aside | 封装好的缓存框架 |
| Write Through | 同时写缓存 + DB | — | 数据一致性要求高 |
| Write Behind | 只写缓存 → 异步写 DB | — | 写密集(风险大) |
为什么先写 DB 再删缓存(而非先删缓存再写 DB)?
❌ 先删缓存再写 DB:
1. 删缓存(缓存已空)
2. 另一个读请求 → miss → 读到了旧 DB → 写到缓存(旧数据!)
3. 写 DB(新数据)
→ 缓存中是旧数据,不一致!
✅ 先写 DB 再删缓存(Cache Aside):
1. 写 DB(新数据)
2. 删缓存(缓存为空)
3. 下一个读请求 → miss → 读 DB → 新数据写入缓存
→ 短暂不一致窗口极小(步骤 2-3 之间)
延时双删
// 先写 DB
db.update(order);
// 立即删缓存
redis.del("order:" + orderId);
// 延时 500ms 再删一次(兜底)
scheduler.schedule(() -> {
redis.del("order:" + orderId);
}, 500, TimeUnit.MILLISECONDS);为什么要延时双删:写 DB 过程中,另一个读请求可能 miss 后读到旧 DB 并写入了缓存 → 第一次删除后的这个窗口内,缓存可能被"污染"。延时 500ms 再删一次,确保读请求都已完成。
记忆锚
"Cache Aside = 先写库再删缓存,延时双删兜底"
Q2:用户资产在分布式环境下如何保证强一致性?
TL;DR
资产强一致性 = TCC 模式(Try 冻结 → Confirm 扣减 → Cancel 解冻)或 悲观锁(SELECT FOR UPDATE)。交易场景资金扣减必须是强一致,不能最终一致。
类比
💳 信用卡预授权:酒店入住(Try)→ 先冻结 1000 元(不是真扣,余额显示"可用余额 -1000")→ 退房确认(Confirm)→ 真扣。如果入住失败 → 取消(Cancel)→ 解冻。TCC 就是这个预授权模型。
TCC 实现资产扣减
// Try:冻结资产
@Transactional
public boolean tryFreeze(long userId, long amount) {
// UPDATE account SET frozen = frozen + ?, available = available - ?
// WHERE available >= ? ← 关键:条件更新保证不超扣
int rows = accountMapper.freeze(userId, amount);
return rows > 0;
}
// Confirm:确认扣减(冻结 → 已扣)
@Transactional
public void confirmDeduct(long freezeId) {
// UPDATE account SET frozen = frozen - ?, balance = balance - ?
// UPDATE freeze_record SET status = 'CONFIRMED'
}
// Cancel:解冻(冻结 → 回到可用余额)
@Transactional
public void cancelFreeze(long freezeId) {
// UPDATE account SET available = available + ?, frozen = frozen - ?
// UPDATE freeze_record SET status = 'CANCELLED'
}为什么不用 Saga?
Saga:正向操作 + 补偿操作(无冻结阶段)
→ 扣减余额 + 如果失败 → 补偿加回
→ 问题:在"扣减→补偿"之间,用户读到余额变少了(虽然最终会恢复)
→ 交易所资产场景不可接受!
TCC:Try 时只是冻结,用户能看到"冻结金额"但不会消失
→ 确认前资金还在,只是不可用
→ 用户感知更好,更符合金融规范
记忆锚
"资产强一致 = TCC 预授权模式,冻结→确认→解冻"
Q3:高并发下用户余额扣减的一致性和准确性
TL;DR
余额扣减 = 乐观锁(version 字段 + CAS UPDATE)处理一般并发 + Redis Lua 预扣 处理极高并发 + 对账系统 兜底。核心:UPDATE ... WHERE version = ? AND balance >= ?。
方案演进
| 方案 | QPS | 安全 | 适用 |
|---|---|---|---|
| SELECT FOR UPDATE | 1000 | ⭐⭐⭐⭐⭐ | 对一致性要求极致的场景 |
| 乐观锁(version) | 10000 | ⭐⭐⭐⭐ | 一般高并发 |
| Redis Lua 预扣 + DB 异步 | 100000 | ⭐⭐⭐ | 超高并发(需对账兜底) |
乐观锁实现
-- version 字段做乐观锁
UPDATE account
SET balance = balance - 100, version = version + 1
WHERE user_id = ? AND version = ? AND balance >= 100;
-- affected rows = 0 → 版本冲突或余额不足 → 重试Redis Lua 预扣 + DB 异步
-- Redis 预扣(原子)
local balance = redis.call('GET', KEYS[1])
if balance >= ARGV[1] then
redis.call('DECRBY', KEYS[1], ARGV[1])
return 1 -- 预扣成功
else
return 0 -- 余额不足
end
-- 异步写 DB:Kafka → 消费者 → 最终扣减 DB
-- 对账:每小时对比 Redis 和 DB,差异自动修复记忆锚
"乐观锁保准确,Redis Lua 保性能,对账系统兜底"
Q4:风控检查→扣款→通知,中间失败怎么补偿?
TL;DR
这个场景最适用 Saga 编排模式:每一步有正向操作和补偿操作。风控通过(不可逆)→ 扣款失败 → 不需要撤回风控决策(因为扣款根本没发生),只需要结束流程并通知用户"交易失败"。
状态机设计
Saga 补偿链
正向:风控PASS → 冻结资产 → 扣款 → 通知
补偿:扣款失败 → 解冻资产 → 订单状态=FAILED
冻结失败 → 订单状态=FAILED(无需补偿风控)
关键:风控决策不需要"撤回",因为后续步骤失败意味着交易并未发生。
风控决策记录只是标记为"EXPIRED"或"NOT_EXECUTED"。
记忆锚
"风控决策不撤回,只标记过期——因为交易根本没发生"
Q5:风控判定通过但下游扣款失败,怎么撤回决策?
TL;DR
决策不撤回,做凭证过期。风控 PASS 返回的是一个带有效期的决策凭证(token),下游扣款成功才激活凭证。超时未激活 → 凭证自动失效 → 等同于"决策未被执行"。
方案设计
三种方案对比
| 方案 | 机制 | 优点 | 缺点 |
|---|---|---|---|
| 决策凭证过期 | 风控返回带 TTL 的 token | 简单,风控不需感知下游 | 有短暂窗口(TTL 期间) |
| 下游回调通知 | 下游扣款失败主动通知风控 | 实时 | 增加下游依赖 |
| 定时对账扫描 | 每小时扫"PASS 但订单失败" | 不侵入业务 | 有延迟 |
推荐:凭证过期 + 对账兜底
风控决策带 30s TTL → 下游 30s 内完成扣款 → 成功则激活凭证
→ 超时未激活 → 凭证自动失效 + 每小时对账确认
记忆锚
"决策 = 带 TTL 的凭证,下游成功才激活,超时自动废"
Q6:Saga 模式详解
TL;DR
Saga = 把一个长事务拆成 N 个本地事务 + N 个补偿事务。两种编排:Choreography(事件驱动,服务间直接通信)→ Orchestration(中心编排器控制流程)。金融场景选 Orchestration。
类比
✈️ 旅行预订:订机票→订酒店→租车,任何一步失败取消前面所有(补偿)。Choreography = 你自己一个个打电话通知取消。Orchestration = 旅行社帮你统一取消。
Choreography vs Orchestration
| Choreography | Orchestration | |
|---|---|---|
| 控制流 | 散布在各服务中 | 集中在编排器 |
| 通信 | 事件驱动(MQ) | 编排器调用各服务 |
| 可观测性 | 难追踪(事件满天飞) | 易追踪(编排器有状态) |
| 复杂度 | 服务多了爆炸 | 编排器是瓶颈(需高可用) |
| 适用 | 简单流程(≤3 步) | 复杂流程(金融/交易) |
Orchestration 状态机
// Saga 编排器
class TransferSagaOrchestrator {
enum State { START, RISK_CHECKED, FROZEN, DEDUCTED, COMPLETED, COMPENSATING }
void execute(TransferRequest req) {
try {
// Step 1
riskService.check(req); // 无补偿(不可逆但不需补偿)
state = RISK_CHECKED;
// Step 2
FreezeResult fr = walletService.freeze(req); // 补偿:unfreeze
state = FROZEN;
// Step 3
walletService.deduct(req); // 补偿:refund
state = COMPLETED;
} catch (Exception e) {
compensate(); // 按状态执行对应补偿
}
}
void compensate() {
switch (state) {
case DEDUCTED: walletService.refund(...); // fall through
case FROZEN: walletService.unfreeze(...); // fall through
case RISK_CHECKED: break; // 无需补偿
}
}
}记忆锚
"Saga = 本地事务 + 补偿事务,Orchestration 适合金融,Choreography 适合简单"
Q7:TCC 模式 + 三大难题
TL;DR
TCC = Try(预留资源)→ Confirm(确认使用)→ Cancel(释放资源)。三大难题:空回滚(Cancel 了一个没 Try 过的)→ 幂等(Confirm/Cancel 可能重复调用)→ 悬挂(Cancel 先到,Try 后到)。
类比
📞 预订会议室:Try = 查看会议室空闲并暂定(别人看是"使用中"但实际没确认)→ Confirm = 确认使用 → Cancel = 取消预订。三个难题对应:会议室没预订但收到了取消通知(空回滚)、同一个人点了两次取消(幂等)、取消通知比预订通知先到(悬挂)。
三大难题详解
// 1. 空回滚防护:Cancel 时检查是否 Try 过
public void cancelFreeze(String tccId) {
TccRecord record = tccMapper.selectById(tccId);
if (record == null) {
// 空回滚:记录一条 CANCEL 空记录,防止后续 Try
tccMapper.insertEmptyCancel(tccId);
return;
}
// 正常 Cancel
doCancel(record);
}
// 2. 幂等:Try/Confirm/Cancel 可能重复调用
// → 通过唯一 tccId + 状态机防重
// UPDATE tcc_record SET status = 'FROZEN' WHERE tcc_id = ? AND status = 'TRYING'
// 3. 悬挂:Cancel 先到,Try 后到
// → Try 时检查是否已被 Cancel(存在空 Cancel 记录)
public void tryFreeze(TccRequest req) {
if (tccMapper.existsCancel(req.getTccId())) {
return; // 已被 Cancel,拒绝 Try
}
doTry(req);
}记忆锚
"空回滚查无 Try + 幂等状态机 + 悬挂先查 Cancel 记录"
Q8:本地消息表 vs 事务消息(RocketMQ)
TL;DR
本地消息表 = 业务操作和消息记录在同一个 DB 事务中 → 定时任务扫未发送消息 → 发送到 MQ。事务消息 = RocketMQ 原生支持的半消息机制,先发 prepare → 执行本地事务 → commit/rollback。
类比
📬 挂号信 vs 快递:本地消息表 = 你去邮局寄挂号信(在邮局柜台登记 + 寄出 = 同一个事务)。事务消息 = 快递员上门取件(先给你填单号→你打包好→他拿走),如果快递员半路丢了会通知你。
对比
| 本地消息表 | RocketMQ 事务消息 | |
|---|---|---|
| 原理 | DB 事务内记录消息 | MQ 半消息 + 本地事务回查 |
| 实现 | 自建(消息表 + 定时任务) | RocketMQ 内置 |
| 可靠 | ⭐⭐⭐⭐(定时任务有间隔) | ⭐⭐⭐⭐⭐(实时回查) |
| 复杂度 | 简单(一个表 + 一个定时任务) | 需 RocketMQ 环境 |
| 适用 | 无 RocketMQ 或简单场景 | 交易/风控核心链路 |
本地消息表实现
-- 业务操作 + 消息记录 = 同一个本地事务
BEGIN;
UPDATE account SET balance = balance - 100 WHERE user_id = 1;
INSERT INTO outbox (event_type, payload, status)
VALUES ('BALANCE_CHANGED', '{"userId":1,"amount":-100}', 'PENDING');
COMMIT;
-- 定时任务(每秒扫描)
SELECT * FROM outbox WHERE status = 'PENDING' LIMIT 100;
-- → 发送到 Kafka → 标记 status = 'SENT'记忆锚
"本地消息表靠定时扫,事务消息靠 MQ 回查,金融核心链路选后者"
Q9:Seata AT 模式 + 脏读问题 + @GlobalLock
TL;DR
Seata AT = 两阶段提交:一阶段记录 undo log + 提交本地事务 → 二阶段全局 commit(删 undo log)或 rollback(回放 undo log)。默认隔离是读未提交(一阶段提交后其他事务就能看到),所以有脏读风险。用 @GlobalLock 防止。
类比
🎬 录屏 + 回退:AT 模式 = 每步操作前录屏(undo log),全局操作失败后按录屏回退(Ctrl+Z)。问题:录屏期间别人看到的是"半成品"画面(脏读)。
AT 模式流程
脏读问题
时间线:
T1(全局事务):UPDATE account SET balance=50 → 本地提交(一阶段)
T2(其他事务):SELECT balance → 读到 50 ← 脏读!
T1:全局回滚 → balance 回滚到 100
T2 读到了 50,但最终 T1 回滚了,数据应该是 100!
→ 这就是 AT 模式的脏读问题
@GlobalLock 解决
// 查询时加 @GlobalLock → 如果该行有未完成的全局事务,等待其完成
@GlobalLock
@Select("SELECT balance FROM account WHERE user_id = ?")
BigDecimal getBalance(long userId);
// → T2 会等到 T1 全局事务结束后再读,避免脏读记忆锚
"AT 一阶段就提交 → 默认读未提交 → @GlobalLock 防脏读"
Q10:2PC vs 3PC vs TCC vs Saga 全面对比
| 2PC | 3PC | TCC | Saga | |
|---|---|---|---|---|
| 阶段数 | 2(prepare/commit) | 3(canCommit/preCommit/doCommit) | 3(Try/Confirm/Cancel) | N+1(N个正向+N个补偿) |
| 一致性级别 | 强一致 | 强一致 | 强一致 | 最终一致 |
| 性能 | 差(同步阻塞) | 稍好(有超时) | 好(Try 不锁) | 最好(异步) |
| 复杂度 | 低 | 中 | 高(三大难题) | 中 |
| 业务侵入 | 无 | 无 | 高(需实现 3 接口) | 中(需写补偿) |
| 适用 | 单数据库 | 已基本被取代 | 资金/资产扣减 | 长流程/跨服务 |
| 缺点 | 阻塞、单点 | 复杂、少见 | 开发成本高 | 补偿可能失败 |
选型决策树
资金扣减(强一致+短流程) → TCC
订单流程(最终一致+长流程) → Saga Orchestration
简单跨库操作 → AT(Seata)+ @GlobalLock
极高并发秒杀(最终一致) → 本地消息表 + 对账
记忆锚
"TCC 管钱,Saga 管流程,AT 管简单,本地消息表管高并发"
Q11:最终一致性 vs 强一致性适用场景
TL;DR
涉及资金的操作必须强一致(扣款/转账/充值),非资金操作可以最终一致(发通知/更新缓存/日志/风控评分)。
交易系统场景划分
| 场景 | 一致性级别 | 原因 |
|---|---|---|
| 用户资产扣减 | 强一致(TCC) | 钱不能差一分 |
| 订单状态流转 | 强一致(状态机) | 状态错误会导致业务异常 |
| 风控检查 + 交易 | 最终一致(Saga 补偿) | 风控失败可补偿,非资金 |
| 行情数据推送 | 最终一致 | 毫秒级延迟差异可接受 |
| 用户通知 | 最终一致(本地消息表) | 通知延迟几秒无所谓 |
| 风控规则更新 | 最终一致(<1 分钟同步) | 新规则等 1 分钟生效可接受 |
| 对账修正 | 最终一致(小时级) | 对账兜底 |
记忆锚
"资金用 TCC 强一致,非资金用 Saga/LMQ 最终一致"
Q12:程序 bug 导致错误数据,如何回滚恢复?
TL;DR
数据修复优先级:备份恢复(最快的)→ binlog 回放(MySQL 闪回工具)→ 补偿脚本(最后一招)。修复前必须先备份当前错乱数据(再错也有个快照)。
修复梯队
第 1 梯队(秒级恢复):
→ 数据库快照/备份 → 恢复到 bug 发生前的状态
→ 前提:有备份且影响面是整个表
第 2 梯队(分钟级恢复):
→ MySQL binlog 回放 → 工具:binlog2sql / MyFlash
→ 把 UPDATE/INSERT/DELETE 生成反向 SQL
→ 例:UPDATE SET balance=100 → 反向:UPDATE SET balance=200(旧值)
第 3 梯队(小时级恢复):
→ 编写补偿脚本 → 逐行修复
→ 前提:知道"正确的数据"应该是什么(从其他表/日志推导)
第 4 梯队(终极):
→ 人工修复 + 事后对账
修复前必做
1. 备份当前错数据(CREATE TABLE xxx_bak AS SELECT * FROM xxx)
2. 确认影响范围(受影响行数、时间范围)
3. 在测试环境验证修复脚本
4. 先修复 1 条 → 验证 → 批量修复
5. 修完对账
记忆锚
"备份→binlog 闪回→补偿脚本,修复前先把错数据备份"
Q13:Redis 宕机重启后资产数据恢复 + 与 DB 一致
TL;DR
Redis 重启后数据丢失 = 从 DB 重新加载全量数据 + 重放 AOF/RDB。一致性保证 = 重启后不立即接受请求,先全量同步 DB,再开启写入。
恢复流程
一致性保证
1. 重启期间拒绝请求(健康检查标记为 NOT_READY)
2. 从 DB 全量加载(SELECT balance FROM accounts)
3. 加载完成后标记 READY → 开始接受请求
4. 启动增量补偿:从 Kafka 消费宕机期间的消息(offset 已持久化)
5. 对账兜底:每小时对比 Redis 和 DB,差异自动修复
为什么不全用 AOF?
AOF 实时记录每一条写命令 → 重启回放所有命令 → 慢(百万条命令回放几分钟)
RDB 快照 → 重启加载快(秒级)但可能丢失最后几分钟数据
推荐:RDB + 增量补偿(从 Kafka/DB 补全快照之后的数据)
记忆锚
"重启→从 DB 全量重建→标记 ready→对账兜底"
Q14:跨多个服务的最终一致性业务状态流转
TL;DR
状态流转 = 状态机 + 事件驱动 + Saga Orchestration。每个状态变更是一个本地事务 + 发布事件 → 下一个服务消费事件 → 更新自己的状态。
示例:订单创建→支付→发货→完成
实现:状态机 + 本地消息表
-- 订单服务
BEGIN;
UPDATE orders SET status = 'PAYING' WHERE order_id = ? AND status = 'CREATED';
INSERT INTO outbox (event_type, payload) VALUES ('ORDER_PAYING', '...');
COMMIT;
-- 支付服务消费 ORDER_PAYING 事件
-- → 执行支付
-- → 发送 PAYMENT_SUCCESS 事件
-- 订单服务消费 PAYMENT_SUCCESS 事件
BEGIN;
UPDATE orders SET status = 'PAID' WHERE order_id = ? AND status = 'PAYING';
COMMIT;记忆锚
"状态机 + 事件驱动 + 本地消息表保证状态流转可靠"
Q15:高并发下行情数据推送的最终一致性
TL;DR
行情推送的"不一致" = 不同用户同一时刻看到的价格略有差异(差 1-2 个 tick)。这天然可接受——行情数据本身就在变化。方案:Redis 集中缓存 + 本地短期缓存,不要求所有用户看到完全相同的值。
为什么行情不需要强一致?
资金扣减:A 转给 B 100 元 → 必须 A-100 且 B+100,差一分都不行
行情推送:BTC 最新价 67890 → 用户 A 看到 67890,用户 B 看到 67889
→ 差 1 个 tick?完全可以接受。因为下一秒价格又变了。
架构
行情源 → Redis(最新价,1s TTL)
↓
WebSocket 推送给所有连接
不同实例可能读到不同时间的 Redis 值 → 最多差 1 个 tick
→ 这就是最终一致性(且业界认为"足够一致")
记忆锚
"行情天生最终一致——几个 tick 的差异不影响交易决策"
Q16:分布式可靠的、支持重试的异步任务调度
TL;DR
可靠异步任务 = 任务表持久化 + 定时调度/消息队列触发 + 状态机管理 + 指数退避重试 + 死信队列兜底。
架构
表结构
CREATE TABLE async_task (
id BIGINT PRIMARY KEY,
task_type VARCHAR(64),
payload JSON,
status ENUM('PENDING','PROCESSING','COMPLETED','FAILED'),
retry_count INT DEFAULT 0,
max_retries INT DEFAULT 3,
next_retry_time DATETIME,
created_at DATETIME,
INDEX idx_status_next_retry (status, next_retry_time)
);重试策略
指数退避:1s → 2s → 4s → 8s(最多 3 次)
超过 → 死信处理(人工介入 / 告警)
记忆锚
"任务表 + 状态机 + 指数退避重试 + 死信兜底"
Q17:微服务多实例间状态同步
TL;DR
状态同步三种方案:集中存储(Redis/DB,最简单)→ 事件广播(MQ 通知所有实例更新)→ Gossip 协议(实例间直接交换)。行情/风控选集中存储(快 + 简单)。
| 方案 | 一致性 | 延迟 | 复杂度 |
|---|---|---|---|
| Redis 集中存储 | 强一致 | < 5ms | ⭐ 低 |
| MQ 事件通知 | 最终一致 | < 100ms | ⭐⭐ 中 |
| Gossip 协议 | 最终一致 | 秒级 | ⭐⭐⭐ 高 |
记忆锚
"Redis 集中存最省事,MQ 通知延迟低,Gossip 去中心但慢"
Q18:Redis 与数据库缓存一致性(详见 Q1)
本题与 Q1 重复,此处给出补充:常见方案优缺点速查。
| 方案 | 原理 | 优点 | 缺点 |
|---|---|---|---|
| Cache Aside | 写 DB → 删缓存 | 简单 | 短暂不一致 |
| 延时双删 | 写 DB → 删缓存 → 等 500ms → 再删 | 更安全 | 代码复杂 |
| CDC(Canal) | 监听 binlog → 异步更新缓存 | 完全解耦,无入侵 | 有延迟 |
| Write Through | 缓存层同时写 DB | 强一致 | 写性能差 |
Q19:用户下单→扣减资产→生成订单 → TCC vs 本地消息表
TL;DR
扣减资产用 TCC(强一致),生成订单用本地消息表(最终一致即可)。整个流程 = TCC 做核心资产扣减 + Saga 编排整体流程。
为什么这样选?
扣减资产(Try → Confirm/Cancel):
→ 必须强一致!用户钱扣了就不能丢,没扣成就不能说扣了
→ TCC 是最佳选择
生成订单:
→ 资产扣成功了 → 订单必须生成(最终一致即可)
→ 本地消息表:扣减成功 → 写消息 → 异步生成订单
记忆锚
"TCC 保钱,Saga/本地消息表保流程"
Q20:DB 读写分离 → 主从延迟问题 → 解决方案
TL;DR
主从延迟 = 刚写入主库的数据,从库还没同步 → 用户"充了钱查不到余额"。解决:写后读强制走主库 + 关键读也走主库。
场景
用户充值 100 元 → 写入主库 → 页面跳转查看余额
→ 查询路由到从库 → 从库还没同步 → 余额没变 → 用户慌了!
解决方案
// 方案 1:写后读强制走主库(推荐)
@Transactional
public void recharge(long userId, long amount) {
jdbcTemplate.update("UPDATE account SET balance = balance + ? WHERE user_id = ?", amount, userId);
// 30 秒内的查询强制走主库
redis.set("route:master:" + userId, "1", 30, TimeUnit.SECONDS);
}
public BigDecimal getBalance(long userId) {
if (redis.exists("route:master:" + userId)) {
return masterJdbcTemplate.queryForObject(...); // 走主库
}
return slaveJdbcTemplate.queryForObject(...); // 走从库
}
// 方案 2:关键业务操作直接走主库
// 充提查、下单、扣款 — 全部走主库
// 只有历史订单查询、报表等容忍延迟的走从库记忆锚
"写后 30s 内强制主库,充值/扣款/下单永远主库"
Q21:资金对账系统设计
TL;DR
对账 = 日切对账(T+1 全面对)+ 实时对账(核心场景秒级对)。发现差异 → 差异分级(> 阈值 → 告警 + 人工介入,< 阈值 → 自动修复)。修复原则:以 DB 为准,Redis 对齐 DB。
架构
对账维度
1. 总额对账:DB SUM(balance) vs Redis SUM(balance) → 5 分钟内出结果
2. 逐用户对账:异步并行逐用户对比 → 1 小时完成
3. 实时对账:核心交易后 5 秒内比对 → 仅针对高频大额用户
记忆锚
"日切全量对 + 实时重点对,差异分级处理,DB 是权威"
Q22:哪些环节必须强一致,哪些可以最终一致?
TL;DR(口述版)
"在交易系统中,我的判断标准很简单:
强一致(必须):
- 资金扣减:用户余额、冻结、划转
- 订单状态:创建→成交→撤销,状态流转必须准确
- 风控阻断:如果是同步拦截模式,决策不能丢
最终一致(可以接受):
- 行情推送:几个 tick 延迟天然可以接受
- 用户通知:晚几秒收到推送无所谓
- 风控评分更新:规则/模型版本同步 1 分钟延迟 OK
- 审计日志:异步写入 Kafka,最终落库
- 缓存更新:Cache Aside 策略本身就是最终一致
一句话:涉及钱的就强一致,不涉及钱的最终一致就够了。"
总结
缓存一致性 → Cache Aside + 延时双删
资产强一致 → TCC(Try-Confirm-Cancel)
长流程跨服务 → Saga Orchestration
高并发扣减 → 乐观锁 + Redis Lua + 对账
最终兜底 → 对账系统
B5 补充:分布式事务深度追问(Q23-Q35)
来自
questions.md一面弱项:本地消息表到底是什么、Seata 各模式适用、XID 传递、隔离级别深入。
Q23:本地消息表到底是什么?给一个交易场景的完整例子
TL;DR
本地消息表 = 在业务 DB 中建一张 outbox 表,业务操作和消息记录放在同一个本地事务中。然后定时任务扫描 outbox 表中未发送的消息,投递到 MQ。是最简单的"保证业务操作和消息发送原子性"的方案。
类比
✉️ 邮局柜台寄挂号信:你去邮局(同一个 DB 事务),交钱(UPDATE)→ 邮局同时在你面前登记挂号信编号(INSERT outbox)。这俩操作在邮局的一次办理中完成(原子)。之后邮递员(定时任务)扫描登记本(outbox 表),把没发出的信投递出去。
完整例子:下单后发通知
-- 1. 本地事务:更新订单 + 写入 outbox
BEGIN;
UPDATE orders SET status = 'PAID' WHERE order_id = 'ORD-123';
INSERT INTO outbox (event_id, event_type, payload, status, created_at)
VALUES ('EVT-456', 'ORDER_PAID', '{"orderId":"ORD-123","userId":42}', 'PENDING', NOW());
COMMIT;
-- 2. 定时任务(每 1 秒扫描)
SELECT * FROM outbox WHERE status = 'PENDING' LIMIT 100;
-- 3. 发送到 Kafka(发送成功后)
UPDATE outbox SET status = 'SENT' WHERE event_id = 'EVT-456';
-- 4. 下游消费者消费 ORDER_PAID 事件 → 发推送/更新报表outbox 表结构
CREATE TABLE outbox (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
event_id VARCHAR(64) UNIQUE NOT NULL, -- 事件唯一 ID(去重!)
event_type VARCHAR(64) NOT NULL, -- 事件类型(ORDER_PAID / BALANCE_CHANGED)
payload JSON NOT NULL, -- 事件内容
status ENUM('PENDING', 'SENT', 'FAILED') DEFAULT 'PENDING',
retry_count INT DEFAULT 0,
created_at DATETIME,
sent_at DATETIME
);
-- 定时任务扫描 status='PENDING' → 发送 → status='SENT'
-- 失败 → retry_count++, 超过 3 次 → status='FAILED'(告警)本地消息表 vs MQ 事务消息的区别
| 本地消息表 | RocketMQ 事务消息 | |
|---|---|---|
| 是什么 | 你自己建的一张表 + 定时任务 | RocketMQ 内置特性 |
| 原子性保证 | DB 本地事务(INSERT outbox 和业务操作同事务) | 半消息 + Broker 回查 |
| 实时性 | ⚠️ 定时任务间隔(秒级延迟) | ✅ 实时 |
| 实现成本 | 简单(一张表 + 一个定时任务) | 需要 RocketMQ 环境 |
| 适用 | 无 RocketMQ 或非实时场景 | 交易核心链路 |
| 可靠性 | ⭐⭐⭐⭐(定时任务可能宕机) | ⭐⭐⭐⭐⭐(Broker 回查) |
记忆锚
"本地消息表 = 业务操作 + 写 outbox 同事务,定时任务扫未发消息到 MQ。秒级延迟,自己实现"
Q24:Seata AT 模式适用什么?什么不适合?
TL;DR
Seata AT 适合短事务 + 单条 SQL 简单 + 没有业务校验的跨库操作(如扣减库存+生成订单)。不适合长事务(锁持有时间太长)、复杂业务逻辑(AT 只是数据回滚,没法补偿外部调用)、高并发热点行(全局锁竞争)。
✅ 适合 Seata AT:
- 跨库的简单 INSERT/UPDATE(如订单+库存+积分)
- 不需要调用外部服务(无 RPC 补偿需求)
- 事务执行时间 < 1s
❌ 不适合 Seata AT:
- 包含外部 API 调用(发短信/推通知)→ 回滚不了已发的短信
- 热点行高并发 → 全局锁成为瓶颈
- 复杂业务校验 → AT 只做数据回滚,业务逻辑没法补偿
- 跨服务异步调用 → TCC 更合适
记忆锚
"AT = 单条 SQL 跨库无外部调用,短平快。TCC/Saga = 有外部调用需补偿"
Q25:Seata 的 XID 怎么在 Dubbo 和 HTTP 中传递?
TL;DR
XID = 全局事务 ID,Seata 通过 拦截器/Filter 自动传递。Dubbo:Seata 的 TransactionPropagationFilter 把 XID 放在 RpcContext 的 attachment 中传递。HTTP/Feign:通过 SeataHandlerInterceptor 把 XID 放在 HTTP Header(TX_XID)中传递。都透明,不侵入业务代码。
传递机制
Dubbo 传递:
Consumer → Seata Filter 拦截 → 将 XID 写入 RpcContext.attachment
→ Provider → Seata Filter 拦截 → 从 RpcContext 读出 XID → 绑定到当前线程
HTTP/Feign 传递:
Consumer → Seata RequestInterceptor → 将 XID 写入 HTTP Header "TX_XID"
→ Provider → Seata HandlerInterceptor → 从 Header 读出 XID
如果异步线程(如 CompletableFuture):
→ 需要手动传递:RootContext.bind(xid) → 新线程 → RootContext.unbind()
记忆锚
"Dubbo 走 RpcContext attachment,HTTP 走 TX_XID Header,Seata 自动拦截不侵入"
Q26:单机事务隔离级别 vs 分布式事务隔离级别
TL;DR
单机事务隔离级别(Read Committed / Repeatable Read)= MySQL 层面,MVCC + 锁保证。分布式事务默认隔离级别 = 读未提交(一阶段已提交,全局可能回滚 → 其他事务能看到中间态)。这就是 Seata AT 的脏读问题,需要用 @GlobalLock 显式防止。
单机事务隔离级别设置建议
MySQL 默认 RR(Repeatable Read)→ 够用大多数场景
RC(Read Committed)适用:
- 高并发写入(RR 的间隙锁会导致锁冲突严重)
- 不需要防幻读(如日志/流水表)
RR(Repeatable Read)适用:
- 业务需要快照一致性(如报表/对账)
- 有范围查询 + 并发写入(间隙锁防幻读)
Seata AT 的默认隔离 = 读未提交
时间线:
T1:UPDATE balance=50 → 一阶段提交(undo log 记了旧值 100)
T2:SELECT balance → 读到 50 ← 脏读!(T1 可能全局回滚 → 回到 100)
T1:全局回滚 → 回放 undo log → balance 回到 100
→ T2 读到了不该看到的 50
解决:
@GlobalLock 注解 → 查询时等待全局事务结束再读
或 TCC 模式(Try 阶段只冻结余额,不改实际余额,不会脏读)
记忆锚
"单机默认 RR 够用,分布式默认读未提交→@GlobalLock 防脏读"
Q27:最终一致性 vs 强一致性 → 已在 Q11 覆盖
Q28:Seata 的几种模式:AT / TCC / Saga / XA
| 模式 | 原理 | 性能 | 侵入性 | 适用 |
|---|---|---|---|---|
| AT | 自动回滚(undo log) | 好 | 零侵入 | 简单跨库操作 |
| TCC | Try-Confirm-Cancel | 好 | 高侵入(需实现 3 接口) | 资金扣减 |
| Saga | 正向 + 补偿 | 最好 | 中(需写补偿逻辑) | 长流程/跨服务 |
| XA | 两阶段提交(2PC) | 差 | 零侵入 | 同数据库多资源 |
Q29:什么情况用本地消息表?什么情况用 Seata?
本地消息表:
✅ 异步场景(发通知/更新报表/审计日志)→ 最终一致即可
✅ 无 RocketMQ 环境
✅ 简单实现,团队无人熟悉 Seata
❌ 实时性要求高(秒级延迟不够)
Seata AT:
✅ 同步场景(扣库存必须立刻返回成功/失败)
✅ 跨库写操作,需要强一致性
❌ 有外部服务调用(发短信/推送)
Seata TCC:
✅ 资金扣减(需要冻结/确认/解冻语义)
❌ 非资金场景不值得(太重)
Seata Saga:
✅ 长流程(订单→支付→发货→完成,跨多个服务)
❌ 补偿逻辑可能失败(需人工干预)
记忆锚
"异步通知→本地消息表。同步跨库→AT。资金扣减→TCC。长流程→Saga"
Q30:本地消息表的定时任务间隔如何权衡?
间隔 = 1s → 实时性好,DB 压力大(每秒扫一次 outbox 表)
间隔 = 5s → 折中,大多数场景够用(通知/报表容忍 5s 延迟)
间隔 = 30s → DB 压力小,适合非实时场景
优化:
- 索引:CREATE INDEX idx_outbox_status ON outbox(status, created_at)
- 每次 LIMIT 100,批量发送(减少 MQ 请求次数)
- 如果对实时性有要求 → 用 RocketMQ 事务消息代替
Q31:分布式事务的补偿失败怎么办?
TL;DR
补偿失败 = 这条消息卡住了。三种兜底:自动重试(指数退避,最多 3 次)→ 转人工处理(写入补偿失败表,发告警)→ 最终对账修复(每天 T+1 对账,发现差异人工修复)。
补偿失败表设计:
id, saga_id, step, error_msg, created_at, status(PENDING→MANUAL_FIXED)
→ 运营后台查询 + 人工点击"重新补偿"
记忆锚
"重试→转人工→对账兜底,三层保证补偿最终成功"
Q32:什么是 ACID?事务隔离级别?
TL;DR
ACID = Atomicity(原子性,要么全成功要么全回滚)→ Consistency(一致性,事务前后数据满足约束)→ Isolation(隔离性,并发事务互不干扰)→ Durability(持久性,提交后数据永久保存)。
四种隔离级别
READ UNCOMMITTED:读到别人未提交的数据 → 脏读
READ COMMITTED: 只读已提交 → 不可重复读(两次读结果不同)
REPEATABLE READ: 事务内快照一致 → 可能幻读(多了新行)
SERIALIZABLE: 串行执行 → 无并发问题,但性能最差
MySQL InnoDB 默认 REPEATABLE READ + 间隙锁解决幻读
记忆锚
"ACID = 原子一致隔离持久。RR 是 MySQL 默认,间隙锁防幻读"
Q33:DB 缓存一致性深入 → 已在 Q1/Q18 覆盖
Q34:跨线程调用(异步)时 Seata XID 如何传递?
// 异步线程需要手动传递 XID
String xid = RootContext.getXID();
CompletableFuture.runAsync(() -> {
RootContext.bind(xid); // 手动绑定到新线程
try {
// 业务操作 → 自动加入同一个全局事务
} finally {
RootContext.unbind(); // 清理
}
});Q35:Nacos 配置下发原理
TL;DR
Nacos 配置下发 = 客户端长轮询(Long Polling)→ 服务端持有连接 30s → 配置变更 → 立即返回 → 客户端收到后更新本地缓存 + 触发 @RefreshScope Bean 重建。如果 30s 没变更 → 返回空 → 客户端立刻发起下一次长轮询。
Client → GET /config?dataId=xxx&group=yyy&contentMD5=abc
Server → hold 30s(无变更则返回空)
→ 有变更 → 返回新配置 + new MD5
→ Client → 更新本地缓存 → 触发 RefreshEvent
挂了对业务影响:本地缓存兜底(nacos 挂了不影响已启动的服务)
总结
本地消息表 → outbox 表 + 定时任务,秒级延迟
Seata AT → 零侵入跨库,默认读未提交需 @GlobalLock
TCC → 资金扣减专用,三接口侵入
Saga → 长流程跨服务,需补偿逻辑
XID 传递 → Dubbo/RPC context / HTTP Header TX_XID
隔离级别 → 单机 RR 够用,分布式需 @GlobalLock 防脏读
Nacos → 长轮询 + 本地缓存,挂了不影响服务
下一篇:B6 分布式锁 + Redis 高可用 + 缓存架构(18 题)