大数据与流处理 / 系统课时

选择 Operator State 重分配模式

选择 Operator State 重分配模式

Operator State 在恢复时不仅要“读回来”,还要解决并行度变化后的归属问题。Flink 为列表型 Operator State 提供 even-split 与 union 两种重分配语义;选错模式会造成状态重复、丢失业务所有权,甚至在扩容后把大状态复制到每个子任务。

学习目标

  • 区分 getListState() 与 getUnionListState() 的恢复语义
  • 根据状态是否需要唯一所有者选择重分配模式
  • 识别 Union State 的复制成本与重复写回风险

两种模式解决不同的所有权问题

getListState() 使用 even-split 重分配。Checkpoint 中所有列表元素会在恢复时重新切分,每个元素只交给一个新子任务;某个子任务可能拿到零个、一个或多个元素。它适合“一个状态元素只能由一个实例继续负责”的数据。

getUnionListState() 使用 union 重分配。恢复时会把各旧子任务保存的列表逻辑合并,再把完整集合交给每一个新子任务。它适合所有实例都需要看到全局元数据,再依据当前分配结果筛选自己应负责部分的场景。

Operator State even-split 与 union 重分配对比

图中的元素分配只是语义示意,业务逻辑不应依赖“某个元素一定落到编号固定的子任务”。真正可依赖的是:even-split 下每个状态元素只有一个恢复后的所有者,union 下每个恢复后的子任务都能看到完整集合。

在代码中明确选择访问方式

下面的完整示例通过启动参数选择重分配模式。Union 恢复后先读取完整集合,再按当前并行度重新计算唯一所有者;后续快照只写本子任务真正拥有的元素,避免把完整 union 集合从每个实例重复写回。

java
import java.util.ArrayList;
import java.util.List;

import org.apache.flink.api.common.functions.OpenContext;
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.api.common.state.ListState;
import org.apache.flink.api.common.state.ListStateDescriptor;
import org.apache.flink.runtime.state.FunctionInitializationContext;
import org.apache.flink.runtime.state.FunctionSnapshotContext;
import org.apache.flink.streaming.api.checkpoint.CheckpointedFunction;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class RedistributionModeDemo {

    enum Mode {
        EVEN_SPLIT,
        UNION
    }

    public static void main(String[] args) throws Exception {
        Mode mode = args.length > 0 && "union".equalsIgnoreCase(args[0])
                ? Mode.UNION
                : Mode.EVEN_SPLIT;

        StreamExecutionEnvironment env =
                StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        env.enableCheckpointing(1000);

        env.fromData("A", "B", "C")
                .map(new ModeAwareMapper(mode))
                .uid("mode-aware-map")
                .setParallelism(1)
                .print()
                .setParallelism(1);

        env.execute("redistribution-mode-demo");
    }

    public static class ModeAwareMapper
            extends RichMapFunction<String, String>
            implements CheckpointedFunction {

        private final Mode mode;
        private transient ListState<String> checkpointedItems;
        private transient List<String> restoredItems;
        private transient List<String> localItems;

        public ModeAwareMapper(Mode mode) {
            this.mode = mode;
        }

        @Override
        public void initializeState(FunctionInitializationContext context)
                throws Exception {
            restoredItems = new ArrayList<>();
            ListStateDescriptor<String> descriptor =
                    new ListStateDescriptor<>("owned-items", String.class);

            checkpointedItems = mode == Mode.UNION
                    ? context.getOperatorStateStore().getUnionListState(descriptor)
                    : context.getOperatorStateStore().getListState(descriptor);

            if (context.isRestored()) {
                for (String item : checkpointedItems.get()) {
                    restoredItems.add(item);
                }
            }
        }

        @Override
        public void open(OpenContext openContext) {
            localItems = new ArrayList<>();
            if (mode == Mode.EVEN_SPLIT) {
                localItems.addAll(restoredItems);
                return;
            }

            int index = getRuntimeContext().getTaskInfo().getIndexOfThisSubtask();
            int parallelism =
                    getRuntimeContext().getTaskInfo().getNumberOfParallelSubtasks();

            // Union 恢复后每个实例看到全集,再确定当前实例的唯一所有权。
            for (String item : restoredItems) {
                if (Math.floorMod(item.hashCode(), parallelism) == index) {
                    localItems.add(item);
                }
            }
        }

        @Override
        public String map(String value) {
            localItems.add(value);
            return mode + ":" + value;
        }

        @Override
        public void snapshotState(FunctionSnapshotContext context) throws Exception {
            checkpointedItems.clear();
            // 无论哪种模式,都只写当前子任务真正拥有的元素。
            for (String item : localItems) {
                checkpointedItems.add(item);
            }
        }
    }
}

预期输出(不传参数,使用 EVEN_SPLIT;控制台可能附带任务编号前缀):

text
EVEN_SPLIT:A
EVEN_SPLIT:B
EVEN_SPLIT:C

这个有限输入示例用于展示 API 选择和安全的写回方式;只有从已完成的 Checkpoint 或 Savepoint 改变并行度恢复时,两种重分配模式的差异才会真正出现。保留稳定的 uid() 也有助于恢复时把旧状态重新映射到同一逻辑算子。

按状态语义而不是数据量猜模式

优先问“恢复后谁应该拥有这个元素”。如果每个分片、待处理任务或缓冲条目只应由一个子任务继续处理,使用 getListState()。同时要把可独立迁移的数据拆成多个列表元素;如果把整个大集合包装成单个元素,Flink 不能再把其内部成员均匀拆开。

只有当每个新子任务都必须拿到完整元数据才能重新计算自己的负责范围时,才考虑 getUnionListState()。例如,恢复后每个实例读取所有分片描述,再按当前并行度筛选自己应接管的分片。筛选完成后,后续快照应只写当前实例真正拥有的那部分,而不是把刚收到的完整 union 集合原样再次保存。

避免把 Union State 当成 Broadcast State

Union 只定义 Operator State 在恢复和扩缩容时怎样重分配,并不意味着运行期间某个子任务的修改会自动同步给其他子任务。Broadcast State 则由广播输入驱动,用于让并行实例在运行时维护一致规则或配置,两者解决的问题不同。

因此选择可以压缩成一个原则:需要唯一所有者就用 even-split,需要每个恢复实例看到完整元数据才用 union;如果需求是按 key 隔离业务状态,应优先使用 Keyed State,而不是靠 Operator State 的重分配模式模拟分区。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

选择 Operator State 重分配模式

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通