20K Java+AI 岗位高频考点 — Flink是实时计算领域的绝对主力,大厂必问。覆盖架构原理、状态管理、窗口机制、Checkpoint、Watermark、CEP、SQL Gateway、CDC实时同步等核心场景。
JobManager:负责调度、资源协调、Checkpoint协调、故障恢复。包含Dispatcher、ResourceManager、JobMaster三个组件。
TaskManager:执行具体的Task,管理内存缓冲区,与JobManager心跳保活。
Slot:TaskManager的资源单元,每个Slot可以运行多个Task(Slot Sharing Group)。
Client → JobManager(Dispatcher + ResourceManager + JobMaster)
↓
TaskManager(Slot-0, Slot-1, ...) ←→ TaskManager(Slot-0, Slot-1, ...)
1. Client将代码转为StreamGraph(流图)
2. 优化后生成JobGraph(算子链合并)
3. 提交到JobManager
4. JobManager将JobGraph转为ExecutionGraph
5. ResourceManager申请Slot
6. TaskManager启动执行Task
关键优化:算子链(Operator Chain)将相邻的并行度相同的算子合并到同一个Task中运行,减少序列化和网络传输。
设置方式(优先级从高到低):
1. 算子级别 env.setParallelism()
2. Execute Environment级别
3. 客户端提交级别 -p 参数
4. 配置文件 flink-conf.yaml 的 parallelism.default
生产建议:与Kafka分区数保持一致,或与TaskManager的Slot总数匹配。
关系:Parallelism ≤ 总Slot数。Slot Sharing允许不同算子的SubTask共享同一个Slot,提高资源利用率。
Keyed State:与Key绑定的状态,只能在KeyedStream上使用。包括ValueState、ListState、MapState、ReducingState、AggregatingState。
Operator State:与算子实例绑定的状态。包括ListState、UnionListState、BroadcastState。
// Keyed State使用示例
ValueState<Long> countState = getRuntimeContext().getState(
new ValueDescriptor<>("count", Long.class)
);
基于Chandy-Lamport算法的分布式快照:
1. JobManager定期向所有Source注入Checkpoint Barrier
2. Barrier随数据流流动到每个算子
3. 算子收到Barrier后保存当前状态快照
4. Barrier对齐(Aligned)后向下游传递
5. 所有算子完成后,JobManager确认Checkpoint完成
核心参数:
execution.checkpointing.interval:间隔时间execution.checkpointing.mode:EXACTLY_ONCE vs AT_LEAST_ONCEstate.backend:HashMapStateBackend / EmbeddedRocksDBStateBackend特点:
场景:大状态作业、窗口聚合、去重、CEP复杂事件处理。
注意:RocksDB有序列化/反序列化开销,吞吐量低于HashMapStateBackend。
Aligned Checkpoint(默认):
Unaligned Checkpoint(1.11+):
| 特性 | Checkpoint | Savepoint |
|---|---|---|
| 触发方式 | 自动定时 | 手动触发 |
| 用途 | 故障恢复 | 版本升级/迁移/集群变更 |
| 格式 | 可增量 | 全量(标准化格式) |
| 生命周期 | 随作业删除 | 永久保留 |
| 兼容性 | 版本敏感 | 跨版本兼容 |
需要端到端配合:
1. Source:可重放的Source(Kafka指定offset)
2. Flink内部:Checkpoint + Barrier对齐
3. Sink:两阶段提交(Two-Phase Commit)
Kafka Sink的Two-Phase Commit流程:
1. 开始Checkpoint → 开启新的Kafka事务
2. 写数据到Kafka事务(未提交)
3. Checkpoint完成 → 提交Kafka事务
4. Checkpoint失败 → 回滚Kafka事务
StateTtlConfig ttlConfig = StateTtlConfig
.newBuilder(Time.days(7))
.setUpdateType(StateTtlConfig.UpdateType.OnCreateAndWrite)
.setStateVisibility(StateTtlConfig.StateVisibility.NeverReturnExpired)
.cleanupInRocksdbCompactFilter(1000) // RocksDB压缩时清理
.build();
ValueStateDescriptor<String> stateDesc = new ValueDescriptor<>("state", String.class);
stateDesc.enableTimeToLive(ttlConfig);
注意:TTL清理是惰性的,过期状态不立即删除,而是在读取或Compact时清理。
// 滚动窗口 - 每分钟统计
.keyBy(event -> event.getUserId())
.window(TumblingEventTimeWindows.of(Time.minutes(1)))
// 滑动窗口 - 每10秒统计过去1分钟
.window(SlidingEventTimeWindows.of(Time.minutes(1), Time.seconds(10)))
// 会话窗口 - 30秒无活动则关闭
.window(EventTimeSessionWindows.withGap(Time.seconds(30)))
内置Trigger:
自定义Trigger需实现:
onElement():每来一个元素调用onProcessingTime():注册的处理时间定时器触发onEventTime():注册的事件时间定时器触发clear():窗口清除时调用Watermark超过窗口结束时间后,窗口默认被清除。设置Allowed Lateness可以让窗口在Watermark超过后的延迟期间仍然接受迟到数据。
.window(TumblingEventTimeWindows.of(Time.minutes(1)))
.allowedLateness(Time.minutes(5)) // 允许5分钟延迟
.sideOutputLateData(lateOutputTag) // 超出延迟的数据放入侧输出
增量聚合(ReduceFunction / AggregateFunction):每来一条数据立即聚合,内存开销小。
.aggregate(new AggregateFunction<Event, Long, Long>() {
public Long createAccumulator() { return 0L; }
public Long add(Event e, Long acc) { return acc + 1; }
public Long getResult(Long acc) { return acc; }
public Long merge(Long a, Long b) { return a + b; }
})
全量聚合(ProcessWindowFunction):窗口触发时获取所有元素,可访问窗口元信息。内存开销大但灵活。
最佳实践:两者结合 — AggregateFunction做预聚合 + ProcessWindowFunction做最终处理。
Watermark是事件时间的进度指示器,表示"在此之前的数据应该都已经到达"。
核心规则:
有序流:WatermarkStrategy.forMonotonousTimestamps()
乱序流:WatermarkStrategy.forBoundedOutOfOrderness(Duration.ofSeconds(5))
自定义:实现 WatermarkGenerator
WatermarkStrategy<Event> strategy = WatermarkStrategy
.<Event>forBoundedOutOfOrderness(Duration.ofSeconds(5))
.withTimestampAssigner((event, timestamp) -> event.getEventTime())
.withIdleness(Duration.ofMinutes(1)); // 空闲Source标记
Flink取所有分区Watermark的最小值作为当前Watermark。
问题:某个分区空闲(无数据)会拉低整体Watermark。
解决方案:
.withIdleness(Duration) 标记空闲分区| 时间语义 | 定义 | 优势 | 劣势 |
|---|---|---|---|
| Event Time | 事件发生的时间 | 结果确定,可重放 | 需要Watermark,处理迟到数据 |
| Processing Time | 处理数据的机器时间 | 简单,低延迟 | 结果不确定,不可重放 |
| Ingestion Time | 数据进入Flink的时间 | 不需要Watermark | 介于两者之间 |
生产环境推荐:Event Time,保证结果可重现。
CEP(Complex Event Processing)用于在事件流中检测复杂的事件模式。
核心概念:
Pattern<Event, ?> pattern = Pattern.<Event>begin("start")
.where(e -> e.getType().equals("login"))
.followedBy("middle")
.where(e -> e.getType().equals("purchase"))
.within(Time.minutes(10));
CEP.pattern(eventStream, pattern)
.select(map -> {
Event start = map.get("start");
Event middle = map.get("middle");
return new Alert(start.getUserId(), "quick purchase");
});
next):严格连续,中间不能有其他事件followedBy):宽松连续,中间可以有其他事件followedByAny):非确定宽松,匹配所有可能组合
-- 实时PV统计
SELECT
window_start,
window_end,
COUNT(*) as pv,
COUNT(DISTINCT user_id) as uv
FROM TABLE(
TUMBLE(TABLE orders, DESCRIPTOR(order_time), INTERVAL '1' MINUTE)
)
GROUP BY window_start, window_end;
Temporal Join用于将流数据与维表(可变化的表)关联,获取关联时刻的最新版本。
-- 订单流关联最新的产品维度
SELECT o.order_id, o.amount, p.product_name, p.category
FROM orders AS o
LEFT JOIN product_dim FOR SYSTEM_TIME AS OF o.order_time AS p
ON o.product_id = p.product_id;
维表支持:JDBC、HBase、Redis(通过Lookup Source)。
流式SQL中,由于数据持续到来,之前的计算结果可能需要撤回(Retract)。
例如 SELECT COUNT(*) FROM stream:
+1(新增)-5(撤回旧值)+ +6(发送新值)注意:下游Sink必须支持Retract(如MySQL的INSERT/DELETE、Kafka不支持Retract)。
Flink 1.13+ 引入的窗口函数,替代旧版Group Window语法:
-- TUMBLE
SELECT * FROM TABLE(TUMBLE(TABLE orders, DESCRIPTOR(order_time), INTERVAL '1' HOUR));
-- HOP(滑动)
SELECT * FROM TABLE(HOP(TABLE orders, DESCRIPTOR(order_time), INTERVAL '5' MINUTES, INTERVAL '1' HOUR));
-- CUMULATE(累积)
SELECT * FROM TABLE(CUMULATE(TABLE orders, DESCRIPTOR(order_time), INTERVAL '1' HOUR, INTERVAL '1' DAY));
-- GROUP WINDOW + 聚合
SELECT window_start, window_end, SUM(amount)
FROM TABLE(TUMBLE(TABLE orders, DESCRIPTOR(order_time), INTERVAL '1' HOUR))
GROUP BY window_start, window_end;
Flink SQL Gateway是一个REST服务,允许远程提交SQL作业。
功能:
部署:./bin/sql-gateway.sh start -D sql-gateway.endpoint.rest.address=0.0.0.0
Flink CDC(Change Data Capture)基于Debezium捕获数据库的Binlog变更。
架构:
1. Debezium Source读取MySQL Binlog
2. 解析为统一的CDC事件(INSERT/UPDATE/DELETE)
3. 通过Flink进行处理和同步到下游
// Flink CDC 2.x 使用方式
MySqlSource<String> source = MySqlSource.<String>builder()
.hostname("localhost").port(3306)
.databaseList("mydb").tableList("mydb.orders")
.username("root").password("xxx")
.deserializer(new JsonDebeziumDeserializationSchema())
.startupOptions(StartupOptions.initial()) // 全量+增量
.build();
env.fromSource(source, WatermarkStrategy.noWatermarks(), "MySQL CDC")
.print();
CDC 2.x的Snapshot阶段:
1. 记录当前Binlog位点
2. 按Chunk分片读取全量数据(无锁,使用MVCC一致性读)
3. 全量读取完成后,从记录的Binlog位点开始增量消费
4. 全量期间的数据变更通过Binlog补齐
无锁关键:利用MySQL的REPEATABLE READ隔离级别 + 一致性快照读,避免了全局锁。
CDC 2.3+支持Schema变更自动同步:
配置:includeSchemaChanges(true)
下游同步时需要对应处理Schema变更,一般配合Schema Registry或自定义路由。
Flink使用信用机制(Credit-based)实现反压:
1. 下游Task通知上游自己还有多少Buffer可用(Credit)
2. 上游只发送Credit数量的数据
3. Buffer耗尽时自动反压上游
监控指标:outPoolUsage、inPoolUsage、backPressureTimeMsPerSecond
反压原因:
现象:某些SubTask处理的数据量远大于其他SubTask。
解决方案:
1. 两阶段聚合:先加随机前缀打散 → 聚合 → 去掉前缀 → 再聚合
2. Local-Global聚合:Flink SQL自动优化(table.optimizer.agg-phase-strategy=TWO_PHASE)
3. Rescale/Rebalance:调整分区策略
4. 自定义Partitioner:根据业务规则均匀分配
// 两阶段聚合示例
.keyBy(e -> e.getKey() + "_" + random.nextInt(10)) // 打散
.sum("count")
.keyBy(e -> e.getOriginalKey()) // 还原
.sum("count");
1. RocksDB + 增量Checkpoint:减少Checkpoint时间和存储
2. 状态TTL:自动清理过期状态
3. 状态清理:clear() 及时清理不再需要的状态
4. Local Recovery:TaskManager本地保存Checkpoint副本,加速恢复
5. 状态压缩:开启Snappy压缩
6. 合理分区:避免单个Key的状态过大
常见原因:
execution.checkpointing.timeout)排查步骤:
1. 查看Checkpoint History的失败原因
2. 检查Aligned Duration和Sync Duration
3. 检查State Size是否异常增长
4. 排查外部存储IO性能
5. 考虑切Unaligned Checkpoint或增大超时时间
使用Kafka Producer的Transactional两阶段提交:
KafkaSink<String> sink = KafkaSink.<String>builder()
.setBootstrapServers("broker:9092")
.setRecordSerializer(new KafkaRecordSerializationSchema<String>() {
@Override
public ProducerRecord<byte[], byte[]> serialize(String element, KafkaSinkContext context, Long timestamp) {
return new ProducerRecord<>("topic", element.getBytes());
}
})
.setDeliveryGuarantee(DeliveryGuarantee.EXACTLY_ONCE)
.setTransactionalIdPrefix("flink-txn-")
.build();
注意:Kafka的transaction.max.timeout.ms(默认15分钟)要大于Checkpoint间隔。
方案一:两阶段提交(支持事务的数据库)
class MySQLTwoPhaseCommitSink extends TwoPhaseCommitSinkFunction<String, Connection, Void> {
protected Connection beginTransaction() { /* 获取连接,关闭自动提交 */ }
protected void invoke(Connection txn, String value) { /* 写入数据 */ }
protected void preCommit(Connection txn) { /* 预提交 */ }
protected void commit(Connection txn) { txn.commit(); }
protected void abort(Connection txn) { txn.rollback(); }
}
方案二:幂等写入(基于主键或唯一索引的INSERT ON DUPLICATE KEY UPDATE)
File Sink(BucketingSink/StreamingFileSink):
JDBC Sink:
batchSize:批量写入大小flushInterval:刷写间隔maxRetries:最大重试次数方案:
1. 使用Bloom Filter + HyperLogLog近似去重
2. 或者用RocksDB的MapState存储用户ID精确去重
3. 窗口聚合后写入Redis
// HyperLogLog近似UV
DataStream<Event> stream = ...;
stream.keyBy(e -> e.getPageId())
.window(TumblingEventTimeWindows.of(Time.minutes(5)))
.aggregate(new HyperLogLogAgg())
.addSink(new RedisSink());
用户行为日志(Kafka) → Flink(CBF) → 特征计算 → 特征库(Redis/HBase)
↓
推荐请求 → 特征拼接 → 模型推理 → 推荐结果 → 推荐服务
Flink负责:
1. 实时特征计算(用户近期行为聚合、商品热度统计)
2. 实时AB分流
3. 推荐效果实时统计(CTR、CVR)
MySQL(Binlog) → Flink CDC → ODS层(Kafka)
↓ Flink SQL
DWD层(Kafka) — 清洗、标准化
↓ Flink SQL
DWS层(Kafka/ClickHouse) — 聚合
↓ Flink SQL
ADS层(Redis/MySQL) — 应用层
关键设计:
监控方案:
currentOffsets - lastProcessedOffset告警策略:
自动恢复:Checkpoint失败 → 重启策略(固定延迟/失败率)→ 多次失败告警人工介入。
Regular Join:保留两边所有数据到状态中,状态持续增长,需配置TTL。
Interval Join:限定时间范围的Join,状态可自动清理。
Temporal Join:流关联维表,获取最新维度数据。
// Interval Join - 订单流关联支付流(支付在订单后5分钟内)
orderStream.keyBy(o -> o.getOrderId())
.intervalJoin(paymentStream.keyBy(p -> p.getOrderId()))
.between(Time.minutes(-5), Time.minutes(0))
.process(new ProcessJoinFunction<>());
1. Filter前置过滤:第一个算子过滤明显错误数据
2. SideOutput侧输出:异常数据输出到侧输出流,单独处理
3. Try-Catch包裹:Map/FlatMap中捕获异常,发送到侧输出
4. 死信队列:无法处理的数据发送到死信Topic
OutputTag<String> dirtyTag = new OutputTag<String>("dirty") {};
stream.process(new ProcessFunction<Event, Event>() {
@Override
public void processElement(Event e, Context ctx, Collector<Event> out) {
try {
// 业务处理
out.collect(e);
} catch (Exception ex) {
ctx.output(dirtyTag, e.getRawData());
}
}
});
生产建议:大作业用Per-Job/Application模式,避免相互影响。
关键链路:
1. 数据采集:CDC(Debezium/Canal)→ Kafka
2. 实时计算:Flink SQL(ODS→DWD→DWS→ADS)
3. 实时存储:ClickHouse/StarRocks/Doris
4. 数据服务:MySQL/Redis → API查询
质量保障:
TaskManager Total Memory
├── Framework Memory(框架使用,固定)
├── Task Memory(算子使用,含RocksDB)
│ ├── Managed Memory(RocksDB状态 / 排序 / 缓存)
│ └── Task Heap / Off-heap
├── Network Memory(网络缓冲区,Shuffle)
└── JVM Metaspace / JVM Overhead
OOM排查:
taskmanager.memory.task.heap.size 不够taskmanager.memory.managed.size 不够(RocksDB)taskmanager.memory.network.min/max 不够(反压)
用户请求 → API网关 → 风控引擎
↓
Kafka(事件流) → Flink CEP(规则匹配)
↓
规则命中 → 决策(通过/拦截/人审)
↓
风控特征 → 特征库(Redis)
Flink负责:
1. 实时特征计算(最近N分钟操作次数、金额统计)
2. CEP模式匹配(异常行为模式检测)
3. 规则动态更新(Broadcast State)
重启策略:
restart-strategy: fixed-delay, 3 attempts, 10s delayrestart-strategy: failure-rate, 3 failures per 5 min, 10s delay状态恢复:
1. 从最近的Checkpoint恢复
2. 如果Checkpoint损坏,从Savepoint恢复
3. 如果无Savepoint,从最早Kafka Offset重新消费
注意:恢复后并行度不能改变(RocksDB的KeyGroup数量固定)。
Flink三板斧:Checkpoint保状态、Watermark推进时间、窗口聚合计算
>
Exactly-Once三要素:可重放Source + Checkpoint Barrier + 两阶段提交Sink
>
反压排查:看outPoolUsage → 找瓶颈算子 → 查GC/IO/倾斜
>
大状态优化:RocksDB增量 + TTL + Local Recovery