（九）状态管理

一、Flink中的状态

1.1 概述

1.2 状态的分类

1）托管状态（Managed State）和原始状态（Raw State）

Flink的状态有两种：托管状态（Managed State）和原始状态（Raw State）。托管状态就是由Flink统一管理的，状态的存储访问、故障恢复和重组等一系列问题都由Flink实现，我们只要调接口就可以；而原始状态则是自定义的，相当于就是开辟了一块内存，需要我们自己管理，实现状态的序列化和故障恢复。

通常我们采用Flink托管状态来实现需求。

2）算子状态（Operator State）和按键分区状态（Keyed State）

接下来我们的重点就是托管状态（Managed State）。

我们知道在Flink中，一个算子任务会按照并行度分为多个并行子任务执行，而不同的子任务会占据不同的任务槽（task slot）。由于不同的slot在计算资源上是物理隔离的，所以Flink能管理的状态在并行任务间是无法共享的，每个状态只能针对当前子任务的实例有效。

而很多有状态的操作（比如聚合、窗口）都是要先做keyBy进行按键分区的。按键分区之后，任务所进行的所有计算都应该只针对当前key有效，所以状态也应该按照key彼此隔离。在这种情况下，状态的访问方式又会有所不同。

基于这样的想法，我们又可以将托管状态分为两类：算子状态和按键分区状态。

另外，也可以通过富函数类（Rich Function）来自定义Keyed State，所以只要提供了富函数类接口的算子，也都可以使用Keyed State。所以即使是map、filter这样无状态的基本转换算子，我们也可以通过富函数类给它们“追加”Keyed State。比如RichMapFunction、RichFilterFunction。在富函数中，我们可以调用.getRuntimeContext()获取当前的运行时上下文（RuntimeContext），进而获取到访问状态的句柄；这种富函数中自定义的状态也是Keyed State。从这个角度讲，Flink中所有的算子都可以是有状态的。

无论是Keyed State还是Operator State，它们都是在本地实例上维护的，也就是说每个并行子任务维护着对应的状态，算子的子任务之间状态不共享。

二、 按键分区状态（Keyed State）

按键分区状态（Keyed State）顾名思义，是任务按照键（key）来访问和维护的状态。它的特点非常鲜明，就是以key为作用范围进行隔离。

需要注意，使用Keyed State必须基于KeyedStream。没有进行keyBy分区的DataStream，即使转换算子实现了对应的富函数类，也不能通过运行时上下文访问Keyed State。

2.1 值状态（ValueState）

 顾名思义，状态中只保存一个“值”（value）。ValueState<T>本身是一个接口，源码中定义如下：

public interface ValueState<T> extends State {

    T value() throws IOException;

    void update(T value) throws IOException;

}

这里的T是泛型，表示状态的数据内容可以是任何具体的数据类型。如果想要保存一个长整型值作为状态，那么类型就是ValueState<Long>。

我们可以在代码中读写值状态，实现对于状态的访问和更新。

• T value()：获取当前状态的值；
• update(T value)：对状态进行更新，传入的参数value就是要覆写的状态值。

在具体使用时，为了让运行时上下文清楚到底是哪个状态，我们还需要创建一个“状态描述器”（StateDescriptor）来提供状态的基本信息。例如源码中，ValueState的状态描述器构造方法如下：

public ValueStateDescriptor(String name, Class<T> typeClass) {

    super(name, typeClass, null);

}

这里需要传入状态的名称和类型——这跟我们声明一个变量时做的事情完全一样。

案例需求：检测每种传感器的水位值，如果连续的两个水位值超过10，就输出报警。

public class KeyedValueStateDemo {

    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);

        SingleOutputStreamOperator<WaterSensor> sensorDS = env

                .socketTextStream("hadoop102", 7777)

                .map(new WaterSensorMapFunction())

                .assignTimestampsAndWatermarks(

                        WatermarkStrategy

                                .<WaterSensor>forBoundedOutOfOrderness(Duration.ofSeconds(3))

                                .withTimestampAssigner((element, ts) -> element.getTs() * 1000L)

                );

        sensorDS.keyBy(r -> r.getId())

                .process(

                        new KeyedProcessFunction<String, WaterSensor, String>() {



                            // TODO 1.定义状态

                            ValueState<Integer> lastVcState;

                            @Override

                            public void open(Configuration parameters) throws Exception {

                                super.open(parameters);

                                // TODO 2.在open方法中，初始化状态

                                // 状态描述器两个参数：第一个参数，起个名字，不重复；第二个参数，存储的类型

                                lastVcState = getRuntimeContext().getState(new ValueStateDescriptor<Integer>("lastVcState", Types.INT));

                            }

                            @Override

                            public void processElement(WaterSensor value, Context ctx, Collector<String> out) throws Exception {

//                                lastVcState.value();  // 取出 本组 值状态 的数据

//                                lastVcState.update(); // 更新 本组 值状态 的数据

//                                lastVcState.clear();  // 清除 本组 值状态 的数据

                                // 1. 取出上一条数据的水位值(Integer默认值是null，判断)

                                int lastVc = lastVcState.value() == null ? 0 : lastVcState.value();

                                // 2. 求差值的绝对值，判断是否超过10

                                Integer vc = value.getVc();

                                if (Math.abs(vc - lastVc) > 10) {

                                    out.collect("传感器=" + value.getId() + "==>当前水位值=" + vc + ",与上一条水位值=" + lastVc + ",相差超过10！！！！");

                                }

                                // 3. 更新状态里的水位值

                                lastVcState.update(vc);

                            }

                        }

                )

                .print();

        env.execute();

    }

}

2.2 列表状态（ListState）

将需要保存的数据，以列表（List）的形式组织起来。在ListState<T>接口中同样有一个类型参数T，表示列表中数据的类型。ListState也提供了一系列的方法来操作状态，使用方式与一般的List非常相似。

• Iterable<T> get()：获取当前的列表状态，返回的是一个可迭代类型Iterable<T>；
• update(List<T> values)：传入一个列表values，直接对状态进行覆盖；
• add(T value)：在状态列表中添加一个元素value；
• addAll(List<T> values)：向列表中添加多个元素，以列表values形式传入。

类似地，ListState的状态描述器就叫作ListStateDescriptor，用法跟ValueStateDescriptor完全一致。

案例:针对每种传感器输出最高的3个水位值

public class KeyedListStateDemo {

    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);

        SingleOutputStreamOperator<WaterSensor> sensorDS = env

                .socketTextStream("hadoop102", 7777)

                .map(new WaterSensorMapFunction())

                .assignTimestampsAndWatermarks(

                        WatermarkStrategy

                                .<WaterSensor>forBoundedOutOfOrderness(Duration.ofSeconds(3))

                                .withTimestampAssigner((element, ts) -> element.getTs() * 1000L)

                );

        sensorDS.keyBy(r -> r.getId())

                .process(

                        new KeyedProcessFunction<String, WaterSensor, String>() {

                            ListState<Integer> vcListState;

                            @Override

                            public void open(Configuration parameters) throws Exception {

                                super.open(parameters);

                                vcListState = getRuntimeContext().getListState(new ListStateDescriptor<Integer>("vcListState", Types.INT));

                            }

                            @Override

                            public void processElement(WaterSensor value, Context ctx, Collector<String> out) throws Exception {

                                // 1.来一条，存到list状态里

                                vcListState.add(value.getVc());

                                // 2.从list状态拿出来(Iterable)， 拷贝到一个List中，排序， 只留3个最大的

                                Iterable<Integer> vcListIt = vcListState.get();