20K Java+AI 岗位高频考点 — 分布式事务是系统设计的核心难题,面试必问CAP理论、Seata四模式、TCC实现。覆盖理论基础、Seata实战、分布式锁、分布式ID、一致性方案。
C(Consistency):所有节点看到相同数据
A(Availability):每个请求都能得到响应
P(Partition Tolerance):网络分区时系统仍工作
定理:分布式系统最多同时满足两项,网络分区必然存在,所以实际是CP或AP
CP系统:ZooKeeper、Etcd、MongoDB(强一致)
AP系统:Eureka、Cassandra、DynamoDB
→ 大多数互联网系统选择AP+最终一致性
BA(Basically Available):基本可用(允许响应变慢/功能降级)
S(Soft State):软状态(允许中间状态)
E(Eventual Consistency):最终一致性(一段时间后一致)
BASE是CAP中AP的延伸,是大多数互联网系统的选择
强一致性:写入立即可见(CP系统)
最终一致性:写入后延迟可见(AP系统,延迟通常ms级)
因果一致性:有因果关系的事件顺序一致
读己之写:自己写入的数据自己立即可读
单调读:不会读到更旧的数据
阶段一(Prepare):
1. Coordinator向所有参与者发送Prepare
2. 参与者执行事务但不提交,写Undo/Redo日志
3. 参与者返回Yes/No
阶段二(Commit/Rollback):
1. 全部Yes → Coordinator发送Commit
2. 任一No → Coordinator发送Rollback
3. 参与者执行Commit/Rollback
问题:
- 同步阻塞:Prepare后参与者锁定资源
- 单点故障:Coordinator挂了,参与者永远阻塞
- 数据不一致:网络分区导致部分Commit部分Rollback
比2PC多了CanCommit阶段:
1. CanCommit:询问是否可以提交(不锁定资源)
2. PreCommit:执行事务(锁定资源)
3. DoCommit:提交或回滚
改进:
- 增加超时机制:参与者超时自动提交(减少阻塞)
- CanCommit预检:减少不必要的资源锁定
仍不能完全解决数据不一致问题,实际很少使用
Try:资源预留(冻结库存、冻结金额)
Confirm:确认执行(扣减冻结库存、扣减冻结金额)
Cancel:取消执行(释放冻结资源)
特性:
- 业务侵入性强(需编写三个方法)
- 性能好(无全局锁)
- 适合资金类强一致场景
三大问题:
1. 空回滚:Try未执行但收到Cancel → 检查Try是否执行
2. 幂等:网络重试 → 所有操作幂等
3. 悬挂:Cancel先于Try到达 → 检查是否已Cancel
@Service
public class OrderTccService {
@Autowired AccountMapper accountMapper;
@Autowired InventoryMapper inventoryMapper;
// Try:冻结资源
public void tryCreateOrder(OrderContext ctx) {
// 冻结金额
accountMapper.freeze(ctx.getUserId(), ctx.getAmount());
// 冻结库存
inventoryMapper.freeze(ctx.getProductId(), ctx.getQuantity());
}
// Confirm:确认扣减
public void confirmCreateOrder(OrderContext ctx) {
accountMapper.deductFrozen(ctx.getUserId(), ctx.getAmount());
inventoryMapper.deductFrozen(ctx.getProductId(), ctx.getQuantity());
orderMapper.insert(ctx.getOrder());
}
// Cancel:释放冻结
public void cancelCreateOrder(OrderContext ctx) {
accountMapper.unfreeze(ctx.getUserId(), ctx.getAmount());
inventoryMapper.unfreeze(ctx.getProductId(), ctx.getQuantity());
}
}
| 模式 | 侵入性 | 性能 | 一致性 | 适用 |
|---|---|---|---|---|
| AT | 无(自动) | 高 | 最终一致 | 通用业务 |
| TCC | 强(三方法) | 最高 | 最终一致 | 资金/库存 |
| Saga | 中(正补) | 高 | 最终一致 | 长事务 |
| XA | 无 | 低 | 强一致 | 数据库级别 |
一阶段:
1. 拦截SQL,解析语义
2. 查询修改前数据(Before Image)
3. 执行业务SQL
4. 查询修改后数据(After Image)
5. 生成Undo Log,写入undo_log表
6. 提交本地事务(释放本地锁)
7. 注册分支事务,获取全局锁
二阶段-提交:
异步删除Undo Log(很快)
二阶段-回滚:
根据Undo Log的反向SQL恢复数据
校验After Image(防脏写)
全局锁:防止其他事务修改同一数据
// Spring Cloud + Seata AT
@Mapper
public interface OrderMapper {
@Insert("INSERT INTO orders(...) VALUES(...)")
void insert(Order order);
}
@Service
public class OrderService {
@GlobalTransactional(name = "create-order", rollbackFor = Exception.class)
public void createOrder(OrderDTO dto) {
// 1. 创建订单(本地事务)
orderMapper.insert(new Order(dto));
// 2. 扣减库存(远程调用)
inventoryClient.deduct(dto.getProductId(), dto.getQuantity());
// 3. 扣减账户(远程调用)
accountClient.debit(dto.getUserId(), dto.getAmount());
}
}
# application.yml
seata:
enabled: true
application-id: order-service
tx-service-group: my-group
service:
vgroup-mapping:
my-group: default
registry:
type: nacos
nacos:
server-addr: localhost:8848
@LocalTCC
public interface OrderTccAction {
@TwoPhaseBusinessAction(name = "orderCreate", commitMethod = "confirm", rollbackMethod = "cancel")
boolean tryCreate(BusinessActionContext ctx,
@BusinessActionContextParameter(paramName = "orderId") Long orderId,
@BusinessActionContextParameter(paramName = "amount") BigDecimal amount);
boolean confirm(BusinessActionContext ctx);
boolean cancel(BusinessActionContext ctx);
}
Saga = 一系列本地事务 + 补偿事务
正向流程:
T1(创建订单) → T2(扣减库存) → T3(扣减账户) → T4(发送通知)
补偿流程(T3失败):
T3失败 → C2(恢复库存) → C1(取消订单)
实现方式:
1. 命令式:Seata Saga状态机
2. 事件式:Choreography(基于事件驱动)
适合:
- 长事务(跨多个服务,总耗时>10秒)
- 可以接受最终一致性
- 第三方服务不可控
// 1. 业务操作+消息记录在同一个事务
@Transactional
public void createOrder(OrderDTO dto) {
orderMapper.insert(new Order(dto));
// 写入本地消息表
OutboxMessage msg = new OutboxMessage();
msg.setTopic("order-created");
msg.setKey(dto.getOrderId());
msg.setBody(toJson(dto));
msg.setStatus("PENDING");
outboxMapper.insert(msg);
}
// 2. 定时任务扫描发送
@Scheduled(fixedRate = 5000)
public void sendPendingMessages() {
List<OutboxMessage> msgs = outboxMapper.findByStatus("PENDING");
for (OutboxMessage msg : msgs) {
try {
kafkaTemplate.send(msg.getTopic(), msg.getKey(), msg.getBody()).get();
outboxMapper.updateStatus(msg.getId(), "SENT");
} catch (Exception e) {
// 下次重试
}
}
}
// 半消息机制
@RocketMQTransactionListener
class OrderTransactionListener implements RocketMQLocalTransactionListener {
@Autowired OrderService orderService;
@Override
public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
try {
orderService.createOrder(parseOrder(msg));
return COMMIT;
} catch (Exception e) {
return ROLLBACK;
}
}
@Override
public RocketMQLocalTransactionState checkLocalTransaction(MessageExt msg) {
String orderId = parseOrderId(msg);
return orderService.exists(orderId) ? COMMIT : ROLLBACK;
}
}
适用:支付回调等场景
特点:不保证一定通知成功,但会尽力多次通知
流程:
1. 支付完成 → 通知商户(最多N次,间隔递增)
2. 商户返回成功 → 结束
3. 商户未返回 → 重试(1s, 5s, 30s, 5m, 30m, 1h, 2h...)
4. 超过最大次数 → 需要商户主动查询
vs 可靠消息:
最大努力通知:发起方尽力通知,接收方可能收不到
可靠消息:保证消息一定送达,但处理可能延迟
@Autowired RedissonClient redisson;
public <T> T withLock(String lockKey, long waitTime, TimeUnit unit, Supplier<T> supplier) {
RLock lock = redisson.getLock(lockKey);
boolean acquired = false;
try {
acquired = lock.tryLock(waitTime, 30, TimeUnit.SECONDS);
if (!acquired) throw new BizException("操作繁忙,请稍后");
return supplier.get();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new BizException("操作中断");
} finally {
if (acquired && lock.isHeldByCurrentThread()) lock.unlock();
}
}
// 原理:
// 1. 加锁:Lua脚本 SETNX + PEXPIRE(原子)
// 2. 看门狗:后台线程每10秒续期(默认30秒锁)
// 3. 可重入:Hash结构,field=线程ID,value=重入次数
// 4. 释放:Lua脚本校验线程ID后删除
原理:临时顺序节点
流程:
1. 创建临时顺序节点 /lock/lock-0000000001
2. 获取所有子节点并排序
3. 如果自己是序号最小的 → 获得锁
4. 否则监听前一个节点的删除事件
5. 前一个节点删除 → 重新检查是否最小
6. 释放锁:删除自己的节点
7. 客户端断开 → 临时节点自动删除(防死锁)
vs Redis锁:
- ZK:强一致(CP),性能较低,无续期问题
- Redis:高性能(AP),需要看门狗续期,可能丢失
Redis作者Antirez提出:
1. 向N个独立Redis实例请求锁
2. 大多数(N/2+1)加锁成功 → 获得锁
3. 释放时向所有实例发释放
Martin Kleppmann批评:
- 时钟漂移可能导致锁失效
- GC暂停可能导致锁过期
- 建议使用ZK或fencing token
实际建议:大多数场景用Redisson单实例锁即可,极端场景用ZK
public class SnowflakeId {
private final long epoch = 1704067200000L; // 2024-01-01
private final long workerIdBits = 5L;
private final long sequenceBits = 12L;
private long workerId;
private long sequence = 0;
private long lastTimestamp = -1L;
public synchronized long nextId() {
long ts = System.currentTimeMillis();
if (ts < lastTimestamp) throw new RuntimeException("时钟回拨");
if (ts == lastTimestamp) {
sequence = (sequence + 1) & ~(-1L << sequenceBits);
if (sequence == 0) ts = waitNextMillis();
} else {
sequence = 0;
}
lastTimestamp = ts;
return ((ts - epoch) << (workerIdBits + sequenceBits))
| (workerId << sequenceBits) | sequence;
}
}
// 结构:1位符号 + 41位时间戳 + 5位机器 + 5位机房 + 12位序列号
// 每毫秒可生成4096个ID
原理:数据库预分配号段,本地消费
表设计:
CREATE TABLE leaf_alloc (
biz_tag VARCHAR(64) PRIMARY KEY,
max_id BIGINT, -- 当前最大ID
step INT, -- 号段长度
version INT -- 乐观锁
);
流程:
1. 应用启动时获取一个号段(如1-1000)
2. 本地原子递增生成ID
3. 号段用完再获取下一个(1001-2000)
优势:数据库压力小(一次获取一批)
双Buffer:当前号段用到20%时异步加载下一号段
AT模式:
+ 无侵入,只需加@GlobalTransactional
+ 开发简单
- 全局锁可能影响并发
- 需要undo_log表
TCC模式:
+ 性能最好(无全局锁)
+ 控制粒度细
- 开发复杂(Try/Confirm/Cancel三个方法)
- 需要处理空回滚/幂等/悬挂
选型:
- 90%场景用AT(简单通用)
- 资金/库存等高并发场景用TCC
- 长事务用Saga
- 强一致要求用XA
支付流程:创建支付单 → 调用三方支付 → 更新支付状态 → 通知订单
方案:
1. 本地消息表+定时补偿:记录支付状态变更
2. 主动查询:定时查三方支付状态
3. 对账:T+1对账保证最终一致
关键:
- 支付回调必须幂等
- 状态机管理支付单状态
- 超时自动关单(延迟消息)
- 对账补偿兜底
监控指标:
1. 事务成功率:< 99.9%需告警
2. 事务耗时:P99 > 3秒需优化
3. 回滚率:> 1%需排查
4. 补偿率:> 0.1%需关注
5. 全局锁等待时间
工具:
- Seata Server Dashboard
- 自定义Metrics:事务创建/提交/回滚计数
- 链路追踪:OpenTelemetry
// 方案一:Redis预扣 + DB兜底
public boolean deductStock(Long productId, int quantity) {
// 1. Redis Lua原子扣减
Long result = redisTemplate.execute(deductScript,
List.of("stock:" + productId), String.valueOf(quantity));
if (result == null || result == 0) return false;
// 2. 异步扣减DB(MQ)
try {
stockProducer.sendDeductMessage(productId, quantity);
} catch (Exception e) {
// 回滚Redis
redisTemplate.opsForValue().increment("stock:" + productId, quantity);
return false;
}
return true;
}
// 方案二:乐观锁(DB直接扣减)
@Update("UPDATE stock SET quantity = quantity - #{qty} WHERE product_id = #{pid} AND quantity >= #{qty}")
int deductStock(@Param("pid") Long productId, @Param("qty") int quantity);
面试标准回答:
"我们主要用Seata AT模式处理分布式事务。选AT是因为开发侵入小,
只需加@GlobalTransactional注解。
在库存扣减这种高并发场景,我们用TCC模式,因为AT的全局锁会
影响并发性能。Try阶段冻结库存,Confirm阶段确认扣减。
对于支付回调这种异步场景,我们用本地消息表+最大努力通知。
整体策略是根据场景选方案,不是一刀切。监控方面,我们接入了
Seata Dashboard,事务成功率保持在99.95%以上。"
CAP选型:大多数互联网选AP+最终一致,资金选CP
>
Seata四模式:AT无侵入通用、TCC高性能资金、Saga长事务、XA强一致
>
分布式锁:Redis高性能(业务锁)、ZK强一致(协调锁)
>
分布式ID:雪花算法(主流)、Leaf号段(批量)、UUID(不推荐索引)