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

通识对照:分布式事务选型:2PC、TCC、Saga 与本地消息表的取舍合同

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

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 UPDATE1000⭐⭐⭐⭐⭐对一致性要求极致的场景
乐观锁(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 编排模式:每一步有正向操作和补偿操作。风控通过(不可逆)→ 扣款失败 → 不需要撤回风控决策(因为扣款根本没发生),只需要结束流程并通知用户"交易失败"。

状态机设计

interview distributed tx qa · 图 1
interview distributed tx qa · 图 1 · 点击查看 SVG 原图

Saga 补偿链

正向:风控PASS → 冻结资产 → 扣款 → 通知
补偿:扣款失败 → 解冻资产 → 订单状态=FAILED
     冻结失败 → 订单状态=FAILED(无需补偿风控)

关键:风控决策不需要"撤回",因为后续步骤失败意味着交易并未发生。
      风控决策记录只是标记为"EXPIRED"或"NOT_EXECUTED"。

记忆锚

"风控决策不撤回,只标记过期——因为交易根本没发生"


Q5:风控判定通过但下游扣款失败,怎么撤回决策?

TL;DR

决策不撤回,做凭证过期。风控 PASS 返回的是一个带有效期的决策凭证(token),下游扣款成功才激活凭证。超时未激活 → 凭证自动失效 → 等同于"决策未被执行"。

方案设计

interview distributed tx qa · 图 2
interview distributed tx qa · 图 2 · 点击查看 SVG 原图

三种方案对比

方案机制优点缺点
决策凭证过期风控返回带 TTL 的 token简单,风控不需感知下游有短暂窗口(TTL 期间)
下游回调通知下游扣款失败主动通知风控实时增加下游依赖
定时对账扫描每小时扫"PASS 但订单失败"不侵入业务有延迟

推荐:凭证过期 + 对账兜底

风控决策带 30s TTL → 下游 30s 内完成扣款 → 成功则激活凭证
→ 超时未激活 → 凭证自动失效 + 每小时对账确认

记忆锚

"决策 = 带 TTL 的凭证,下游成功才激活,超时自动废"


Q6:Saga 模式详解

TL;DR

Saga = 把一个长事务拆成 N 个本地事务 + N 个补偿事务。两种编排:Choreography(事件驱动,服务间直接通信)→ Orchestration(中心编排器控制流程)。金融场景选 Orchestration。

类比

✈️ 旅行预订:订机票→订酒店→租车,任何一步失败取消前面所有(补偿)。Choreography = 你自己一个个打电话通知取消。Orchestration = 旅行社帮你统一取消。

Choreography vs Orchestration

ChoreographyOrchestration
控制流散布在各服务中集中在编排器
通信事件驱动(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 模式流程

interview distributed tx qa · 图 3
interview distributed tx qa · 图 3 · 点击查看 SVG 原图

脏读问题

时间线:
  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 全面对比

2PC3PCTCCSaga
阶段数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,再开启写入。

恢复流程

interview distributed tx qa · 图 4
interview distributed tx qa · 图 4 · 点击查看 SVG 原图

一致性保证

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。每个状态变更是一个本地事务 + 发布事件 → 下一个服务消费事件 → 更新自己的状态。

示例:订单创建→支付→发货→完成

interview distributed tx qa · 图 5
interview distributed tx qa · 图 5 · 点击查看 SVG 原图

实现:状态机 + 本地消息表

-- 订单服务
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

可靠异步任务 = 任务表持久化 + 定时调度/消息队列触发 + 状态机管理 + 指数退避重试 + 死信队列兜底。

架构

interview distributed tx qa · 图 6
interview distributed tx qa · 图 6 · 点击查看 SVG 原图

表结构

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。

架构

interview distributed tx qa · 图 7
interview distributed tx qa · 图 7 · 点击查看 SVG 原图

对账维度

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)好零侵入简单跨库操作
TCCTry-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 题)