• 大数据面试题：Flink延迟数据是怎么解决的

    最近朋友面试某猪的时候，被问到一个问题答得面试官不太满意，问的是前司数据延迟问题是怎么解决的，我稍作整理。

    一、什么是延迟数据

    大数据处理过程中 Join 的场景太多太多了，几乎所有公司的 APP 都会涉及到两条流数据之间的维度拼接，将表变宽等场景，避免不了进行多流 Join 操作。同时join场景中受网络或物理设备等因素影响也有可能，以致出现不同的流式数据到达计算引擎的时间不一定，那这些数据称为延迟数据。即延迟数据是指系统的事件时间戳在经过延迟元素时间戳之后的时间到达的数据。所以延迟数据可以说是一种特殊的乱序数据，它没有被watermark和Window机制处理，因为是在窗口关闭后才到达的数据。一般这种情况有三种处理办法：

    • 重新激活已经关闭的窗口并重新计算以修正结果。

    • 将迟到数据收集起来另外处理。

    • 将迟到数据直接丢弃。

    Flink默认采用第三种方法，将迟到数据直接丢弃。接下来我们演示一个延迟数据案例，之后使用Flink提供的waterMark、allowedLateness机制、sideOutput机制解决延迟数据的场景。

    二、Flink延迟数据场景

    这里是模拟将两个Socket流使用事件时间进行5秒滚动窗口Left Outer join后，延迟数据被丢失的场景，延迟数据没有被正常输出。

    1. 代码

    1. object MyCoGroupJoin {
    2.  
    3. def main(args: Array[String]): Unit = {
    4.  
    5. // 创建环境变量
    6.  
    7. val env = StreamExecutionEnvironment.getExecutionEnvironment
    8.  
    9. // 指定事件时间
    10.  
    11. env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    12.  
    13. // 创建Socket源数据流，内容格式 "时间戳 单词"
    14.  
    15. val s1 = env.socketTextStream("hadoop52", 9999)
    16.  
    17. // 设置事件时间戳字段
    18.  
    19. .assignAscendingTimestamps(_.split(" ")(0).toLong)
    20.  
    21. .map(line => {
    22.  
    23. val strs = line.split(" ")
    24.  
    25. (strs(0).toLong, strs(1))
    26.  
    27. })
    28.  
    29. // 创建Socket源数据流，内容格式 "时间戳 单词"
    30.  
    31. val s2 = env.socketTextStream("hadoop52", 8888)
    32.  
    33. // 设置事件时间戳字段
    34.  
    35. .assignAscendingTimestamps(_.split(" ")(0).toLong)
    36.  
    37. .map(line => {
    38.  
    39. val strs = line.split(" ")
    40.  
    41. (strs(0).toLong, strs(1))
    42.  
    43. })
    44.  
    45. //将两个数据流进行合并统计，这里是将两数据流利用窗口进行单词拼串处理
    46.  
    47. s1.coGroup(s2)
    48.  
    49. .where(_._2)
    50.  
    51. .equalTo(_._2)
    52.  
    53. .window(TumblingEventTimeWindows.of(Time.seconds(5))) //滚动窗口，窗口大小5秒
    54.  
    55. .apply(new CoGroupFunction[(Long, String), (Long, String), String] {
    56.  
    57. override def coGroup(first: lang.Iterable[(Long, String)], second: lang.Iterable[(Long, String)], out: Collector[String]): Unit = {
    58.  
    59. // 对两数据流中的数据进行循环遍历，并拼串下发
    60.  
    61. first.forEach(r1 => {
    62.  
    63. second.forEach(r2 => {
    64.  
    65. println(s"${r1}::${r2}")
    66.  
    67. val str = r1._2 + r2._2
    68.  
    69. out.collect(str)
    70.  
    71. })
    72.  
    73. })
    74.  
    75. }
    76.  
    77. })
    78.  
    79. .print()
    80.  
    81. env.execute("cogroupjoin")
    82.  
    83. }
    84.  
    85. }

    2. Socket数据源1

    [atguigu@hadoop52 ~]$ nc -l 9999

    1001000 hello

    1005000 java

    1003000 hello [这条被丢弃了]

    1010000 xixi

    3. Socket数据源2

    [atguigu@hadoop52 ~]$ nc -l 8888

    1002000 hello

    1005000 java

    1001000 hello [这条被丢弃了]

    1010000 xixi

    4. 程序执行控制台输出结果

    (1001000,hello)::(1002000,hello)

    4> hellohello

    (1005000,java)::(1005000,java)

    2> javajava

    我们发现在Socket数据源输入 "1005000 java" 后，会统计1005000时间戳之前的数据，而在1005000时间戳之后输入的hello就没有被统计输出。当输入 "1010000 xixi" 后，触发了第2个窗口，只输出了java，还是没有后输入的hello统计结果，这也更明确了1005000时间戳之后输入的hello被丢弃了。数据很重要，不想丢弃怎么办，我们可以使用Flink提供的水印位(waterMark)解决。

    三、解决方案之waterMark

    watermark是flink为了处理event time窗口计算提出的一种机制，本质上就是一个时间戳，代表着比这个时间早的事件已经全部进入到相应的窗口，后续不会再有比这个时间小的事件出现，基于这个前提我们才有可能将event time窗口视为完整并触发窗口的计算。

    1. 程序代码

    1. object MyCoGroupJoin {
    2.  
    3. def main(args: Array[String]): Unit = {
    4.  
    5. // 创建环境变量
    6.  
    7. val env = StreamExecutionEnvironment.getExecutionEnvironment
    8.  
    9. // 指定事件时间
    10.  
    11. env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    12.  
    13. // 创建Socket源数据流，内容格式 "时间戳 单词"
    14.  
    15. val s1 = env.socketTextStream("hadoop52", 9999)
    16.  
    17. // 设置事件时间戳字段
    18.  
    19. // .assignAscendingTimestamps(_.split(" ")(0).toLong)
    20.  
    21. // 这里可以指定周期性产生WaterMark 或 间歇性产生WaterMark，分别使用AssignerWithPeriodicWatermarks和AssignerWithPunctuatedWatermarks来实现
    22.  
    23. // 这里使用周期性产生WaterMark,延长2秒
    24.  
    25. .assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[String](Time.seconds(2)) {
    26.  
    27. override def extractTimestamp(element: String): Long = {
    28.  
    29. val strs = element.split(" ")
    30.  
    31. strs(0).toLong
    32.  
    33. }
    34.  
    35. })
    36.  
    37. .map(line => {
    38.  
    39. val strs = line.split(" ")
    40.  
    41. (strs(0).toLong, strs(1))
    42.  
    43. })
    44.  
    45. // 创建Socket源数据流，内容格式 "时间戳 单词"
    46.  
    47. val s2 = env.socketTextStream("hadoop52", 8888)
    48.  
    49. // 设置事件时间戳字段
    50.  
    51. // .assignAscendingTimestamps(_.split(" ")(0).toLong)
    52.  
    53. // 这里可以指定周期性产生WaterMark 或 间歇性产生WaterMark，分别使用AssignerWithPeriodicWatermarks和AssignerWithPunctuatedWatermarks来实现
    54.  
    55. // 这里使用周期性产生WaterMark,延长2秒
    56.  
    57. .assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[String](Time.seconds(2)) {
    58.  
    59. override def extractTimestamp(element: String): Long = {
    60.  
    61. val strs = element.split(" ")
    62.  
    63. strs(0).toLong
    64.  
    65. }
    66.  
    67. })
    68.  
    69. .map(line => {
    70.  
    71. val strs = line.split(" ")
    72.  
    73. (strs(0).toLong, strs(1))
    74.  
    75. })
    76.  
    77. //将两个数据流进行合并统计，这里是将两数据流利用窗口进行单词拼串处理
    78.  
    79. s1.coGroup(s2)
    80.  
    81. .where(_._2)
    82.  
    83. .equalTo(_._2)
    84.  
    85. .window(TumblingEventTimeWindows.of(Time.seconds(5))) //滚动窗口，窗口大小5秒
    86.  
    87. .apply(new CoGroupFunction[(Long, String), (Long, String), String] {
    88.  
    89. override def coGroup(first: lang.Iterable[(Long, String)], second: lang.Iterable[(Long, String)], out: Collector[String]): Unit = {
    90.  
    91. // 对两数据流中的数据进行循环遍历，并拼串下发
    92.  
    93. first.forEach(r1 => {
    94.  
    95. second.forEach(r2 => {
    96.  
    97. println(s"${r1}::${r2}")
    98.  
    99. val str = r1._2 + r2._2
    100.  
    101. out.collect(str)
    102.  
    103. })
    104.  
    105. })
    106.  
    107. }
    108.  
    109. })
    110.  
    111. .print()
    112.  
    113. env.execute("cogroupjoin")
    114.  
    115. }
    116.  
    117. }

    2. Socket数据源1

    [atguigu@hadoop52 ~]$ nc -l 9999

    1001000 hello

    1005000 java

    1003000 hello

    1007000 java

    3. Socket数据源2

    [atguigu@hadoop52 ~]$ nc -l 8888

    1002000 hello

    1005000 java

    1001000 hello

    1007000 java

    4. 程序执行控制台输出结果

    (1001000,hello)::(1002000,hello)

    4> hellohello

    (1001000,hello)::(1001000,hello)

    4> hellohello

    (1003000,hello)::(1002000,hello)

    4> hellohello

    (1003000,hello)::(1001000,hello)

    4> hellohello

    当我们使用WaterMark后，我们可以发现在两个Socket终端输入"1005000 java"时，控制台并没有立刻统计输出信息。而是在两个Socket终端输入 "1007000 java"

    后，控制台才将统计结果输出出来且在时间戳"1005000"之后输入的hello也同时给统计出来了，上面的问题可以解决了，但是 "1007000 java" 之后我们再输入 hello ，你会发现还是存在问题，没有输出又给丢弃了。继续测试如下。

    5. Socket数据源1

    [atguigu@hadoop52 ~]$ nc -l 9999

    1001000 hello

    1005000 java

    1003000 hello

    1007000 java

    1003000 hello

    1012000 spark

    6. Socket数据源2

    [atguigu@hadoop52 ~]$ nc -l 8888

    1002000 hello

    1005000 java

    1001000 hello

    1007000 java

    1004000 hello

    1012000 spark

    7. 程序执行控制台输出结果

    (1001000,hello)::(1002000,hello)

    4> hellohello

    (1001000,hello)::(1001000,hello)

    4> hellohello

    (1003000,hello)::(1002000,hello)

    4> hellohello

    (1003000,hello)::(1001000,hello)

    4> hellohello

    (1005000,java)::(1005000,java)

    2> javajava

    (1005000,java)::(1007000,java)

    2> javajava

    (1007000,java)::(1005000,java)

    2> javajava

    (1007000,java)::(1007000,java)

    2> javajava

    所以waterMark只能在一定程度上解决这种问题。我们再来看看allowedLateness机制。

    四、解决方案之allowedLateness机制

    默认情况下，当watermark通过end-of-window之后，再有之前的数据到达时，这些数据会被丢弃。为了避免有些迟到的数据被丢弃，因此产生了allowedLateness机制。简单来讲，allowedLateness就是针对event time而言，对于watermark超过end-of-window之后还允许有一段时间（也是以event time来衡量）来等待之后的数据到达，以便再次处理这些数据。

    1. 程序代码

    1. object MyCoGroupJoin {
    2.  
    3. def main(args: Array[String]): Unit = {
    4.  
    5. // 创建环境变量
    6.  
    7. val env = StreamExecutionEnvironment.getExecutionEnvironment
    8.  
    9. // 指定事件时间
    10.  
    11. env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    12.  
    13. // 创建Socket源数据流，内容格式 "时间戳 单词"
    14.  
    15. val s1 = env.socketTextStream("hadoop52", 9999)
    16.  
    17. // 设置事件时间戳字段
    18.  
    19. // .assignAscendingTimestamps(_.split(" ")(0).toLong)
    20.  
    21. // 这里可以指定周期性产生WaterMark 或 间歇性产生WaterMark，分别使用AssignerWithPeriodicWatermarks和AssignerWithPunctuatedWatermarks来实现
    22.  
    23. // 这里使用周期性产生WaterMark,延长2秒
    24.  
    25. .assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[String](Time.seconds(2)) {
    26.  
    27. override def extractTimestamp(element: String): Long = {
    28.  
    29. val strs = element.split(" ")
    30.  
    31. strs(0).toLong
    32.  
    33. }
    34.  
    35. })
    36.  
    37. .map(line => {
    38.  
    39. val strs = line.split(" ")
    40.  
    41. (strs(0).toLong, strs(1))
    42.  
    43. })
    44.  
    45. // 创建Socket源数据流，内容格式 "时间戳 单词"
    46.  
    47. val s2 = env.socketTextStream("hadoop52", 8888)
    48.  
    49. // 设置事件时间戳字段
    50.  
    51. // .assignAscendingTimestamps(_.split(" ")(0).toLong)
    52.  
    53. // 这里可以指定周期性产生WaterMark 或 间歇性产生WaterMark，分别使用AssignerWithPeriodicWatermarks和AssignerWithPunctuatedWatermarks来实现
    54.  
    55. // 这里使用周期性产生WaterMark,延长2秒
    56.  
    57. .assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[String](Time.seconds(2)) {
    58.  
    59. override def extractTimestamp(element: String): Long = {
    60.  
    61. val strs = element.split(" ")
    62.  
    63. strs(0).toLong
    64.  
    65. }
    66.  
    67. })
    68.  
    69. .map(line => {
    70.  
    71. val strs = line.split(" ")
    72.  
    73. (strs(0).toLong, strs(1))
    74.  
    75. })
    76.  
    77. //将两个数据流进行合并统计，这里是将两数据流利用窗口进行单词拼串处理
    78.  
    79. s1.coGroup(s2)
    80.  
    81. .where(_._2)
    82.  
    83. .equalTo(_._2)
    84.  
    85. .window(TumblingEventTimeWindows.of(Time.seconds(5))) //滚动窗口，窗口大小5秒
    86.  
    87. // 允许数据迟到2秒，窗口触发后2秒内过来的数据还可以重新被计算
    88.  
    89. .allowedLateness(Time.seconds(2))
    90.  
    91. .apply(new CoGroupFunction[(Long, String), (Long, String), String] {
    92.  
    93. override def coGroup(first: lang.Iterable[(Long, String)], second: lang.Iterable[(Long, String)], out: Collector[String]): Unit = {
    94.  
    95. // 对两数据流中的数据进行循环遍历，并拼串下发first.forEach(r1 => {
    96.  
    97. second.forEach(r2 => {
    98.  
    99. println(s"${r1}::${r2}")
    100.  
    101. val str = r1._2 + r2._2
    102.  
    103. out.collect(str)
    104.  
    105. })
    106.  
    107. })
    108.  
    109. }
    110.  
    111. })
    112.  
    113. .print()
    114.  
    115. env.execute("cogroupjoin")
    116.  
    117. }
    118.  
    119. }

    2. Socket数据源1

    [atguigu@hadoop52 ~]$ nc -l 9999

    1001000 hello

    1007000 java

    3. Socket数据源2

    [atguigu@hadoop52 ~]$ nc -l 8888

    1002000 hello

    1007000 java

    1003000 hello

    4. 程序执行控制台输出结果

    (1001000,hello)::(1002000,hello)

    4> hellohello

    (1001000,hello)::(1002000,hello)

    4> hellohello

    (1001000,hello)::(1003000,hello)

    4> hellohello

    到这里估计有朋友又有疑问了，allowedLateness机制解决数据延迟设置的时间段，那之后再来的延迟数据呢，还是被丢弃了并没有彻底解决问题。别慌，针对allowedLateness机制之后来的延迟数据Flink还提供了另一种方案就是sideOutput机制。

    五、解决方案之sideOutput机制

    Side Output简单来说就是在程序执行过程中,将主流stream流中的不同的业务类型或者不同条件的数据分别输出到不同的地方。如果我们想对没能及时在Flink窗口计算的延迟数据专门处理，也就是窗口已经计算了，但后面才来的数据专门处理，我们可以使用旁路输出到侧流中去处理。

    1. 程序代码

    1. object MyCoGroupJoin {
    2.  
    3. def main(args: Array[String]): Unit = {
    4.  
    5. // 创建环境变量
    6.  
    7. val env = StreamExecutionEnvironment.getExecutionEnvironment
    8.  
    9. // 指定事件时间
    10.  
    11. env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    12.  
    13. // 创建Socket源数据流，内容格式 "时间戳 单词"
    14.  
    15. val s1 = env.socketTextStream("hadoop52", 9999)
    16.  
    17. // 这里可以指定周期性产生WaterMark 或 间歇性产生WaterMark，分别使用AssignerWithPeriodicWatermarks和AssignerWithPunctuatedWatermarks来实现
    18.  
    19. // 这里使用周期性产生WaterMark,延长2秒
    20. .assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[String](Time.seconds(2)) {
    21.  
    22. override def extractTimestamp(element: String): Long = {
    23.  
    24. val strs = element.split(" ")
    25.  
    26. strs(0).toLong
    27.  
    28. }
    29.  
    30. })
    31.  
    32. .map(line => {
    33.  
    34. val strs = line.split(" ")
    35.  
    36. (strs(0).toLong, strs(1))
    37.  
    38. })
    39.  
    40. // 定义一个侧输出流
    41.  
    42. val lateData: OutputTag[(Long, String)] = new OutputTag[(Long, String)]("late")
    43.  
    44. val s2 = s1.timeWindowAll(Time.seconds(5))
    45.  
    46. //允许迟到2秒数据
    47.  
    48. .allowedLateness(Time.seconds(2))
    49.  
    50. //迟到长于2秒的数据将被保存到lateData侧数据流中
    51.  
    52. .sideOutputLateData(lateData)
    53.  
    54. .process(new ProcessAllWindowFunction[(Long, String), (Long, String), TimeWindow] {
    55.  
    56. override def process(context: Context, elements: Iterable[(Long, String)], out: Collector[(Long, String)]): Unit = {
    57.  
    58. elements.foreach(ele => {
    59.  
    60. out.collect(ele)
    61.  
    62. })
    63.  
    64. }
    65.  
    66. })
    67.  
    68. s2.print("主流")
    69.  
    70. s2.getSideOutput(lateData).print("侧流")
    71.  
    72. env.execute("cogroupjoin")
    73.  
    74. }
    75.  
    76. }

    2. Socket数据源

    [atguigu@hadoop52 ~]$ nc -l 9999

    1001000 hello

    1005000 java

    1007000 python

    1002000 hello

    1009000 java

    1001000 xixi

    1002000 haha

    3. 程序执行控制台输出结果

    主流:10> (1001000,hello)

    主流:11> (1001000,hello)

    主流:12> (1002000,hello)

    侧流:1> (1001000,xixi)

    侧流:2> (1002000,haha)

    通过上面测试可以发现晚于allowedLateness机制的延迟数据，Flink没有丢弃而是输出到了侧输出流中等待处理了，这样延迟数据就完美解决了。

    六、总结

    sideOutput机制可以将迟到事件单独放入一个数据流分支，这会作为 window 计算结果的副产品，以便用户获取并对其进行特殊处理。

    allowedLateness机制允许用户设置一个允许的最大迟到时长。Flink 会在窗口关闭后一直保存窗口的状态直至超过允许迟到时长，这期间的迟到事件不会被丢弃，而是默认会触发窗口重新计算。

  • 相关阅读:
    前端实现类似公告的无缝横向滚动
    埃及市场开发攻略，收藏一篇就够了
    浅谈如何学习网络编程
    大数据的崭露头角：数据湖与数据仓库的融合之道
    Integritee通过XCM集成至Moonriver，为其生态系统带来企业级隐私解决方案
    六级作文---3.图画类
    rk3568 SDK的buildroot添加package
    数据结构-栈
    分布式事务解决方案
    ElasticSearch系列——分词器
  • 原文地址：https://blog.csdn.net/weixin_51981189/article/details/133164539