← 返回首页 ❓ 面试题库
📑 本篇章节导航 (共9章,点击直达)
一、分布式理论基础二、2PC与3PC三、TCC模式四、Seata框架五、消息事务方案六、分布式锁七、分布式ID八、面试高频综合题面试速记口诀

Q123 分布式事务与数据一致性深度实战

20K Java+AI 岗位高频考点 — 分布式事务是系统设计的核心难题,面试必问CAP理论、Seata四模式、TCC实现。覆盖理论基础、Seata实战、分布式锁、分布式ID、一致性方案。

一、分布式理论基础

1. CAP定理?


C(Consistency):所有节点看到相同数据
A(Availability):每个请求都能得到响应
P(Partition Tolerance):网络分区时系统仍工作

定理:分布式系统最多同时满足两项,网络分区必然存在,所以实际是CP或AP

CP系统:ZooKeeper、Etcd、MongoDB(强一致)
AP系统:Eureka、Cassandra、DynamoDB
→ 大多数互联网系统选择AP+最终一致性

2. BASE理论?


BA(Basically Available):基本可用(允许响应变慢/功能降级)
S(Soft State):软状态(允许中间状态)
E(Eventual Consistency):最终一致性(一段时间后一致)

BASE是CAP中AP的延伸,是大多数互联网系统的选择

3. 一致性模型?


强一致性:写入立即可见(CP系统)
最终一致性:写入后延迟可见(AP系统,延迟通常ms级)
因果一致性:有因果关系的事件顺序一致
读己之写:自己写入的数据自己立即可读
单调读:不会读到更旧的数据

二、2PC与3PC

4. 2PC(两阶段提交)?


阶段一(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

5. 3PC(三阶段提交)?


比2PC多了CanCommit阶段:
1. CanCommit:询问是否可以提交(不锁定资源)
2. PreCommit:执行事务(锁定资源)
3. DoCommit:提交或回滚

改进:
- 增加超时机制:参与者超时自动提交(减少阻塞)
- CanCommit预检:减少不必要的资源锁定

仍不能完全解决数据不一致问题,实际很少使用

三、TCC模式

6. TCC(Try-Confirm-Cancel)原理?


Try:资源预留(冻结库存、冻结金额)
Confirm:确认执行(扣减冻结库存、扣减冻结金额)
Cancel:取消执行(释放冻结资源)

特性:
- 业务侵入性强(需编写三个方法)
- 性能好(无全局锁)
- 适合资金类强一致场景

三大问题:
1. 空回滚:Try未执行但收到Cancel → 检查Try是否执行
2. 幂等:网络重试 → 所有操作幂等
3. 悬挂:Cancel先于Try到达 → 检查是否已Cancel

7. TCC Java实现?


@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());
    }
}

四、Seata框架

8. Seata四种模式对比?

模式侵入性性能一致性适用
AT无(自动)高最终一致通用业务
TCC强(三方法)最高最终一致资金/库存
Saga中(正补)高最终一致长事务
XA无低强一致数据库级别

9. Seata AT模式原理?


一阶段:
1. 拦截SQL,解析语义
2. 查询修改前数据(Before Image)
3. 执行业务SQL
4. 查询修改后数据(After Image)
5. 生成Undo Log,写入undo_log表
6. 提交本地事务(释放本地锁)
7. 注册分支事务,获取全局锁

二阶段-提交:
异步删除Undo Log(很快)

二阶段-回滚:
根据Undo Log的反向SQL恢复数据
校验After Image(防脏写)

全局锁:防止其他事务修改同一数据

10. Seata AT模式实战?


// 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

11. Seata TCC模式?


@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);
}

12. Saga模式?


Saga = 一系列本地事务 + 补偿事务

正向流程:
T1(创建订单) → T2(扣减库存) → T3(扣减账户) → T4(发送通知)

补偿流程(T3失败):
T3失败 → C2(恢复库存) → C1(取消订单)

实现方式:
1. 命令式:Seata Saga状态机
2. 事件式:Choreography(基于事件驱动)

适合:
- 长事务(跨多个服务,总耗时>10秒)
- 可以接受最终一致性
- 第三方服务不可控

五、消息事务方案

13. 本地消息表?


// 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) {
            // 下次重试
        }
    }
}

14. RocketMQ事务消息?


// 半消息机制
@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;
    }
}

15. 最大努力通知?


适用:支付回调等场景
特点:不保证一定通知成功,但会尽力多次通知

流程:
1. 支付完成 → 通知商户(最多N次,间隔递增)
2. 商户返回成功 → 结束
3. 商户未返回 → 重试(1s, 5s, 30s, 5m, 30m, 1h, 2h...)
4. 超过最大次数 → 需要商户主动查询

vs 可靠消息:
最大努力通知:发起方尽力通知,接收方可能收不到
可靠消息:保证消息一定送达,但处理可能延迟

六、分布式锁

16. Redis分布式锁(Redisson)?


@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后删除

17. ZooKeeper分布式锁?


原理:临时顺序节点

流程:
1. 创建临时顺序节点 /lock/lock-0000000001
2. 获取所有子节点并排序
3. 如果自己是序号最小的 → 获得锁
4. 否则监听前一个节点的删除事件
5. 前一个节点删除 → 重新检查是否最小
6. 释放锁:删除自己的节点
7. 客户端断开 → 临时节点自动删除(防死锁)

vs Redis锁:
- ZK:强一致(CP),性能较低,无续期问题
- Redis:高性能(AP),需要看门狗续期,可能丢失

18. RedLock争议?


Redis作者Antirez提出:
1. 向N个独立Redis实例请求锁
2. 大多数(N/2+1)加锁成功 → 获得锁
3. 释放时向所有实例发释放

Martin Kleppmann批评:
- 时钟漂移可能导致锁失效
- GC暂停可能导致锁过期
- 建议使用ZK或fencing token

实际建议:大多数场景用Redisson单实例锁即可,极端场景用ZK

七、分布式ID

19. 雪花算法?


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

20. Leaf号段模式?


原理:数据库预分配号段,本地消费

表设计:
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%时异步加载下一号段

八、面试高频综合题

21. Seata AT vs TCC怎么选?


AT模式:
+ 无侵入,只需加@GlobalTransactional
+ 开发简单
- 全局锁可能影响并发
- 需要undo_log表

TCC模式:
+ 性能最好(无全局锁)
+ 控制粒度细
- 开发复杂(Try/Confirm/Cancel三个方法)
- 需要处理空回滚/幂等/悬挂

选型:
- 90%场景用AT(简单通用)
- 资金/库存等高并发场景用TCC
- 长事务用Saga
- 强一致要求用XA

22. 支付场景的一致性设计?


支付流程:创建支付单 → 调用三方支付 → 更新支付状态 → 通知订单

方案:
1. 本地消息表+定时补偿:记录支付状态变更
2. 主动查询:定时查三方支付状态
3. 对账:T+1对账保证最终一致

关键:
- 支付回调必须幂等
- 状态机管理支付单状态
- 超时自动关单(延迟消息)
- 对账补偿兜底

23. 分布式事务监控?


监控指标:
1. 事务成功率:< 99.9%需告警
2. 事务耗时:P99 > 3秒需优化
3. 回滚率:> 1%需排查
4. 补偿率:> 0.1%需关注
5. 全局锁等待时间

工具:
- Seata Server Dashboard
- 自定义Metrics:事务创建/提交/回滚计数
- 链路追踪:OpenTelemetry

24. 库存扣减一致性?


// 方案一: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);

25. 如何回答"你们的分布式事务方案"?


面试标准回答:
"我们主要用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(不推荐索引)