Flink 状态管理
#Flink 状态管理
我们前面写的 wordcount 的例子，没有包含状态管理。如果一个 task 在处理过程中挂掉了，那么它在内存中的状态都会丢失，所有的数据都需要重新计算。从容错和消息处理的语义上(at least once, exactly once)，Flink 引入了 state 和 checkpoint。
因此可以说 flink 因为引入了 state 和 checkpoint 所以才支持的 exactly once
首先区分一下两个概念：
state：
state 一般指一个具体的 task/operator 的状态：
- state 数据默认保存在 java 的堆内存中，TaskManage 节点的内存中。
- operator 表示一些算子在运行的过程中会产生的一些中间结果。
checkpoint：
checkpoint 可以理解为 checkpoint 是把 state 数据定时持久化存储了，则表示了一个 Flink Job 在一个特定时刻的一份全局状态快照，即包含了所有 task/operator 的状态。
注意：task(subTask)是 Flink 中执行的基本单位。operator 指算子(transformation)
State 可以被记录，在失败的情况下数据还可以恢复。
Flink 中有两种基本类型的 State：
- Keyed State
- Operator State
Keyed State 和 Operator State，可以以两种形式存在：
- 原始状态(raw state)
- 托管状态(managed state)
托管状态是由 Flink 框架管理的状态。
我们说 operator 算子保存了数据的中间结果，中间结果保存在什么类型中，如果我们这里是托管状态，则由 flink 框架自行管理
原始状态由用户自行管理状态具体的数据结构，框架在做 checkpoint 的时候，使用 byte[]来读写状态内容，对其内部数据结构一无所知。
通常在 DataStream 上的状态推荐使用托管的状态，当实现一个用户自定义的 operator 时，会使用到原始状态。
#1. State-Keyed State
基于 KeyedStream 上的状态。这个状态是跟特定的 key 绑定的，对 KeyedStream 流上的每一个 key，都对应一个 state，比如：stream.keyBy(…)。KeyBy 之后的 Operator State,可以理解为分区过的 Operator State。
保存 state 的数据结构：
ValueState：即类型为 T 的单值状态。这个状态与对应的 key 绑定，是最简单的状态了。它可以通过 update 方法更新状态值，通过 value()方法获取状态值。
ListState：即 key 上的状态值为一个列表。可以通过 add 方法往列表中附加值；也可以通过 get()方法返回一个 Iterable来遍历状态值。
ReducingState:这种状态通过用户传入的 reduceFunction，每次调用 add 方法添加值的时候，会调用 reduceFunction，最后合并到一个单一的状态值。
MapState
需要注意的是，以上所述的 State 对象，仅仅用于与状态进行交互（更新、删除、清空等），而真正的状态值，有可能是存在内存、磁盘、或者其他分布式存储系统中。相当于我们只是持有了这个状态的句柄。
#1. ValueState
使用 ValueState 保存中间结果对下面数据进行分组求和。
开发步骤：
1. 获取流处理执行环境
2. 加载数据源
3. 数据分组
4. 数据转换，定义ValueState,保存中间结果
5. 数据打印
6. 触发执行
ValueState:测试数据源：
List(
(1L, 4L),
(2L, 3L),
(3L, 1L),
(1L, 2L),
(3L, 2L),
(1L, 2L),
(2L, 2L),
(2L, 9L)
)
示例代码：
import org.apache.flink.api.common.functions.RichFlatMapFunction
import org.apache.flink.api.common.state.{ValueState, ValueStateDescriptor}
import org.apache.flink.api.common.typeinfo.{TypeHint, TypeInformation}
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}
import org.apache.flink.util.Collector
object TestKeyedState {
class CountWithKeyedState extends RichFlatMapFunction[(Long, Long), (Long, Long)] {
/**
* ValueState状态句柄. 第一个值为count，第二个值为sum。
*/
private var sum: ValueState[(Long, Long)] = _
override def flatMap(input: (Long, Long), out: Collector[(Long, Long)]): Unit = {
// 获取当前状态值
val tmpCurrentSum: (Long, Long) = sum.value
// 状态默认值
val currentSum = if (tmpCurrentSum != null) {
tmpCurrentSum
} else {
(0L, 0L)
}
// 更新
val newSum = (currentSum._1 + 1, currentSum._2 + input._2)
// 更新状态值
sum.update(newSum)
// 如果count >=3 清空状态值，重新计算
if (newSum._1 >= 3) {
out.collect((input._1, newSum._2 / newSum._1))
sum.clear()
}
}
override def open(parameters: Configuration): Unit = {
sum = getRuntimeContext.getState(
new ValueStateDescriptor[(Long, Long)]("average", // 状态名称
TypeInformation.of(new TypeHint[(Long, Long)](){}) )// 状态类型
)
}
}
def main(args: Array[String]): Unit = {
//初始化执行环境
val env = StreamExecutionEnvironment.getExecutionEnvironment
//构建数据源
val inputStream: DataStream[(Long, Long)] = env.fromCollection(
List(
(1L, 4L),
(2L, 3L),
(3L, 1L),
(1L, 2L),
(3L, 2L),
(1L, 2L),
(2L, 2L),
(2L, 9L))
)
//执行数据处理
inputStream.keyBy(0)
.flatMap(new CountWithKeyedState)
.setParallelism(1)
.print
//运行任务
env.execute
}
}
#2. MapState
使用 MapState 保存中间结果对下面数据进行分组求和:
1. 获取流处理执行环境
2. 加载数据源
3. 数据分组
4. 数据转换，定义MapState,保存中间结果
5. 数据打印
6. 触发执行
MapState:测试数据源：
List(
("java", 1),
("python", 3),
("java", 2),
("scala", 2),
("python", 1),
("java", 1),
("scala", 2)
)
示例代码：
object MapState {
def main(args: Array[String]): Unit = {
val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
env.setParallelism(1)
/**
* 使用MapState保存中间结果对下面数据进行分组求和
* 1.获取流处理执行环境
* 2.加载数据源
* 3.数据分组
* 4.数据转换，定义MapState,保存中间结果
* 5.数据打印
* 6.触发执行
*/
val source: DataStream[(String, Int)] = env.fromCollection(List(
("java", 1),
("python", 3),
("java", 2),
("scala", 2),
("python", 1),
("java", 1),
("scala", 2)))
source.keyBy(0)
.map(new RichMapFunction[(String, Int), (String, Int)] {
var mste: MapState[String, Int] = _
override def open(parameters: Configuration): Unit = {
val msState = new MapStateDescriptor[String, Int]("ms",
TypeInformation.of(new TypeHint[(String)] {}),
TypeInformation.of(new TypeHint[(Int)] {}))
mste = getRuntimeContext.getMapState(msState)
}
override def map(value: (String, Int)): (String, Int) = {
val i: Int = mste.get(value._1)
mste.put(value._1, value._2 + i)
(value._1, value._2 + i)
}
}).print()
env.execute()
}
}
#2. State-Operator State
Flink默认不启用Checkpointing。如果要启用，可以在StreamExecutionEnvironment上调用enableCheckpointing(n)，其中n是以毫秒为单位的checkpoint间隔。
还有其他一些参数：
1、exactly-once vs at-least-once：在enableCheckpointing(n)中可以传递模式，对于大多数应用可能
exactly-once适合，但对于延迟要求在毫秒级别的，或许也可以设置为at-least-once。
2、checkpoint timeout：如果超过这个时间checkpoint还没结束，就会被认为是失败的。
3、minimum time between checkpoints：规定在两次checkpoints之间的最小时间是为了流应用可以在此期间有 明显的处理进度。比如这个值被设置为5秒，则在上一次checkpoint结束5秒之内不会有新的checkpoint被触发。这也通常意味着checkpoint interval的值会比这个值要大。为什么要设置这个值？因为checkpiont interval有时候会不可靠，比如当文件系统反应比较慢的时候，checkpiont花费的时间可能就比预想的要多，这样仅仅只有checkpoint interval的话就会重叠。记住，设置minimum time between checkpoints也要求checkpoints的并发度是1。
4、number of concurrent checkpoints：默认，Flink在有一个checkpoint在执行的时候不会触发另一次checkpoint。但如果非要做，比如对于处理有延迟的流水线操作而言，又希望能够高频的进行checkpoint，则可以更改这个值。如果设置了minimum time between checkpoints，就不要设置这个值。
5、externalized checkpoints：externalized checkpoints将元数据也会写入持久化存储，并且在作业失败的时候不会自动清除数据。这样，你就获得了作业失败之后的一个恢复点。
6、fail/continue task on checkpoint errors：这个值规定当某次checkpoint执行失败的时候，task是否要被认为是执行失败。Flink默认checkpoint失败则task处理失败。但是你可以改，如果改了，那么checkpoint失败的时候，task还会继续运行，只是会告诉checkpoint协调器这次checkpoint失败了。
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
// 每1000毫秒启动一个检查点
env.enableCheckpointing(1000);
// advanced options:
// 将模式设置为exactly-once(这是默认值)
env.getCheckpointConfig().setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE);
// 确保500毫秒的进程发生在检查点之间
env.getCheckpointConfig().setMinPauseBetweenCheckpoints(500);
// 检查点必须在一分钟内完成，否则将被丢弃
env.getCheckpointConfig().setCheckpointTimeout(60000);
// 只允许一个检查点同时进行
env.getCheckpointConfig().setMaxConcurrentCheckpoints(1);
// 启用在作业取消后保留的外部检查点
env.getCheckpointConfig().enableExternalizedCheckpoints(ExternalizedCheckpointCleanup.RETAIN_ON_CANCELLATION);
与 Key 无关的 State，与 Operator 绑定的 state，整个 operator 只对应一个 state。
保存 state 的数据结构：
ListState
举例来说，Flink 中的 Kafka Connector，就使用了 operator state。它会在每个 connector 实例中，保存该实例中消费 topic 的所有(partition, offset)映射。
步骤：
- 获取执行环境
- 设置检查点机制：路径，重启策略
- 自定义数据源
- 需要继承并行数据源和 CheckpointedFunction
- 设置 listState,通过上下文对象 context 获取
- 数据处理，保留 offset
- 制作快照
- 数据打印
- 触发执行
示例代码：
import java.util
import org.apache.flink.api.common.restartstrategy.RestartStrategies
import org.apache.flink.api.common.state.{ListState, ListStateDescriptor}
import org.apache.flink.api.common.time.Time
import org.apache.flink.api.common.typeinfo.{TypeHint, TypeInformation}
import org.apache.flink.runtime.state.{FunctionInitializationContext, FunctionSnapshotContext}
import org.apache.flink.runtime.state.filesystem.FsStateBackend
import org.apache.flink.streaming.api.CheckpointingMode
import org.apache.flink.streaming.api.checkpoint.CheckpointedFunction
import org.apache.flink.streaming.api.environment.CheckpointConfig
import org.apache.flink.streaming.api.functions.source.{RichParallelSourceFunction, SourceFunction}
import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment
import org.apache.flink.streaming.api.scala._
object ListOperate {
def main(args: Array[String]): Unit = {
val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
//Flink默认不启用Checkpointing。如果要启用，可以在StreamExecutionEnvironment上调用 enableCheckpointing(n)，其中n是以毫秒为单位的checkpoint间隔
env.setParallelism(1)
env.enableCheckpointing(5000)
/*Flink一共提供了三种StateBackend
1.MemoryStateBackend(基于内存存储)
2.FsStateBackend(基于文件系统存储)
3.RocksDBStateBackend(基于RocksDB数据库存储)
**/
env.setStateBackend(new FsStateBackend("hdfs://node01:8020/tmp/check/8"))
env.getCheckpointConfig.setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE)
env.getCheckpointConfig.setMaxConcurrentCheckpoints(1)
env.getCheckpointConfig.setCheckpointTimeout(60000)
env.getCheckpointConfig.setFailOnCheckpointingErrors(false)
env.getCheckpointConfig.enableExternalizedCheckpoints(CheckpointConfig.ExternalizedCheckpointCleanup.RETAIN_ON_CANCELLATION)
//重启策略
env.setRestartStrategy(RestartStrategies.failureRateRestart(3, Time.minutes(1), Time.seconds(5)))
//模拟kakfa偏移量
env.addSource(new MyRichParrelSourceFun)
.print()
env.execute()
}
}
class MyRichParrelSourceFun extends RichParallelSourceFunction[String]
with CheckpointedFunction {
var listState: ListState[Long] = _
var offset: Long = 0L
//任务运行
override def run(ctx: SourceFunction.SourceContext[String]): Unit = {
val iterState: util.Iterator[Long] = listState.get().iterator()
while (iterState.hasNext) {
offset = iterState.next()
}
while (true) {
offset += 1
ctx.collect("offset:"+offset)
Thread.sleep(1000)
if(offset > 10){
1/0
}
}
}
//取消任务
override def cancel(): Unit = ???
//制作快照
override def snapshotState(context: FunctionSnapshotContext): Unit = {
listState.clear()
listState.add(offset)
}
//初始化状态
override def initializeState(context: FunctionInitializationContext): Unit = {
listState = context.getOperatorStateStore.getListState(new ListStateDescriptor[Long](
"listState", TypeInformation.of(new TypeHint[Long] {})
))
}
}
#3. Broadcast State
Broadcast State 是 Flink 1.5 引入的新特性。在开发过程中，如果遇到需要下发/广播配置、规则等低吞吐事件流到下游所有 task 时，就可以使用 Broadcast State 特性。下游的 task 接收这些配置、规则并保存为 BroadcastState, 将这些配置应用到另一个数据流的计算中 。
#1) API 介绍
通常，我们首先会创建一个 Keyed 或 Non-Keyed 的 Data Stream，然后再创建一个 Broadcasted Stream，最后通过 Data Stream 来连接（调用 connect 方法）到 Broadcasted Stream 上，这样实现将 Broadcast State 广播到 Data Stream 下游的每个 Task 中。
如果 Data Stream 是 Keyed Stream，则连接到 Broadcasted Stream 后，添加处理 ProcessFunction 时需要使用 KeyedBroadcastProcessFunction 来实现，下面是 KeyedBroadcastProcessFunction 的 API，代码如下所示：
public abstract class KeyedBroadcastProcessFunction<KS, IN1, IN2, OUT> extends BaseBroadcastProcessFunction {
public abstract void processElement(final IN1 value, final ReadOnlyContext ctx, final Collector<OUT> out) throws Exception;
public abstract void processBroadcastElement(final IN2 value, final Context ctx, final Collector<OUT> out) throws Exception;
}
上面泛型中的各个参数的含义，说明如下：
- KS：表示 Flink 程序从最上游的 Source Operator 开始构建 Stream，当调用 keyBy 时所依赖的 Key 的类型；
- IN1：表示非 Broadcast 的 Data Stream 中的数据记录的类型；
- IN2：表示 Broadcast Stream 中的数据记录的类型；
- OUT：表示经过 KeyedBroadcastProcessFunction 的 processElement()和 processBroadcastElement()方法处理后输出结果数据记录的类型。
如果 Data Stream 是 Non-Keyed Stream，则连接到 Broadcasted Stream 后，添加处理 ProcessFunction 时需要使用 BroadcastProcessFunction 来实现，下面是 BroadcastProcessFunction 的 API，代码如下所示：
public abstract class BroadcastProcessFunction<IN1, IN2, OUT> extends BaseBroadcastProcessFunction {
public abstract void processElement(final IN1 value, final ReadOnlyContext ctx, final Collector<OUT> out) throws Exception;
public abstract void processBroadcastElement(final IN2 value, final Context ctx, final Collector<OUT> out) throws Exception;
}
上面泛型中的各个参数的含义，与前面 KeyedBroadcastProcessFunction 的泛型类型中的后 3 个含义相同，只是没有调用 keyBy 操作对原始 Stream 进行分区操作，就不需要 KS 泛型参数。
注意事项：
- Broadcast State 是 Map 类型，即 K-V 类型。
- Broadcast State 只有在广播一侧的方法中 processBroadcastElement 可以修改;在非广播一侧方法中 processElement 只读。
- Broadcast State 在运行时保存在内存中。
#2) 场景举例
- 动态更新计算规则: 如事件流需要根据最新的规则进行计算，则可将规则作为广播状态广播到下游 Task 中。
- 实时增加额外字段: 如事件流需要实时增加用户的基础信息，则可将用户的基础信息作为广播状态广播到下游 Task 中。