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。
09.10.5-002 Flink Exactly-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 性能调优