Apache Flink 核心概念术语全解:从集群架构、数据流模型到状态与容错机制

原创2026-09-23 17:50:041,946 阅读
文章标签:后端大数据流处理批处理

Apache Flink 核心概念术语全解:从集群架构、数据流模型到状态与容错机制

导读

Flink 的官方文档、源码注释与社区讨论中充斥着大量术语——Flink Application、JobGraph、ExecutionGraph、Operator Chain、State Backend、UID hash……这些概念彼此关联,构成了理解 Flink 运行机制的地基。本文以 docs/content/docs/concepts/glossary.md 中的官方术语表为主体骨架,逐条解析全部核心术语,并结合本仓库的 flink-runtime、flink-streaming-java 等模块源码加以印证与扩充。读完本文,你将能够准确区分"集群与进程""作业与图""任务与子任务""状态与检查点"这几组最容易混淆的概念,并在阅读 Flink 源码、排查运行日志或设计作业时自如使用这些术语。


一、总体脉络:Flink 的四层抽象模型

glossary 中的 30 个术语并非彼此孤立,它们天然地落在四层抽象上:

层次 关键术语
进程与集群层 Flink Cluster、Flink JobManager、Flink JobMaster、Flink TaskManager、Flink Application Cluster、Flink Job Cluster、Flink Session Cluster
作业与图层 Flink Application、Flink Job、Logical Graph、JobGraph、Physical Graph、ExecutionGraph
执行单元与数据层 Operator、Function、Instance、Task、Sub-Task、Operator Chain、Record、Event、Partition、Transformation
状态与容错层 Managed State、State Backend、Checkpoint Storage、JobResultStore、UID、UID hash、Table Program、Execution Mode

从用户编写的代码到真正运行在分布式环境中的任务,数据要依次经历"应用 → 作业 → 逻辑图 → 物理图 → 任务"的层层转换;而状态、检查点与标识符则贯穿始终,保证作业的可靠性与可恢复性。下面逐层展开。


二、集群与进程:谁在分布式系统里干活

Flink Cluster(Flink 集群)

A distributed system consisting of (typically) one JobManager and one or more Flink TaskManager processes.

一个 Flink Cluster 是一个分布式系统,典型地由一个 JobManager 进程和一个或多个 TaskManager 进程组成。它是 Flink 运行时的物理载体:JobManager 负责协调与调度,TaskManager 负责真正执行任务。

在源码层面,这两个进程的启动入口分别位于 flink-runtime/src/main/java/org/apache/flink/runtime/jobmaster/JobMaster.java 与 flink-runtime/src/main/java/org/apache/flink/runtime/taskexecutor/TaskManagerRunner.java。注意 glossary 用"typically"一词:在某些测试或嵌入式场景下,JobManager 与 TaskManager 可以共存在同一个 JVM 中,但这不改变它们作为独立角色的定位。

Flink JobManager(作业管理器)

The JobManager is the orchestrator of a Flink Cluster. It contains three distinct components: Flink Resource Manager, Flink Dispatcher and one Flink JobMaster per running Flink Job.

JobManager 是整个集群的协调者(orchestrator),它内部实际包含三个职责不同的组件:

  1. Flink Resource Manager(资源管理器):负责集群资源的分配与回收,对应源码中的 flink-runtime/src/main/java/org/apache/flink/runtime/resourcemanager/ResourceManager.java。它与部署平台(如 YARN、Kubernetes、Standalone)对接,管理 TaskManager 的注册、槽位(slot)的分配与释放。
  2. Flink Dispatcher(分发器):负责接收作业提交请求,为每个作业拉起对应的 JobMaster,并对外提供 REST 接口。对应源码为 flink-runtime/src/main/java/org/apache/flink/runtime/dispatcher/Dispatcher.java。
  3. 每个运行中作业一个 Flink JobMaster:见下文。

理解这三者的关系对排查问题很关键:你在 Web UI 上看到的"JobManager",其实是这三类组件的综合体;而日志中标注的 JobManager 日志可能同时包含 Dispatcher、ResourceManager 与多个 JobMaster 的输出。

Flink JobMaster(作业主管)

JobMasters are one of the components running in the JobManager. A JobMaster is responsible for supervising the execution of the Tasks of a single job.

JobMaster 是 JobManager 内部每个作业对应一个的组件,负责监督(supervising)单个作业的所有 Task 的执行。它持有该作业的调度、检查点协调、结果分区跟踪等运行时状态,是整个作业运行期的"大脑"。对应实现即 JobMaster.java,从源码 import 列表可以看到它涉及的职责范围极广:slot 池(SlotPoolService)、心跳(HeartbeatManager)、结果分区跟踪(JobMasterPartitionTracker)、检查点(CheckpointCoordinator)等。

一句话区分:JobManager 是集群级进程,JobMaster 是作业级组件;JobManager 进程为每个运行中的作业维护一个 JobMaster。

Flink TaskManager(任务管理器)

TaskManagers are the worker processes of a Flink Cluster. Tasks are scheduled to TaskManagers for execution. They communicate with each other to exchange data between subsequent Tasks.

TaskManager 是 Flink 集群的工作进程(worker)。Task 被调度到 TaskManager 上执行;不同的 TaskManager 之间会互相通信,以在前后相邻的 Task 之间交换数据(这正是 Operator Chain 之外、需要走网络栈传输的场景)。

在源码中,TaskManager 进程的核心类为 TaskManagerRunner.java,而具体承载任务执行的组件在 TaskManagerServices(flink-runtime/src/main/java/org/apache/flink/runtime/taskexecutor/TaskManagerServices.java)中组装。TaskManager 的内存划分(堆内/堆外、托管内存等)直接影响状态后端与网络缓冲的可用空间,因此 TaskManager 的资源配置往往是调优的第一步。


三、三种集群部署形态:Application / Job / Session Cluster

glossary 用"集群生命周期是否绑定作业"这一维度区分了三种部署形态,这是理解 Flink 部署模式的钥匙。

Flink Application 与 Flink Application Cluster(应用集群)

先看 Flink Application 的定义:

A Flink application is a Java Application that submits one or multiple Flink Jobs from the main() method (or by some other means). Submitting jobs is usually done by calling execute() on an execution environment.

Flink Application 是一个 Java 应用,它从 main() 方法(或通过其他方式)提交一个或多个 Flink Job,提交动作通常通过调用执行环境的 execute() 完成。一个应用既可以把作业提交给长期运行的 Session Cluster,也可以提交给专用的 Application Cluster 或 Job Cluster。

Flink Application Cluster 则是只执行来自一个 Flink Application 的作业的专用集群,集群生命周期与应用的运行生命周期绑定——应用启动则集群拉起,应用结束(main() 返回)则集群随之释放。这种模式让每个应用拥有完全独立的资源与 ClassLoader 环境,避免作业间相互干扰,是生产环境推荐的部署方式之一。

Flink Job Cluster(作业集群)

A Flink Job Cluster is a dedicated Flink Cluster that only executes a single Flink Job. The lifetime of the Flink Cluster is bound to the lifetime of the Flink Job. This deployment mode has been deprecated since Flink 1.15.

Flink Job Cluster 是只执行单个 Flink Job 的专用集群,集群生命周期与作业生命周期绑定。glossary 明确标注:该部署模式自 Flink 1.15 起已被弃用(deprecated)。如果你在旧版本资料中看到"per-job cluster"的说法,指的就是这种形态;在新版本中应改用 Application 模式(应用模式),两者的资源隔离收益相同,但 Application 模式在运维与生命周期管理上更统一。

Flink Session Cluster(会话集群)

A long-running Flink Cluster which accepts multiple Flink Jobs for execution. The lifetime of this Flink Cluster is not bound to the lifetime of any Flink Job.

Session Cluster 是一个长期运行的集群,可同时接纳多个 Flink Job 执行,集群生命周期不与任何单个作业绑定。过去它也被称为 session mode 下的 Flink Cluster。

三种模式的对比速查:

模式 集群生命周期 可运行作业数 资源隔离 备注
Application Cluster 绑定应用生命周期 一个应用的多个作业 好(独立集群) 生产推荐
Job Cluster 绑定单个作业生命周期 仅一个 好 自 1.15 起弃用
Session Cluster 长期运行,不绑定作业 多个作业共享 一般(共享资源) 适合开发调试、小作业

四、作业与四种图:Logical / JobGraph / Physical / ExecutionGraph

glossary 中反复出现"图(graph)"的概念,这是 Flink 中最容易混淆的部分。核心在于区分逻辑图与物理图两个层级。

Logical Graph(逻辑图)与 JobGraph

A logical graph is a directed graph where the nodes are Operators and the edges define input/output-relationships of the operators and correspond to data streams or data sets.

Logical Graph 是有向图:节点是 Operator,边描述算子之间的输入/输出关系,对应数据流(data stream)或数据集(data set)。它由 Flink Application 提交作业时创建,通常也被称为 dataflow graph(数据流图)。在 DataStream API 中,用户代码经过 StreamGraphGenerator(见 flink-streaming-java/src/main/java/org/apache/flink/streaming/api/graph/StreamGraphGenerator.java)被翻译成 StreamGraph,再进一步转换为可提交的 JobGraph。

glossary 明确指出 JobGraph 就是 Logical Graph 的别名("see Logical Graph")。JobGraph 是作业提交给集群时的"蓝图",它被序列化后提交给 Dispatcher,再由 JobMaster 消费。从源码结构看,flink-runtime/src/main/java/org/apache/flink/runtime/jobgraph/ 目录下的 JobGraph、JobVertex、JobEdge 等类即对应这一层抽象的运行时实现。

Physical Graph(物理图)与 ExecutionGraph

A physical graph is the result of translating a Logical Graph for execution in a distributed runtime. The nodes are Tasks and the edges indicate input/output-relationships or partitions of data streams or data sets.

Physical Graph 是 Logical Graph 为在分布式运行时中执行而翻译的结果:节点变为 Task,边表示输入/输出关系或数据流/数据集的分区关系。glossary 指出 ExecutionGraph 是 Physical Graph 的别名("see Physical Graph")。

ExecutionGraph 在源码中是分布式执行的核心数据结构,见 flink-runtime/src/main/java/org/apache/flink/runtime/executiongraph/ExecutionGraph.java:

The execution graph is the central data structure that coordinates the distributed execution of a data flow. It keeps representations of each parallel task, each intermediate stream, and the communication between them.

该接口的 Javadoc 进一步揭示了物理图内部的三个层级结构,对应三种标识符:

  • ExecutionJobVertex:对应 JobGraph 中的一个顶点(通常是一个算子操作,如 "map" 或 "join"),持有该顶点所有并行子任务聚合后的状态,用 JobVertexID 标识;
  • ExecutionVertex:对应一个并行子任务(subtask),每个 ExecutionJobVertex 有多少并行度就有多少个 ExecutionVertex,用"ExecutionJobVertex + 并行下标"标识;
  • Execution:一次对 ExecutionVertex 的执行尝试(attempt)。失败重试、或数据需要重算时会出现多次 Execution,每次执行尝试用 ExecutionAttemptID 唯一标识——JobManager 与 TaskManager 之间所有关于任务部署与状态更新的消息,都用 ExecutionAttemptID 寻址。

图模型关系小结:

用户代码(DataStream/SQL)
   │  StreamGraphGenerator / 翻译
   ▼
Logical Graph(逻辑图,节点=Operator)
   │  = JobGraph(作业提交蓝图)
   ▼
Physical Graph(物理图,节点=Task)
   │  = ExecutionGraph(运行时分布式执行结构)
   ▼
Task / Sub-Task(在 TaskManager 上执行)

Flink Job(作业)

A Flink Job is the runtime representation of a logical graph (also often called dataflow graph) that is created and submitted by calling execute() in a Flink Application.

Flink Job 是逻辑图(数据流图)的运行时表示,由 Flink Application 中调用 execute() 创建并提交。因此:一个应用可以包含多个作业(多次调用 execute()),而每个作业都有自己独立的 JobMaster、ExecutionGraph 与生命周期。作业是资源分配、状态隔离与故障恢复的基本单位之一。


五、数据模型:Record、Event 与 Partition

Record(记录)

Records are the constituent elements of a data set or data stream. Operators and Functions receive records as input and emit records as output.

Record 是数据集或数据流的基本组成元素,Operator 与 Function 以 Record 为输入、以 Record 为输出。它是 Flink 处理的最小数据单元——无论底层是 Kafka 消息、文件行还是数据库变更日志,进入 Flink 后都被抽象为 Record 流。

Event(事件)

An event is a statement about a change of the state of the domain modelled by the application. Events can be input and/or output of a stream or batch processing application. Events are special types of records.

Event 是对应用所建模领域的状态变化的陈述(例如"用户下单""传感器温度升高")。它可以作为流式或批处理应用的输入和/或输出。关键区别在于:Event 是 Record 的一种特殊类型——Event 承载业务语义(描述发生了什么变化),而 Record 是更通用的数据容器概念。

Partition(分区)

A partition is an independent subset of the overall data stream or data set. ... A transformation which changes the way a data stream or data set is partitioned is often called repartitioning.

Partition 是数据流或数据集的独立子集。数据流/数据集通过把每条 Record 分配到若干个分区之一(或之一上)来完成划分;运行时由 Task 消费各个分区。改变数据流/数据集分区方式的转换称为重分区(repartitioning)。

分区是并行的基石:一个算子的并行度是 N,则其输出通常被划分为 N 个分区,下游 N 个并行子任务各消费一个分区。常见的重分区转换包括 keyBy(按键分区)、rebalance(轮询)、broadcast(广播)等。当算子之间发生重分区时,两个算子便无法被链接(chaining)为同一个 Operator Chain——这正是下一节要讲的链式结构的关键约束。


六、执行单元:Function、Operator、Instance、Task、Sub-Task 与 Operator Chain

Function(函数)

Functions are implemented by the user and encapsulate the application logic of a Flink program. Most Functions are wrapped by a corresponding Operator.

Function 是由用户实现、封装 Flink 程序业务逻辑的代码单元(如 MapFunction、FlatMapFunction、ProcessFunction)。大多数 Function 会被相应的 Operator 包装——也就是说,用户写的是 Function,而 Flink 运行的是包装了该 Function 的 Operator。

Operator(算子)

Node of a Logical Graph. An Operator performs a certain operation, which is usually executed by a Function. Sources and Sinks are special Operators for data ingestion and data egress.

Operator 是逻辑图的节点,执行某种操作(通常由 Function 完成)。Source(数据接入)与 Sink(数据输出)是特殊类型的 Operator。因此逻辑图"节点是 Operator"与"边是数据流"的定义在此闭环:一个算子对应一个(或一组)业务操作,Source/Sink 作为边界算子负责数据的流入与流出。

Instance(实例)与并行实例

The term instance is used to describe a specific instance of a specific type (usually Operator or Function) during runtime. ... the term parallel instance is also frequently used to emphasize that multiple instances of the same Operator or Function type are running in parallel.

Instance 描述运行时某个特定类型(通常是 Operator 或 Function)的具体实例。由于 Flink 主要用 Java 编写,这与 Java 中的 Instance/Object 概念一致。当同一 Operator 或 Function 类型的多个实例并行运行时,则称为并行实例(parallel instance)——并行度是多少,就有多少个并行实例。

Task(任务)与 Sub-Task(子任务)

Node of a Physical Graph. A task is the basic unit of work, which is executed by Flink's runtime. Tasks encapsulate exactly one parallel instance of an Operator or Operator Chain.

Task 是物理图的节点,是 Flink 运行时执行的基本工作单元。一个 Task 恰好封装一个 Operator 或 Operator Chain 的并行实例。

A Sub-Task is a Task responsible for processing a partition of the data stream. The term "Sub-Task" emphasizes that there are multiple parallel Tasks for the same Operator or Operator Chain.

Sub-Task 是负责处理数据流中一个分区的 Task。这个词强调:同一 Operator 或 Operator Chain 存在多个并行 Task。简单说,一个并行度为 N 的算子有 N 个并行实例,每个实例对应一个 Sub-Task;在物理图上它们各自是一个 Task 节点。实际运行(消费分区)的最小调度单位是 Sub-Task,对应前文 ExecutionGraph 中的 ExecutionVertex。

Operator Chain(算子链)

An Operator Chain consists of two or more consecutive Operators without any repartitioning in between. Operators within the same Operator Chain forward records to each other directly without going through serialization or Flink's network stack.

Operator Chain 由两个或更多连续的、中间没有重分区的 Operator 组成。链内算子之间直接转发 Record,不经过序列化,也不走 Flink 网络栈——数据在同一 JVM 的同一线程内直接传递,因而吞吐更高、延迟更低。

理解这个术语要注意两点:

  • 形成链的前提是算子间无重分区(keyBy、rebalance 等会切断链),同时各算子并行度需一致;
  • 链一旦形成,链上所有算子就被打包进一个 Task(即一个 Operator Chain 封装为一个并行实例),这正是"Task 封装一个 Operator 或 Operator Chain"的含义。

在 Web UI 上看到的一个"任务",往往就是一条 Operator Chain;链内各算子仍可通过 disableChaining() 等方法显式拆开。


七、状态与检查点:Managed State、State Backend、Checkpoint Storage

Managed State(托管状态)

Managed State describes application state which has been registered with the framework. For Managed State, Apache Flink will take care about persistence and rescaling among other things.

Managed State 是已注册到框架(Flink 运行时)的应用状态。对于托管状态,Flink 会负责**持久化(persistence)与重缩放(rescaling)**等事宜——即扩缩容时状态自动重新分配、故障时状态可从检查点恢复。与之相对的是 Raw State(原生状态,框架不感知其内部结构)。

State Backend(状态后端)

For stream processing programs, the State Backend of a Flink Job determines how its state is stored on each TaskManager (Java Heap of TaskManager or (embedded) RocksDB).

对于流处理程序,State Backend 决定每个 TaskManager 上状态如何存储,典型选项包括:

  • TaskManager 的 Java 堆(Heap):状态存放在 JVM 堆内,读写快但受 GC 影响、容量受堆大小限制;
  • (内嵌)RocksDB:状态存放在 TaskManager 本地磁盘上的 RocksDB 键值存储中,容量大、适合大状态,但每次读写涉及序列化。

State Backend 决定状态"存在哪、怎么存",是状态存储策略层面的概念。本仓库中状态后端相关实现分布在 flink-state-backends 模块下(如 flink-statebackend-rocksdb、flink-statebackend-forst、flink-statebackend-heap-spillable 等),其中 RocksDB 后端即内嵌 RocksDB 的实现。

Checkpoint Storage(检查点存储)

The location where the State Backend will store its snapshot during a checkpoint (Java Heap of JobManager or Filesystem).

Checkpoint Storage 是 State Backend 在检查点期间存放其快照(snapshot)的位置,选项包括:

三者关系一句话:State Backend 决定状态在 TaskManager 上怎么存;Checkpoint Storage 决定检查点时状态快照往哪儿放;Managed State 是这两者所管理的状态对象本身。


八、API 层面的抽象:Transformation、Table Program 与运行时执行模式

Transformation(转换)

A Transformation is applied on one or more data streams or data sets and results in one or more output data streams or data sets. A transformation might change a data stream or data set on a per-record basis, but might also only change its partitioning or perform an aggregation.

Transformation 应用于一个或多个数据流/数据集,产出一个或多个输出。它可以按记录粒度改写数据,也可以只改变分区方式或执行聚合。关键定位在最后一句:

While Operators and Functions are the "physical" parts of Flink's API, Transformations are only an API concept. Specifically, most transformations are implemented by certain Operators.

Operator 与 Function 是 Flink API 的"物理"部分,而 Transformation 只是 API 层面的概念——大多数 transformation 由特定 Operator 实现。也就是说,map()、keyBy()、window() 这类 API 调用是 Transformation;它们在编译为逻辑图时会被翻译成对应的 Operator,进而在运行时由 Operator/Function 真正执行。

Table Program(表程序)

A generic term for pipelines declared with Flink's relational APIs (Table API or SQL).

Table Program 是用 Flink 关系型 API(Table API 或 SQL)声明的流水线的统称。与 DataStream API 程序相对,Table Program 走的是关系代数路线:声明式地描述"做什么"(如 SELECT ... WHERE ...),由 Flink 的查询优化器(基于 Calcite,位于 flink-table/flink-table-planner 模块)负责翻译与优化。

(Runtime) Execution Mode(运行时执行模式)

DataStream API programs can be executed in one of two execution modes: BATCH or STREAMING.

DataStream API 程序可以在两种运行时执行模式之一中运行:BATCH(批)或 STREAMING(流)。从 Flink 1.12 开始,同一套 DataStream API 可以按模式切换语义:流模式按事件时间持续处理、支持有界与无界流;批模式则按有界数据集的整体处理、可应用批式调度与更积极的算子优化。详细说明见官方文档 Execution Mode。


九、容错与恢复:JobResultStore(作业结果存储)

The JobResultStore is a Flink component that persists the results of globally terminated (i.e. finished, cancelled or failed) jobs to a filesystem, allowing the results to outlive a finished job. These results are then used by Flink to determine whether jobs should be subject to recovery in highly-available clusters.

JobResultStore 是 Flink 的作业结果持久化组件:它把**全局终止(globally terminated)**的作业(即 finished、cancelled 或 failed)的结果写入文件系统,使结果在作业结束后仍然存在。这些结果随后被 Flink 用来判断:在高可用(HA)集群中,哪些作业需要被恢复——已确认终止且被标记为干净的作业不会被重复拉起,而因异常中断的作业则可能被恢复。

该组件的接口定义在 flink-runtime/src/main/java/org/apache/flink/runtime/highavailability/JobResultStore.java,其 Javadoc 揭示了结果记录的两种状态:

  • dirty(脏):对应作业尚未被正确清理(clean-up 尚未完成),后续仍需执行清理动作;
  • clean(干净):对应作业的清理已完成,无需进一步操作。

接口中的 createDirtyResultAsync 与 markResultAsCleanAsync 两个方法即对应"登记脏结果 → 清理完成后标记为干净"的完整生命周期(JobResultStore.java)。实际文件系统实现为 FileSystemJobResultStore(位于同一 highavailability 包下),配置项集中在 flink-runtime/src/main/java/org/apache/flink/runtime/highavailability/JobResultStoreOptions.java。


十、算子身份标识:UID 与 UID hash

UID(用户/结构标识)

A unique identifier of an Operator, either provided by the user or determined from the structure of the job. When the Application is submitted this is converted to a UID hash.

UID 是一个 Operator 的唯一标识,来源有二:

  1. 用户显式提供:通过 DataStream.uid("my-operator-id")(DataStream API)或 SQL 中的算子 hint 等方式指定;
  2. 根据作业结构自动确定:未指定时,Flink 根据算子在图中的结构信息生成。

作业提交时,UID 会被转换为 UID hash。

UID hash(UID 哈希)

A unique identifier of an Operator at runtime, otherwise known as "Operator ID" or "Vertex ID" and generated from a UID. It is commonly exposed in logs, the REST API or metrics, and most importantly is how operators are identified within savepoints.

UID hash 是运行时 Operator 的唯一标识,也被称为 "Operator ID" 或 "Vertex ID",由 UID 生成。它常见于:

  • 日志:算子相关日志中打印的标识;
  • REST API 与指标(metrics):Web UI 与监控系统中展示的算子标识;
  • 最重要的一点——savepoint 中算子的身份标识:savepoint 恢复时正是依据 UID hash 把状态对回相应的算子。因此,若作业拓扑结构变化导致自动生成的 hash 改变,或未显式设置 UID 的算子顺序调整,savepoint 恢复就可能失败——这就是官方一直建议"为关键算子显式设置 UID"的原因。Savepoint 的详细机制见 docs/content/docs/ops/state/savepoints.md。

在源码层面,UID hash 的生成逻辑位于 flink-streaming-java 模块的 StreamGraphHasher(flink-streaming-java/src/main/java/org/apache/flink/streaming/api/graph/StreamGraphHasher.java),其 Javadoc 说明它是"为 StreamGraph 生成哈希的接口",为每个 StreamNode 计算一个哈希;而运行时标识类 OperatorID 定义于 flink-runtime/src/main/java/org/apache/flink/runtime/jobgraph/OperatorID.java,其中的 fromJobVertexID(JobVertexID) 工厂方法(OperatorID.java)展示了 OperatorID 与作业顶点 ID 之间的转换关系。


十一、术语速查表

术语 一句话定义 关键关联
Flink Cluster 一个 JobManager + 若干 TaskManager 的分布式系统 集群级
Flink JobManager 集群协调者,含 Resource Manager、Dispatcher 与每个作业一个 JobMaster 进程级
Flink JobMaster 监督单个作业所有 Task 执行的组件 作业级
Flink TaskManager 执行 Task 的工作进程,彼此通信交换数据 进程级
Flink Application 从 main() 提交一个或多个作业的 Java 应用 应用级
Flink Application Cluster 只执行一个应用的作业、生命周期绑定应用的专用集群 部署形态
Flink Job Cluster 只执行单个作业、生命周期绑定作业的专用集群(1.15 起弃用) 部署形态
Flink Session Cluster 长期运行、可执行多个作业、生命周期不绑定作业的集群 部署形态
Flink Job 逻辑图(数据流图)的运行时表示,由 execute() 创建 作业级
Logical Graph / JobGraph 节点为 Operator 的有向图,即数据流图 / 作业提交蓝图 图模型
Physical Graph / ExecutionGraph 翻译自逻辑图、节点为 Task 的执行图,运行时核心结构 图模型
Record 数据集/数据流的基本组成元素 数据模型
Event 描述领域状态变化陈述的 Record 特殊类型 数据模型
Partition 数据流/数据集的独立子集;改变划分方式称重分区 数据模型
Function 用户实现的业务逻辑单元,多数被 Operator 包装 执行单元
Operator 逻辑图节点,执行操作(通常由 Function 完成),Source/Sink 为特例 执行单元
Instance 运行时某个 Operator/Function 类型的具体实例;并行实例强调并行 执行单元
Task 物理图节点,封装一个 Operator 或 Operator Chain 的并行实例 执行单元
Sub-Task 负责处理一个分区的 Task,强调同一算子的多个并行 Task 执行单元
Operator Chain 无重分区连续算子组成的链,链内直接转发、不经序列化与网络栈 执行单元
Managed State 注册到框架、由 Flink 负责持久化与重缩放的应用状态 状态
State Backend 决定状态在每个 TaskManager 上如何存储(Java 堆或 RocksDB) 状态
Checkpoint Storage 检查点时状态快照的存放位置(JobManager 堆或文件系统) 检查点
JobResultStore 持久化全局终止作业结果、决定 HA 下哪些作业需要恢复的组件 容错
Transformation API 层面的数据流/数据集转换概念,多数由 Operator 实现 API
Table Program 用 Table API 或 SQL 声明的流水线统称 API
Execution Mode DataStream 程序的 BATCH / STREAMING 两种执行模式 API
UID 算子唯一标识(用户提供或按作业结构确定) 标识
UID hash 由 UID 生成的运行时算子标识(Operator ID / Vertex ID),savepoint 依此识别算子 标识

结语:把术语串成一条主线

回顾全文,Flink 的核心术语其实可以被一条主线串起:你编写一个 Flink Application(应用),在 main() 中调用 execute() 提交 Flink Job(作业);作业以 Logical Graph / JobGraph(逻辑图,节点是 Operator,边是数据流)为蓝图,被翻译为 Physical Graph / ExecutionGraph(物理图,节点是 Task,边对应 Partition);Task 封装 Operator 或 Operator Chain 的并行实例(Sub-Task)并被调度到 TaskManager 上执行,而 JobMaster 在 JobManager 中监督这一切;执行期间,Managed State 按 State Backend 的策略在 TaskManager 上存储,检查点快照按 Checkpoint Storage 的配置落位,作业结束后 JobResultStore 记录其最终结果,UID / UID hash 则保证 savepoint 能准确把状态对回算子。

掌握了这条主线,你就拥有了阅读 Flink 文档、理解运行日志、排查故障乃至深入源码的统一语言。进一步探索时,可以从 glossary.md 出发,配合 execution_mode.md(执行模式)、savepoints.md(保存点)以及本仓库 flink-runtime、flink-streaming-java 源码,按图索骥地深入每个概念背后的实现。

登录后查看全文
flink