罗罗编程学习记录
本页内容 展开查看

09.10.5 Exactly-Once 语义与两阶段提交 Sink

所属:全栈开发面试题库 / 09 高阶架构:高并发与分布式 / 09.10 大数据与流处理

覆盖范围

  • 三种语义:At-most-once、At-least-once、Exactly-once
  • Flink Checkpoint 与 Exactly-Once 的关系
  • 两阶段提交 Sink(TwoPhaseCommitSinkFunction)
  • 幂等 Sink 与事务 Sink
  • Kafka/MySQL/Redis 作为 Sink 的 Exactly-Once

高频题速览

编号 题目 难度 频率
09.10.5-001 At-most-once、At-least-once、Exactly-once 区别 进阶 ★★★★★
09.10.5-002 Flink Exactly-Once 怎么实现 高级 ★★★★★
09.10.5-003 两阶段提交 Sink 原理 高级 ★★★★☆
09.10.5-004 TwoPhaseCommitSinkFunction 流程 高级 ★★★★☆
09.10.5-005 幂等 Sink 是什么 进阶 ★★★★☆
09.10.5-006 Kafka Sink 怎么保证 Exactly-Once 高级 ★★★★☆
09.10.5-007 MySQL Sink 怎么保证 Exactly-Once 高级 ★★★☆☆
09.10.5-008 Redis Sink 怎么保证 Exactly-Once 进阶 ★★★☆☆
09.10.5-009 Exactly-Once 的代价 进阶 ★★★★☆
09.10.5-010 End-to-End Exactly-Once 条件 高级 ★★★★☆

09.10.5-001 At-most-once、At-least-once、Exactly-once 有什么区别?

一句话结论

At-most-once 是最多一次(可能丢,不重试);At-least-once 是至少一次(可能重复,重试);Exactly-once 是精确一次(不丢不重);Exactly-once 是理想语义,实际通过 Checkpoint + 两阶段提交或幂等实现。

概念解释

  • At-most-once:不保证不丢,故障时直接放弃,最快。
  • At-least-once:保证不丢,故障重放,可能重复。
  • Exactly-once:不丢不重,通过 Checkpoint + Sink 事务实现。

原理流程

At-most-once:
  故障 → 丢弃,不重试
At-least-once:
  故障 → 从上次 checkpoint 重放,可能重复
Exactly-once:
  故障 → 从 checkpoint 恢复,Sink 两阶段提交,不重复

代码或图示

对比:
  At-most-once:不丢不保证,最快
  At-least-once:不丢,可能重复
  Exactly-once:不丢不重,开销最大

常见误区

  • 误区:Exactly-once 是每条消息只处理一次。由于故障重放,消息可能被处理多次,但通过 Sink 事务保证结果只生效一次。
  • 误区:At-least-once 就是重复。At-least-once 可能重复,Sink 幂等去重后结果等价于 Exactly-once。

追问

  • 问:Flink 默认哪种?答:开启 Checkpoint 后是 Exactly-once,不开启是 At-most-once。
  • 问:Kafka 消费者语义?答:enable.auto.commit 是 At-most-once,手动提交 offset 是 At-least-once。

一句话结论

Flink Exactly-Once 靠分布式 Checkpoint:每个 Checkpoint 是一致性快照,记录所有算子状态(包括 Source offset);故障时从最近 Checkpoint 恢复,Source 重放未消费的数据,算子从快照恢复状态;Sink 通过两阶段提交或幂等保证不重复写入。

概念解释

  • Checkpoint:一致性快照,记录所有算子状态。
  • Source offset:Kafka offset 在 Checkpoint 中记录。
  • Sink 事务:两阶段提交或幂等,保证结果不重复。

原理流程

正常运行:
  Checkpoint n 记录所有算子状态 + Source offset
故障恢复:
  从 Checkpoint n 恢复
  → Source 从 offset n 重放
  → 算子从快照恢复状态
  → Sink 根据 Checkpoint 完成状态提交/回滚

代码或图示

Flink Exactly-Once 条件:
  1. Checkpoint 开启(分布式一致性快照)
  2. Source 可重放(Kafka offset 可重置)
  3. Sink 支持两阶段提交或幂等

常见误区

  • 误区:Flink 自动保证端到端 Exactly-Once。Flink 保证内部状态一致,Sink 需要配合(两阶段提交或幂等)。
  • 误区:Checkpoint 间隔越短越好。间隔短恢复快但开销大,按业务容忍度设。

追问

  • 问:Flink Checkpoint 间隔?答:秒级到分钟级, exactly-once 要求 Checkpoint 成功。
  • 问:Checkpoint 失败会怎样?答:重试,连续失败触发作业失败,作业重启从上次成功 Checkpoint 恢复。

09.10.5-003 两阶段提交 Sink 原理是什么?

一句话结论

两阶段提交 Sink 借鉴分布式事务 2PC:Checkpoint 开始时 Sink 开启事务(beginTransaction),数据写入事务缓冲;Checkpoint 完成时 Sink 提交事务(commit);故障恢复时,如果 Checkpoint 完成则提交,否则中止(abort)未完成的事务。

概念解释

  • 两阶段:pre-commit(Checkpoint 对齐时写事务缓冲)+ commit(Checkpoint 完成时提交)。
  • 事务:Sink 外部系统的事务(Kafka 事务、MySQL 事务)。
  • 恢复:重启时检查未完成事务,commit 或 abort。

原理流程

1. Checkpoint n 开始:Sink 开启事务 T_n
2. 数据写入 T_n 的缓冲(不提交)
3. Checkpoint n 对齐:pre-commit,数据在事务中
4. Checkpoint n 完成:commit T_n
故障恢复:
  检查 T_n 是否 commit
    commit → 跳过
    未 commit → abort T_n,从 Checkpoint n 重放

代码或图示

两阶段提交:
  pre-commit(Checkpoint 对齐)→ 数据在事务中
  commit(Checkpoint 完成)→ 事务提交
  abort(故障恢复)→ 未提交事务回滚

常见误区

  • 误区:两阶段提交是强一致。它是 Flink 内部 Checkpoint 与 Sink 事务的协调,不是跨系统分布式事务。
  • 误区:两阶段提交 Sink 一定 Exactly-Once。Sink 外部系统要支持事务(Kafka 事务、MySQL 本地事务),否则不行。

追问

  • 问:哪些 Sink 支持两阶段提交?答:Kafka(事务)、两阶段提交文件 Sink、Jdbc Sink(本地事务)。
  • 问:Redis 支持两阶段提交吗?答:Redis 不支持跨事务,用幂等 Sink,详见 09.10.5-008。

09.10.5-004 TwoPhaseCommitSinkFunction 流程是什么?

一句话结论

Flink 的 TwoPhaseCommitSinkFunction 是两阶段提交 Sink 的基类:beginTransaction 开启事务,invoke 写数据到事务缓冲,preCommit 在 Checkpoint 对齐时调用,commit 在 Checkpoint 完成时提交,abort 在恢复时中止未提交事务;用户实现这几个方法即可。

概念解释

  • beginTransaction:开启外部事务。
  • invoke:写数据到事务。
  • preCommit:Checkpoint 对齐时调用(通常 flush)。
  • commit:Checkpoint 完成时提交事务。
  • abort:恢复时中止未提交事务。

原理流程

1. 初始化:beginTransaction() → 开启事务 T
2. 处理数据:invoke(T, value) → 写入事务 T
3. Checkpoint 对齐:preCommit(T) → flush
4. Checkpoint 完成:commit(T) → 提交事务 T
故障恢复:
  从状态中取出未完成事务 T
  → 如果 T 已 commit → 跳过
  → 否则 abort(T)

代码或图示

public abstract class TwoPhaseCommitSinkFunction<IN, TXN, CONTEXT> {
    protected abstract TXN beginTransaction();
    protected abstract void invoke(TXN transaction, IN context) throws Exception;
    protected abstract void preCommit(TXN transaction) throws Exception;
    protected abstract void commit(TXN transaction);
    protected abstract void abort(TXN transaction);
}

常见误区

  • 误区:TwoPhaseCommitSinkFunction 是强一致分布式事务。它是 Flink Checkpoint 与 Sink 事务的协调,外部系统事务要支持。
  • 误区:commit 一定成功。commit 可能失败(外部系统故障),需要重试或告警。

追问

  • 问:Kafka Sink 怎么用?答:Flink KafkaProducer 支持两阶段提交,开启事务,Checkpoint 时 commit。
  • 问:恢复时事务怎么处理?答:把事务 ID 存在 Flink 状态中,恢复时检查 commit/abort。

09.10.5-005 幂等 Sink 是什么?

一句话结论

幂等 Sink 是多次写入同一结果不产生副作用:同一笔数据写多次,结果和写一次一样;通过业务主键(order_id)去重,或 Redis SETNX、MySQL INSERT ON DUPLICATE KEY UPDATE 实现;幂等 Sink 配合 At-least-once 重放,结果等价于 Exactly-once。

概念解释

  • 幂等:多次操作结果相同。
  • 去重:业务主键唯一,重复写入覆盖或忽略。
  • 适用:不支持事务的 Sink(Redis、外部 HTTP API)。

原理流程

At-least-once 重放:
  同一条数据写两次
  → Sink 按主键去重,结果只生效一次
  → 等价 Exactly-once

代码或图示

-- MySQL 幂等
INSERT INTO orders (id, amount) VALUES (1, 100)
ON DUPLICATE KEY UPDATE amount = VALUES(amount);
# Redis 幂等
redis.set("order:1", value, nx=True)  # 已存在则不写

常见误区

  • 误区:幂等 Sink 不需要 Exactly-once。幂等 Sink 是 At-least-once + 去重,结果等价 Exactly-once,但不是真正的事务语义。
  • 误区:所有 Sink 都能幂等。非幂等操作(如计数器 INCR)多次执行结果不同,不能用幂等。

追问

  • 问:计数怎么幂等?答:不直接 INCR,而是用业务主键记录已处理,再算增量;或用 Redis SETNX 标记。
  • 问:幂等 key 怎么选?答:业务主键(order_id、event_id),唯一标识一笔数据。

09.10.5-006 Kafka Sink 怎么保证 Exactly-Once?

一句话结论

Flink Kafka Sink 用 Kafka 事务:开启 transaction.id,数据写入事务(未提交),Checkpoint 完成时 commit 事务;Kafka 消费者配置 isolation.level=read_committed,只读到已提交的消息;实现端到端 Exactly-Once。

概念解释

  • Kafka 事务:producer 开启事务,消息写入未提交,commit 后消费者可见。
  • transaction.id:事务唯一标识,Flink Checkpoint ID 关联。
  • read_committed:消费者只读已提交事务的消息。

原理流程

1. Flink 开启 Kafka 事务(transaction.id = checkpoint-n)
2. 数据写入 Kafka(事务未提交)
3. Checkpoint 完成 → commit Kafka 事务
4. 消费者 read_committed → 只读到已提交消息
故障恢复:
  未 commit 的事务 → Kafka 自动 abort
  → 消费者读不到未提交消息

代码或图示

// Flink Kafka Sink 配置
FlinkKafkaProducer.<String>builder(...)
    .setDeliveryGuarantee(DeliveryGuarantee.EXACTLY_ONCE)
    .setTransactionalTimeout(...)
    .build();

常见误区

  • 误区:Kafka Exactly-Once 不需要消费者配置。消费者要配 isolation.level=read_committed,否则会读到未提交消息。
  • 误区:Kafka 事务没有代价。事务有开销,延迟略高,吞吐量略降。

追问

  • 问:transaction.id 怎么生成?答:Flink 自动生成,关联 Checkpoint ID,恢复时恢复事务。
  • 问:Kafka 事务超时?答:transaction.timeout.ms,默认 1 分钟,Checkpoint 间隔要小于超时。

09.10.5-007 MySQL Sink 怎么保证 Exactly-Once?

一句话结论

MySQL Sink 用本地事务 + 幂等:每条消息在 MySQL 本地事务中写入,Checkpoint 完成时提交事务;或用幂等写入(INSERT ON DUPLICATE KEY UPDATE)配合 At-least-once 重放;MySQL 不支持跨 Flink 作业的分布式事务,靠本地事务 + 幂等。

概念解释

  • 本地事务:每个并行 Sink 子任务一个 MySQL 事务。
  • 幂等写入:主键唯一,重复写入覆盖。
  • 不支持跨作业:MySQL 事务是本地的,多个 Sink 子任务的事务不保证同时提交。

原理流程

方式 1(两阶段提交):
  Checkpoint 对齐 → 开启 MySQL 事务
  数据写入事务
  Checkpoint 完成 → commit MySQL 事务
方式 2(幂等):
  At-least-once 重放
  → INSERT ON DUPLICATE KEY UPDATE
  → 重复写入覆盖

代码或图示

-- 幂等 MySQL 写入
INSERT INTO order_metrics (order_id, total_amount, updated_at)
VALUES (123, 500, NOW())
ON DUPLICATE KEY UPDATE
  total_amount = VALUES(total_amount),
  updated_at = VALUES(updated_at);

常见误区

  • 误区:MySQL Sink 是强一致 Exactly-Once。每个并行子任务独立事务,跨子任务不保证同时提交。
  • 误区:MySQL 两阶段提交跨作业。MySQL 不支持 XA 跨 Flink 作业,靠本地事务 + 幂等。

追问

  • 问:多子任务事务不一致怎么办?答:短暂不一致,对账任务修复。
  • 问:JdbcSink 支持两阶段提交吗?答:Flink 1.14+ JdbcSink 支持 EXACTLY_ONCE(本地事务),详见官方文档。

09.10.5-008 Redis Sink 怎么保证 Exactly-Once?

一句话结论

Redis 不支持跨操作事务,不能用两阶段提交;用幂等 Sink:业务主键唯一,重复写入用 SETNX(已存在则不写)或覆盖写;或用 Redis 事务(MULTI/EXEC)保证单条操作原子,但不跨 Checkpoint;Redis Sink 靠幂等,不是两阶段提交。

概念解释

  • Redis 事务:MULTI/EXEC 保证单条命令原子,不跨 Checkpoint。
  • 幂等:SETNX 已存在则不写,或覆盖写。
  • 适用:Redis 适合幂等写入,不适合两阶段提交。

原理流程

At-least-once 重放:
  SETNX order:1 value
  → 第一次写成功
  → 重放时 SETNX 发现已存在,不写
  → 幂等

代码或图示

# Redis 幂等写
redis.set("order:1", value, nx=True)  # 已存在则不写
# 或覆盖写
redis.set("order:1", value)  # 重复写覆盖,结果一致

常见误区

  • 误区:Redis INCR 是幂等的。INCR 多次执行结果不同,不能用 At-least-once + 幂等。
  • 误区:Redis 事务(MULTI/EXEC)是两阶段提交。MULTI/EXEC 是单条命令原子,不跨 Checkpoint。

追问

  • 问:Redis 计数怎么保证 Exactly-Once?答:不直接 INCR,而是用业务主键记录已处理,再算增量;或用 Redis 的 Lua 脚本做幂等。
  • 问:Redis 支持两阶段提交吗?答:Redis 没有原生两阶段提交,需要外部协调(如 Redlock),但不推荐。

09.10.5-009 Exactly-Once 的代价是什么?

一句话结论

Exactly-Once 代价:Checkpoint 开销(周期性快照、Barrier 对齐)、Sink 事务开销(Kafka 事务延迟、MySQL 事务)、吞吐降低(事务和快照阻塞)、延迟增加(Checkpoint 间隔);不是所有场景都需要 Exactly-Once,按业务容忍度选。

概念解释

  • Checkpoint 开销:快照序列化、Barrier 对齐。
  • 事务开销:Kafka 事务延迟、MySQL 事务。
  • 吞吐降低:事务和快照阻塞数据流。

原理流程

Exactly-Once:
  Checkpoint 开销 + 事务开销
  → 吞吐比 At-least-once 低 10%~30%
  → 延迟增加(Checkpoint 间隔)

代码或图示

代价对比:
  At-least-once:吞吐高,可能重复
  Exactly-once:吞吐低 10%~30%,不丢不重

常见误区

  • 误区:Exactly-Once 一定值得。非关键数据(日志、埋点)用 At-least-once + 幂等足够,不需要 Exactly-Once。
  • 误区:Exactly-Once 延迟不可接受。Checkpoint 间隔设 1~5 分钟,延迟在可接受范围。

追问

  • 问:什么场景必须 Exactly-Once?答:资金、订单计数、库存扣减,重复会导致错误。
  • 问:什么场景用 At-least-once?答:日志、埋点、监控指标,重复可接受或可幂等。

09.10.5-010 End-to-End Exactly-Once 的条件是什么?

一句话结论

端到端 Exactly-Once 三个条件:1. Source 可重放(Kafka offset 可重置);2. Flink Checkpoint 一致性快照(内部状态不丢不重);3. Sink 支持两阶段提交或幂等;三者缺一不可,Flink 内部 Exactly-Once 不等于端到端。

概念解释

  • Source 可重放:Kafka 等消息队列,offset 可重置。
  • Checkpoint:Flink 内部一致性快照。
  • Sink 事务/幂等:Sink 写入不重复。

原理流程

End-to-End Exactly-Once:
  Source (Kafka) → Flink (Checkpoint) → Sink (事务/幂等)
  故障时:
    Source 从 Checkpoint offset 重放
    Flink 从 Checkpoint 恢复状态
    Sink 从 Checkpoint commit/abort 事务

代码或图示

三个条件:
  1. Source:Kafka(offset 可重置)
  2. Flink:Checkpoint 开启
  3. Sink:Kafka 事务 / MySQL 本地事务 / Redis 幂等

常见误区

  • 误区:Flink 开启 Checkpoint 就是端到端 Exactly-Once。Flink 内部一致,但 Sink 不支持事务/幂等就重复。
  • 误区:File Sink 是 Exactly-Once。File Sink 需要 TwoPhaseCommitSinkFunction,否则故障恢复时文件重复。

追问

  • 问:HTTP API Sink 怎么保证?答:HTTP API 不支持事务,用幂等 API(业务主键去重),At-least-once + 幂等。
  • 问:怎么验证端到端 Exactly-Once?答:故障注入,重启作业,检查 Sink 结果是否重复。

待整理清单

  • [ ] Kafka Exactly-Once 配置示例
  • [ ] TwoPhaseCommitSinkFunction 自定义实现
  • [ ] Flink Exactly-Once 性能调优