知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 24 - 分布式事务怎么做 > 导读:本文用一问一答的方式,讲清 2PC、TCC、Saga、本地消息表四种分布式事务方案的原理、代价与选择依据,读完你能针对不同业务场景给出合适的方案并进行取舍说明。适合准备后端面试、以及需要处理跨服务数据一致性的工程师。 ## 一、先建立全局认知 ### Q:什么情况下需要分布式事务? A:结论:**当一个业务操作要跨多个服务/多个数据库,且这些写入必须"要么全成功、要么全失败"时,本地事务就无能为力了**。 典型场景是电商下单:订单服务创建订单、库存服务扣减库存、积分服务增加积分,这三个操作分布在不同数据库,每个库自己的本地事务只能保证自己那一步,无法覆盖整体。单库的 ACID 事务在这里失效,就必须引入分布式事务方案。 ### Q:主流的分布式事务方案有哪几类? A:四类——2PC(两阶段提交)、TCC(Try-Confirm-Cancel)、Saga、本地消息表。它们的共同点是都放弃了"全程强一致",转而用不同手段去逼近一致性:要么靠资源锁定(2PC),要么靠预留与补偿(TCC/Saga),要么靠可靠的事件传递(本地消息表)。 ## 二、理解核心机制 ### Q:2PC 是怎么工作的,代价是什么? A:2PC 引入一个协调者,分两个阶段让所有参与者一起提交或一起回滚。  *图:2PC 两阶段:Prepare 与 Commit* ```text 协调者(Transaction Manager)协调多个参与者: 阶段一:Prepare(准备) 协调者 → 参与者A:你能提交吗? 协调者 → 参与者B:你能提交吗? 参与者A → 协调者:可以(锁定资源,写 redo/undo 日志) 参与者B → 协调者:可以 阶段二:Commit(提交) 如果所有参与者都回复"可以": 协调者 → 所有参与者:提交! 如果任一参与者回复"不行": 协调者 → 所有参与者:回滚! ``` Java 中通过 JTA(Java Transaction API)实现,底层走 XA 协议: ```java // Java 中通过 JTA(Java Transaction API)实现 @Transactional public void placeOrder(OrderDTO dto) { // XA 事务:跨数据库的两阶段提交 orderDataSource.createOrder(dto); // 数据库 A inventoryDataSource.deductStock(dto); // 数据库 B // 由事务管理器协调两个数据库的提交/回滚 } ``` 其中 XA 是数据库层面支持的两阶段提交协议规范,JTA 是 Java 侧的事务 API。 **优缺点**: - 优点:强一致性,数据库原生支持(XA 协议) - 缺点:同步阻塞(Prepare 阶段锁资源)、协调者单点故障、性能差 - 适用:对一致性要求极高、并发量不大的场景(如银行转账) ### Q:TCC 是怎么工作的,代价是什么? A:TCC 为每个服务提供三个接口,把"一次操作"拆成"预留—确认—取消"。 ```text 每个服务提供三个接口: Try:预留资源(冻结库存、冻结余额) Confirm:确认提交(扣减冻结的库存、扣减冻结的余额) Cancel:取消释放(解冻库存、解冻余额) ``` ```java // 库存服务 TCC 接口 public interface InventoryTccService { // Try:冻结库存 @TwoPhaseBusinessAction(name = "deductStock", commitMethod = "confirm", rollbackMethod = "cancel") boolean tryDeduct(BusinessActionContext context, @BusinessActionContextParameter(paramName = "productId") Long productId, @BusinessActionContextParameter(paramName = "count") int count); // Confirm:扣减冻结的库存 boolean confirm(BusinessActionContext context); // Cancel:解冻库存 boolean cancel(BusinessActionContext context); } // Try 实现 public boolean tryDeduct(BusinessActionContext context, Long productId, int count) { // UPDATE inventory SET frozen = frozen + #{count} // WHERE product_id = #{productId} AND stock - frozen >= #{count} return inventoryMapper.freeze(productId, count) > 0; } // Confirm 实现 public boolean confirm(BusinessActionContext context) { Long productId = (Long) context.getActionContext("productId"); int count = (int) context.getActionContext("count"); // UPDATE inventory SET stock = stock - #{count}, frozen = frozen - #{count} return inventoryMapper.confirmDeduct(productId, count) > 0; } // Cancel 实现 public boolean cancel(BusinessActionContext context) { Long productId = (Long) context.getActionContext("productId"); int count = (int) context.getActionContext("count"); // UPDATE inventory SET frozen = frozen - #{count} return inventoryMapper.unfreeze(productId, count) > 0; } ``` 关键点:Try 阶段不真正扣减,而是"冻结"(frozen + count),并用 `stock - frozen >= count` 条件保证不会超卖;Confirm 才把冻结量转为实际扣减;Cancel 则解冻。这样资源在中间态是被预留而非锁死的,其他事务依然可以读取。 **优缺点**: - 优点:不锁数据库资源,性能好;最终一致性 - 缺点:代码侵入性强(每个服务要写 3 个接口);需要处理空回滚、悬挂、幂等 - 适用:对性能要求高、资金类业务(支付、转账) ### Q:Saga 和 TCC 有什么不同? A:Saga 把长事务拆成多个本地事务,每一步都配一个补偿操作,失败时按逆序回滚——它不预留资源,而是"先做、再补偿"。  *图:Saga 正向流程与补偿流程* ```text Saga 把长事务拆成多个本地事务,每个事务有对应的补偿操作: 正向流程:T1 → T2 → T3 补偿流程:如果 T3 失败 → C2(补偿 T2)→ C1(补偿 T1) 示例: T1:创建订单(状态=待支付) T2:扣减库存 T3:扣减余额 ← 失败! C2:回补库存 C1:取消订单 ``` ```java // 使用 Seata Saga 状态机定义(JSON 配置) // 也可以用编排式(Orchestration)代码实现: public class OrderSagaOrchestrator { public void placeOrder(OrderDTO dto) { try { // 正向流程 Order order = orderService.create(dto); // T1 inventoryService.deduct(dto.getProductId(), 1); // T2 accountService.debit(dto.getUserId(), dto.getAmount()); // T3 } catch (Exception e) { // 补偿流程(逆序) compensate(dto); } } private void compensate(OrderDTO dto) { try { accountService.refund(dto.getUserId(), dto.getAmount()); } catch (Exception ignored) {} try { inventoryService.rollback(dto.getProductId(), 1); } catch (Exception ignored) {} try { orderService.cancel(dto.getOrderId()); } catch (Exception ignored) {} } } ``` 关键点:补偿必须逆序执行,且每个补偿自身要能容忍失败(示例里用 try-catch 忽略异常,实际生产中需要重试与告警)。与 TCC 的区别在于:TCC 在 Try 阶段就预留资源、隔离性更好;Saga 不做预留、直接提交,中间状态对外可见,因此隔离性更弱但实现更轻。 **优缺点**: - 优点:无全局锁,性能好;适合长流程 - 缺点:不保证隔离性(中间状态可见);补偿逻辑复杂 - 适用:跨多个服务的长流程(如旅行预订:机票+酒店+租车) ## 三、放进真实场景 ### Q:本地消息表为什么被推荐? A:因为它用"本地事务 + 可靠投递"绕开了分布式事务,实现简单、不引入额外框架。 ```text 核心思想:利用本地事务保证"业务操作 + 写消息"的原子性 流程: 1. 订单服务在本地事务中:创建订单 + 写消息表(同一个数据库) 2. 定时任务扫描消息表,发送 MQ 3. 库存服务消费 MQ,扣减库存 4. 库存服务处理完成后,回调或发消息确认 5. 订单服务收到确认,更新消息状态为"已完成" ``` ```java // 1. 本地事务:业务操作 + 写消息表 @Transactional public void createOrder(OrderDTO dto) { // 创建订单 Order order = new Order(dto); orderMapper.insert(order); // 写本地消息表(同一个数据库事务) LocalMessage msg = new LocalMessage(); msg.setMsgId(UUID.randomUUID().toString()); msg.setTopic("inventory-deduct"); msg.setBody(JSON.toJSONString(new DeductCommand(dto.getProductId(), 1))); msg.setStatus("INIT"); localMessageMapper.insert(msg); } // 2. 定时任务:扫描并发送消息 @Scheduled(fixedRate = 5000) public void sendPendingMessages() { List<LocalMessage> messages = localMessageMapper.selectByStatus("INIT", 100); for (LocalMessage msg : messages) { try { mqProducer.send(msg.getTopic(), msg.getBody()); localMessageMapper.updateStatus(msg.getMsgId(), "SENT"); } catch (Exception e) { // 发送失败,下次重试 log.error("消息发送失败: {}", msg.getMsgId(), e); } } } // 3. 消费者:幂等消费 @RocketMQMessageListener(topic = "inventory-deduct") public void onMessage(String body) { DeductCommand cmd = JSON.parseObject(body, DeductCommand.class); // 幂等检查 + 扣减库存 inventoryService.deductIdempotent(cmd); } ``` 关键点:这是三段代码协同——第一段把"创建订单"和"写消息"放在同一个数据库事务里,保证两者同生共死;第二段用定时任务兜住"消息一定发出去",即使发送失败也会重试;第三段强调**消费端必须幂等**,因为重试机制天然会带来重复投递。适用场景:大多数业务,性价比最高。 **优缺点**: - 优点:不依赖分布式事务框架,实现简单可靠;最终一致性 - 缺点:有延迟(定时扫描间隔);消息表会膨胀需要定期清理 - 适用:大多数业务场景,性价比最高 ### Q:RocketMQ 事务消息和本地消息表有什么区别? A:本质思路相同,都是保证"业务操作 + 发消息"的原子性;区别在原子性的实现载体。 本地消息表靠数据库事务保证原子性,需要建消息表、写定时扫描任务;RocketMQ 事务消息靠 Half Message + 回查机制实现,不需要消息表和定时任务,但强依赖 RocketMQ 这一中间件。选型时:已经用 RocketMQ 就优先用事务消息,否则本地消息表更通用。 ### Q:TCC 中的空回滚和悬挂是什么? A:这是 TCC 落地时两个必须处理的异常时序。 空回滚:Try 还没执行(比如因为超时或网络问题没到达),协调者就调了 Cancel——Cancel 必须能处理"没有东西可回滚"的情况,不能报错,也不能误扣。 悬挂:Cancel 先执行了,Try 后到达——此时 Try 不能再执行,否则资源会被冻结却永远等不到 Confirm/Cancel。 通用解决方案:用一张事务控制表记录每个分支事务的状态(Try 是否执行、Cancel 是否执行),Cancel 前先查表,Try 前也先查表判断是否已被 Cancel,从而同时防住空回滚与悬挂。另外 Confirm/Cancel 都要保证幂等。 ### Q:四种方案怎么选? A:按下表权衡一致性、性能、代码侵入与复杂度。 | 方案 | 一致性 | 性能 | 代码侵入 | 复杂度 | 适用场景 | |------|--------|------|---------|--------|---------| | 2PC | 强一致 | 低 | 低 | 中 | 银行转账、强一致场景 | | TCC | 最终一致 | 高 | 高(3 个接口) | 高 | 资金类、高并发 | | Saga | 最终一致 | 高 | 中 | 中 | 长流程、跨多服务 | | 本地消息表 | 最终一致 | 中 | 低 | 低 | 大多数业务场景 | 设计取舍:2PC 换强一致但牺牲性能和可用性;TCC 换来高并发下的资金安全但代码侵入最重;Saga 适合长流程但中间状态可见;本地消息表以一点延迟换取最低的落地成本。选型的第一原则是先看业务对一致性的真实要求,而不是直接上最"强"的方案。  [编辑 Excalidraw 源图](/images/java-interview-copy/business-scenario/24-distributed-transaction-distributed-transaction-patterns-diagram.excalidraw) ## 四、总结与自测 ### Q:面试里怎么答这道题? A:按四步答。 1. 先明确:分布式事务没有银弹,根据业务场景选择合适方案 2. 大多数互联网场景用最终一致性就够了,推荐本地消息表或 RocketMQ 事务消息 3. 资金类场景用 TCC,强一致场景用 2PC 4. 不管哪种方案,都要考虑幂等性、超时处理、补偿机制 ### Q:不管选哪种方案,落地时都要补齐哪些横切能力? A:三种:幂等(重复投递或重试下,操作只能生效一次)、超时(Try / 正向事务长时间无响应时的判定与回滚)、补偿(失败路径的可重试、可告警)。这三项与具体方案正交,却决定了分布式事务能否在真实系统里稳定运行——上面的空回滚、悬挂、消费者幂等,本质上都是这三项能力的具体表现。 --- ## 自测 1. 2PC 的 Prepare 阶段为什么要锁定资源?这带来了什么代价? 2. TCC 相比 Saga,在隔离性上有什么优势,代价是什么? 3. 本地消息表方案里,为什么消费端必须做幂等?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入