深入浅出Flink 09 之 WaterMark

最新推荐文章于 2022-01-30 14:48:47 发布
最新推荐文章于 2022-01-30 14:48:47 发布
阅读量140 收藏 1
点赞数
分类专栏： Flink 文章标签： flink
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40503579/article/details/118708595
版权

Flink 09 之 WaterMark

1 需求背景

需求描述：每隔5秒，计算最近10秒单词出现的次数。
在这里插入图片描述

1.1 TimeWindow实现

/*** 每隔5秒计算最近10秒单词出现的次数 */
 public class TimeWindowWordCount { 
 public static void main(String[] args) throws Exception{ 
 StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); 
 DataStreamSource<String> dataStream = env.socketTextStream("localhost", 8888); SingleOutputStreamOperator<Tuple2<String, Integer>> result = dataStream.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() {
@Override public void flatMap(String line, Collector<Tuple2<String, Integer>> out) throws Exception { 
String[] fields = line.split(","); 
for (String word : fields) { 
	out.collect(new Tuple2<>(word, 1)); 
	} 
} }).keyBy(0) .timeWindow(Time.seconds(10), Time.seconds(5))
 .sum(1);
	result.print().setParallelism(1); 
	env.execute("TimeWindowWordCount"); 
	}
 }

1.2 ProcessWindowFunction

/*** 每隔5秒计算最近10秒单词出现的次数 */
 public class TimeWindowWordCount {
  public static void main(String[] args) throws Exception{ 
  StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); 
  DataStreamSource<String> dataStream = env.socketTextStream("hadoop1", 8888); 
  SingleOutputStreamOperator<Tuple2<String, Integer>> result = dataStream.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() { 
  @Override public void flatMap(String line, Collector<Tuple2<String, Integer>> out) throws Exception { 
  String[] fields = line.split(","); 
  for (String word : fields) { 
 	 out.collect(new Tuple2<>(word, 1)); 
		  } 
  		}
   }).keyBy(0)
   .timeWindow(Time.seconds(10), Time.seconds(5))
   		 .process(new SumProcessWindowFunction()); 
   		 result.print().setParallelism(1); 
    	 env.execute("TimeWindowWordCount");
   }
/**
* IN, OUT, KEY, W 
* IN：输入的数据类型
* OUT：输出的数据类型 
* Key：key的数据类型（在Flink里面，String用Tuple表示） 
* W：Window的数据类型
*/ 
public static class SumProcessWindowFunction extends ProcessWindowFunction<Tuple2<String,Integer>,Tuple2<String,Integer>,Tuple,TimeW indow> {
FastDateFormat dataFormat = FastDateFormat.getInstance("HH:mm:ss"); 
/*** 当一个window触发计算的时候会调用这个方法
 * @param tuple key 
 * @param context operator的上下文 
 * @param elements 指定window的所有元素 
 * @param out 用户输出 */
  @Override public void process(Tuple tuple, Context context, Iterable<Tuple2<String, Integer>> elements, Collector<Tuple2<String, Integer>> out) { 
  System.out.println("当天系统的时 间："+dataFormat.format(System.currentTimeMillis()));
   System.out.println("Window的处理时 间："+dataFormat.format(context.currentProcessingTime())); 
   System.out.println("Window的开始时 间："+dataFormat.format(context.window().getStart())); 
   System.out.println("Window的结束时 间："+dataFormat.format(context.window().getEnd())); 
   int sum = 0; 
   for (Tuple2<String, Integer> ele : elements) { 
 		  sum += 1;
    }
    // 输出单词出现的次数 
    out.collect(Tuple2.of(tuple.getField(0), sum)); 
 		  	 } 
 		  }
    }

先输入：
hive
然后输入hive,hbase
输出结果：

当天系统的时间：15:10:30
 Window的处理时间：15:10:30 
 Window的开始时间：15:10:20 
 Window的结束时间：15:10:30 
 (hive,1) 
 当天系统的时间：15:10:35 
 Window的处理时间：15:10:35 
 Window的开始时间：15:10:25 
 Window的结束时间：15:10:35 
 当天系统的时间：15:10:35
Window的处理时间：15:10:35 
Window的开始时间：15:10:25 
Window的结束时间：15:10:35 
(hbase,1) 
(hive,1)

根据每隔5秒执行最近10秒的数据，Flink划分的窗口
[00:00:00, 00:00:05) [00:00:05, 00:00:10) [00:00:10, 00:00:15) [00:00:15, 00:00:20) [00:00:20, 00:00:25) [00:00:25, 00:00:30) [00:00:30, 00:00:35) [00:00:35, 00:00:40) [00:00:40, 00:00:45) [00:00:45, 00:00:50) [00:00:50, 00:00:55) [00:00:55, 00:01:00) [00:01:00, 00:01:05) …

1.3 Time的种类

针对stream数据中的时间，可以分为以下三种：
日志数据：
Event Time：事件产生的时间，它通常由事件中的时间戳描述。
Ingestion time：事件进入Flink的时间(一般不用)
Processing Time：事件被处理时当前系统的时间
在这里插入图片描述
案例演示：
原始日志如下

2020-11-11 10:00:01,134 INFO executor.Executor: Finished task in state 0.0

这条数据进入Flink的时间是2020-11-11 20:00:00,102
到达window处理的时间为2020-11-11 20:00:01,100
2020-11-11 10:00:01,134 是Event time
2020-11-11 20:00:00,102 是Ingestion time
2020-11-11 20:00:01,100 是Processing time
思考：
如果我们想要统计每分钟内接口调用失败的错误日志个数，使用哪个时间才有意义？

2 Process Time Window（有序）

需求：每隔5秒计算最近10秒的单词出现的次数（接口调用出错的次数）
自定义source，模拟：第 13 秒的时候连续发送 2 个事件，第 16 秒的时候再发送 1 个事件
在这里插入图片描述

/*** 每隔5秒计算最近10秒单词出现的次数 */ 
public class TimeWindowWordCount { 
public static void main(String[] args) throws Exception{ 
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); 

env.setParallelism(1); DataStreamSource<String> dataStream = env.addSource(new TestSouce()); 

SingleOutputStreamOperator<Tuple2<String, Integer>> result = dataStream.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() { 
@Override public void flatMap(String line, Collector<Tuple2<String, Integer>> out) throws Exception { 
String[] fields = line.split(","); 
for (String word : fields) { 
	out.collect(new Tuple2<>(word, 1));
 		} 
	 } 
 }).keyBy(0)
	.timeWindow(Time.seconds(10), Time.seconds(5))
	 .process(new SumProcessWindowFunction()); 
		 result.print().setParallelism(1); 
 		env.execute("TimeWindowWordCount"); 
 }
public static class TestSouce implements SourceFunction<String>{
 FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss");
  @Override public void run(SourceContext<String> ctx) throws Exception { 
  // 控制大约在 10 秒的倍数的时间点发送事件
String currTime = String.valueOf(System.currentTimeMillis()); 
while (Integer.valueOf(currTime.substring(currTime.length() - 4)) > 100) { 
currTime = String.valueOf(System.currentTimeMillis()); continue; 
}System.out.println("开始发送事件的时间：" + 	dateFormat.format(System.currentTimeMillis())); 
// 第 13 秒发送两个事件 
	TimeUnit.SECONDS.sleep(13);
	 ctx.collect("hadoop," + System.currentTimeMillis()); 
 // 产生了一个事件，但是由于网络原因，事件没有发送 
 	ctx.collect("hadoop," + System.currentTimeMillis()); 
 // 第 16 秒发送一个事件 
 	TimeUnit.SECONDS.sleep(3); ctx.collect("hadoop," + System.currentTimeMillis()); 
 	TimeUnit.SECONDS.sleep(300);
}	
@Override public void cancel() {
	 } 
}
/**
* IN, OUT, KEY, W
* IN：输入的数据类型 
* OUT：输出的数据类型 
* Key：key的数据类型（在Flink里面，String用Tuple表示） 
* W：Window的数据类型 */ 
* public static class SumProcessWindowFunction extends ProcessWindowFunction<Tuple2<String,Integer>,Tuple2<String,Integer>,Tuple,TimeW indow> {
FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss");
 /**
 * 当一个window触发计算的时候会调用这个方法 
 * @param tuple key 
 * @param context operator的上下文
  * @param elements 指定window的所有元素 
  * @param out 用户输出 */ 
  @Override
public void process(Tuple tuple, Context context, Iterable<Tuple2<String, Integer>> elements, Collector<Tuple2<String, Integer>> out) {
 // System.out.println("当天系统的时 间："+dateFormat.format(System.currentTimeMillis())); //
 // System.out.println("Window的处理时 间："+dateFormat.format(context.currentProcessingTime())); 
 // System.out.println("Window的开始时 间："+dateFormat.format(context.window().getStart()));
// System.out.println("Window的结束时 间："+dateFormat.format(context.window().getEnd()));
 int sum = 0; for (Tuple2<String, Integer> ele : elements) { 
 		sum += 1; 
	 }
 // 输出单词出现的次数 
 out.collect(Tuple2.of(tuple.getField(0), sum)); 
		 }
	  }
   }

输出结果：
开始发送事件的时间：16:16:40
(hadoop,2)
(hadoop,3)
(hadoop,1)
在这里插入图片描述

3 Process Time Window（无序）

接口的调用失败的次数（时间段）
自定义source，模拟：正常情况下第 13 秒的时候连续发送 2 个事件，但是有一个事件确实在第13秒的
发送出去了，另外一个事件因为某种原因在19秒的时候才发送出去，第 16 秒的时候再发送 1 个事件

/*** 每隔5秒计算最近10秒单词出现的次数 */ 
public class TimeWindowWordCount { public static void main(String[] args) throws Exception{ 
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); 
env.setParallelism(1); 
DataStreamSource<String> dataStream = env.addSource(new TestSouce()); 
SingleOutputStreamOperator<Tuple2<String, Integer>> result = dataStream.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() { @Override
public void flatMap(String line, Collector<Tuple2<String, Integer>> out) throws Exception { 
		String[] fields = line.split(","); 
for (String word : fields) { 
		out.collect(new Tuple2<>(word, 1)); 
		} 
	}
 }).keyBy(0) .timeWindow(Time.seconds(10), Time.seconds(5)) 
 .process(new SumProcessWindowFunction()); 
 result.print().setParallelism(1);
  env.execute("TimeWindowWordCount"); 
 }
/*** 模拟：第 13 秒的时候连续发送 2 个事件，第 16 秒的时候再发送 1 个事件 */ 
public static class TestSouce implements SourceFunction<String>{ 
FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss"); 
@Override public void run(SourceContext<String> ctx) throws Exception { 
		// 控制大约在 10 秒的倍数的时间点发送事件 
		String currTime = String.valueOf(System.currentTimeMillis()); 
while (Integer.valueOf(currTime.substring(currTime.length() - 4)) > 100) {
			 currTime = String.valueOf(System.currentTimeMillis()); 
		 continue;
  }
			  System.out.println("开始发送事件的时间：" + dateFormat.format(System.currentTimeMillis())); 
  // 第 13 秒发送两个事件 
  TimeUnit.SECONDS.sleep(3);
   ctx.collect("hadoop," + System.currentTimeMillis());
// 产生了一个事件，但是由于网络原因，事件没有发送 
		String event = "hadoop," + System.currentTimeMillis(); 
// 第 16 秒发送一个事件 
		TimeUnit.SECONDS.sleep(3); 
		ctx.collect("hadoop," + System.currentTimeMillis()); 
		// 第 19 秒的时候发送 
	TimeUnit.SECONDS.sleep(3); 
			ctx.collect(event); TimeUnit.SECONDS.sleep(300); 
}
@Override public void cancel() { }
}
/**
* IN, OUT, KEY, W 
* IN：输入的数据类型
* OUT：输出的数据类型 
* Key：key的数据类型（在Flink里面，String用Tuple表示） 
* W：Window的数据类型 */
public static class SumProcessWindowFunction extends ProcessWindowFunction<Tuple2<String,Integer>,Tuple2<String,Integer>,Tuple,TimeW indow> {
FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss"); 
/**
* 当一个window触发计算的时候会调用这个方法 
* @param tuple key
* @param context operator的上下文 
* @param elements 指定window的所有元素 
* @param out 用户输出 */ 
* @Override public void process(Tuple tuple, Context context, Iterable<Tuple2<String, Integer>> elements, Collector<Tuple2<String, Integer>> out) {
 // System.out.println("当天系统的时 间："+dateFormat.format(System.currentTimeMillis())); //
 // System.out.println("Window的处理时间："+dateFormat.format(context.currentProcessingTime()));
  // System.out.println("Window的开始时 间："+dateFormat.format(context.window().getStart()));
   // System.out.println("Window的结束时 间："+dateFormat.format(context.window().getEnd()));
   		 int sum = 0; 
    for (Tuple2<String, Integer> ele : elements) { 
    		sum += 1;
     }
     // 输出单词出现的次数
      out.collect(Tuple2.of(tuple.getField(0), sum));
 		  }
	} 
}

处理结果：
开始发送事件的时间：16:18:50
(hadoop,1)
(1573287543001,1)
(1573287543001,1)
(hadoop,3)
(1573287546016,1)
(1573287543016,1)
(1573287546016,1)
(hadoop,2)
(1573287543016,1)

在这里插入图片描述

4 使用Event Time处理无序

使用Event Time处理
/*** 每隔5秒计算最近10秒单词出现的次数 */
 public class TimeWindowWordCount { 
 public static void main(String[] args) throws Exception{ 
 StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); 
 env.setParallelism(1);
  //步骤一：设置时间类型 	env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime); 
  DataStreamSource<String> dataStream = env.addSource(new TestSouce()); dataStream.map(new MapFunction<String, Tuple2<String,Long>>() { 
  @Override public Tuple2<String, Long> map(String line) throws Exception { 
  		String[] fields = line.split(","); 
  		return new Tuple2<>(fields[0],Long.valueOf(fields[1])); }
  //步骤二：获取数据里面的event Time
}).assignTimestampsAndWatermarks(new EventTimeExtractor() ) 
		.keyBy(0) 
		.timeWindow(Time.seconds(10), Time.seconds(5)) 
		.process(new SumProcessWindowFunction()) 
		.print().setParallelism(1); 
		env.execute("TimeWindowWordCount");
 }
public static class TestSouce implements SourceFunction<String>{ 
FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss"); 
@Override public void run(SourceContext<String> ctx) throws Exception {
 // 控制大约在 10 秒的倍数的时间点发送事件 
 String currTime = String.valueOf(System.currentTimeMillis()); 
 while (Integer.valueOf(currTime.substring(currTime.length() - 4)) > 100) {
		currTime = String.valueOf(System.currentTimeMillis()); continue;
 }
 System.out.println("开始发送事件的时间：" + dateFormat.format(System.currentTimeMillis()));
  // 第 13 秒发送两个事件 
  TimeUnit.SECONDS.sleep(13); 
  ctx.collect("hadoop," + System.currentTimeMillis()); 
  // 产生了一个事件，但是由于网络原因，事件没有发送 
  String event = "hadoop," + System.currentTimeMillis();
   // 第 16 秒发送一个事件 
   TimeUnit.SECONDS.sleep(3); 
   ctx.collect("hadoop," + System.currentTimeMillis()); 
   // 第 19 秒的时候发送 
   TimeUnit.SECONDS.sleep(3);
    ctx.collect(event);
	TimeUnit.SECONDS.sleep(300); 
}
@Override public void cancel() { } }
/**
* IN, OUT, KEY, W 
* * IN：输入的数据类型 
* * OUT：输出的数据类型 
* * Key：key的数据类型（在Flink里面，String用Tuple表示） 
* * W：Window的数据类型 */ 
public static class SumProcessWindowFunction extends ProcessWindowFunction<Tuple2<String,Long>,Tuple2<String,Integer>,Tuple,TimeWind ow> { 
FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss");
 /**
 * 当一个window触发计算的时候会调用这个方法
  * @param tuple key 
  * @param context operator的上下文 
  * @param elements 指定window的所有元素 
  * @param out 用户输出 */ 
  @Override
public void process(Tuple tuple, Context context, Iterable<Tuple2<String, Long>> elements, Collector<Tuple2<String, Integer>> out) {
	 // System.out.println("当天系统的时 间："+dateFormat.format(System.currentTimeMillis())); //
 	// System.out.println("Window的处理时 间："+dateFormat.format(context.currentProcessingTime()));
 	 // System.out.println("Window的开始时 间："+dateFormat.format(context.window().getStart()));
	// System.out.println("Window的结束时 间："+dateFormat.format(context.window().getEnd())); 
		int sum = 0; 
	for (Tuple2<String, Long> ele : elements) { 
		sum += 1; 
	}
// 输出单词出现的次数 
	out.collect(Tuple2.of(tuple.getField(0), sum)); 
		}
 }
private static class EventTimeExtractor implements AssignerWithPeriodicWatermarks<Tuple2<String, Long>> { 
FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss"); 
// 拿到每一个事件的 Event Time 
@Override public long extractTimestamp(Tuple2<String, Long> element, long previousElementTimestamp) { 
		return element.f1; 
}
@Nullable 
@Override public Watermark getCurrentWatermark() { 
		return new Watermark(System.currentTimeMillis()); 
		} 
	} 
}

计算结果：
开始发送事件的时间：16:44:10
(hadoop,1)
(hadoop,3)
(hadoop,1)
在这里插入图片描述
现在我们第三个window的结果已经计算准确了，但是我们还是没有彻底的解决问题。接下来就需要我
们使用WaterMark机制来解决了。

5 使用WaterMark机制解决无序

在这里插入图片描述

/*** 每隔5秒计算最近10秒单词出现的次数 */
 public class TimeWindowWordCount { public static void main(String[] args) throws Exception{ 
 StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); 
 env.setParallelism(1);
  //步骤一：设置时间类型 env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime); 
  DataStreamSource<String> dataStream = env.addSource(new TestSouce()); 
  dataStream.map(new MapFunction<String, Tuple2<String,Long>>() { 
  @Override public Tuple2<String, Long> map(String line) throws Exception { 
  		String[] fields = line.split(","); 
 		 return new Tuple2<>(fields[0],Long.valueOf(fields[1]));
   }
 		 //步骤二：获取数据里面的event Time 
  }).assignTimestampsAndWatermarks(new EventTimeExtractor() ) 
  .keyBy(0) 
 		 .timeWindow(Time.seconds(10), Time.seconds(5)) 
  		.process(new SumProcessWindowFunction()) 
  		.print().setParallelism(1); 
		  env.execute("TimeWindowWordCount"); 
  }
  public static class TestSouce implements SourceFunction<String>{ 
  FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss"); 
  @Override public void run(SourceContext<String> ctx) throws Exception { 
  // 控制大约在 10 秒的倍数的时间点发送事件 
  String currTime = String.valueOf(System.currentTimeMillis()); 
  while (Integer.valueOf(currTime.substring(currTime.length() - 4)) > 100) { 
 		 currTime = String.valueOf(System.currentTimeMillis()); 
  		continue;
	}
	System.out.println("开始发送事件的时间：" + dateFormat.format(System.currentTimeMillis())); 
	// 第 13 秒发送两个事件 
			TimeUnit.SECONDS.sleep(13); 
			ctx.collect("hadoop," + System.currentTimeMillis()); 
	// 产生了一个事件，但是由于网络原因，事件没有发送 
			String event = "hadoop," + System.currentTimeMillis(); 
	// 第 16 秒发送一个事件 
			TimeUnit.SECONDS.sleep(3); 
			ctx.collect("hadoop," + System.currentTimeMillis()); 
	// 第 19 秒的时候发送 
			TimeUnit.SECONDS.sleep(3); 
			ctx.collect(event); TimeUnit.SECONDS.sleep(300);
	}
@Override public void cancel() { }
}
/**
* IN, OUT, KEY, W 
* IN：输入的数据类型 
* OUT：输出的数据类型 
* Key：key的数据类型（在Flink里面，String用Tuple表示） 
* W：Window的数据类型 
*/ 
public static class SumProcessWindowFunction extends ProcessWindowFunction<Tuple2<String,Long>,Tuple2<String,Integer>,Tuple,TimeWind ow> { 
FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss"); 
/**
* 当一个window触发计算的时候会调用这个方法 
* @param tuple key 
* @param context operator的上下文 
* @param elements 指定window的所有元素 
* * @param out 用户输出 */
@Override public void process(Tuple tuple, Context context, Iterable<Tuple2<String, Long>> elements, Collector<Tuple2<String, Integer>> out) { 
// System.out.println("当天系统的时 间："+dateFormat.format(System.currentTimeMillis())); //
// System.out.println("Window的处理时 间："+dateFormat.format(context.currentProcessingTime()));
 // System.out.println("Window的开始时 间："+dateFormat.format(context.window().getStart())); 
 // System.out.println("Window的结束时 间："+dateFormat.format(context.window().getEnd()));
		int sum = 0; 
for (Tuple2<String, Long> ele : elements) { 
		sum += 1; 
	}
// 输出单词出现的次数 
out.collect(Tuple2.of(tuple.getField(0), sum)); 
		} 
}
private static class EventTimeExtractor implements AssignerWithPeriodicWatermarks<Tuple2<String, Long>> { 
FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss");
 // 拿到每一个事件的 Event Time 
 @Override public long extractTimestamp(Tuple2<String, Long> element, long previousElementTimestamp) { 
 		return element.f1;
 	 }
 	@Nullable
 	@Override 
 	public Watermark getCurrentWatermark() { 
 			//window延迟5秒触发 
 			return new Watermark(System.currentTimeMillis() - 5000);
 			 } 
 		} 
 }

计算结果：
开始发送事件的时间：16:57:40
(hadoop,2)
(hadoop,3)
(hadoop,1)

海兵-2016
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
深入浅出Flink 10之 WaterMark机制原理
澜水清风的博客
07-14 2717
Flink 10之 WaterMark机制原理1 WaterMark的定义2 需求(深入理解WaterMark)3 计算window的触发时间5 WaterMark+Window 处理乱序时间6 迟到太多的事件7 多并行度下的WaterMark（了解） 1 WaterMark的定义 使用eventTime的时候如何处理乱序数据？ 我们知道，流处理从事件产生，到流经source，再到operator，中间是有一个过程和时间的。虽然大部 分情况下，流到operator的数据都是按照事件产生的时间顺序来的，但是也
【深入浅出flink】第13篇：从源码解读flink中Watermark的周期性和间断式生成方式
雷恩Layne
01-27 1993
我们通常通过DataStream的assignTimestampsAndWatermarks方法引入Watermark，assignTimestampsAndWatermarks方法中要求传入的接口有两种，一种是AssignerWithPeriodicWatermarks（周期性生成Watermark的时间戳分配器），另一中是AssignerWithPunctuatedWatermarks（间断式生成Watermark的时间戳分配器），它们都是TimestampAssigner(时间戳分配器)接口的子接口。
【深入浅出flink】第14篇：kafka分区数与flink算子并行度导致Watermark不触发问题，大多数大数据开发者都会遇到的问题
雷恩Layne
01-30 4541
场景描述：flink消费分区有三个，其中第一个分区有数据，另外两个分区无数据。消费kafka分区的flink算子并行度为3，三个子任务分别消费kafka的分区，导致Watermark机制失效。
深入浅出Flink-第四章（waterMark）
大锤
04-05 263
1 需求背景 需求描述：每隔5秒，计算最近10秒单词出现的次数。 1.1 TimeWindow实现 /** * 每隔5秒计算最近10秒单词出现的次数 */ public class TimeWindowWordCount { public static void main(String[] args) throws Exception{ StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutio
【深入浅出flink】第12篇：多图全面剖析flink中的时间语义和Watermark，面试官再也难不倒我了
雷恩Layne
01-23 2291
流式数据处理最大的特点是数据具有时间属性特征，Flink根据时间产生的位置不同，将时间区分为三种概念：数据生成时间（Event_time）、事件接入时间（Ingestion_time）、事件处理时间（Processing_time）。那么此时出现一个问题，一旦出现乱序，如果只根据eventTime决定window的运行，我们不能明确数据是否全部到位，但又不能无限期的等下去，此时必须要有个机制来保证一个特定的时间后，必须触发window去进行计算了，这个特别的机制，就是Watermark。
【深入浅出flink】第10篇：聊聊flink窗口计算的触发器（Trigger）
雷恩Layne
01-17 6958
Trigger（触发器）决定了什么时候窗口准备就绪了，一旦窗口准备就绪就可以使用WindowFunction（窗口计算操作）进行计算。每一个 WindowAssigner（窗口分配器） 都会有一个默认的Trigger。如果默认的Trigger不满足用户的需求，用户可以自定义Trigger。
Flink的watermark理解
Baron_ND的博客
05-17 675
摘要 对于Flink来说，Watermark是个很难绕过去的概念。本文将从整体的思路上来说，运用感性直觉的思考来帮大家梳理Watermark概念。 1 问题 关于Watermark，很容易产生几个问题 Flink 流处理应用中，常见的处理需求/应对方案是什么? Watermark究竟应该翻译成水印还是水位线？ Watermark本质是什么? Watermark是如何解决问题? 下面我们就来简要解答这些问题以给大家一个大致概念，在后文中，会再深入描述。 问题1. Flink 流处理应用中常见的
[白话解析] Flink的Watermark机制
涂作权的博客
03-16 621
本文转自：https://www.cnblogs.com/rossiXYZ/p/12286407.html 1. 摘要 对于Flink来说，Watermark是个很难绕过去的概念。本文将从整体的思路上来说，运用感性直觉的思考来帮大家梳理Watermark概念。 2.问题 关于Watermark，很容易产生几个问题 Flink 流处理应用中，常见的处理需求/应对方案是什么? Watermark究竟应该翻译成水印还是水位线？ Watermark本质是什么? Watermark是如何解决问题? 下面我们就来简
Flink的Watermark机制
07-23 363
原博客地址：https://www.cnblogs.com/rossiXYZ/p/12286407.html 摘要 对于Flink来说，Watermark是个很难绕过去的概念。本文将从整体的思路上来说，运用感性直觉的思考来帮大家梳理Watermark概念。 01问题 关于Watermark，很容易产生几个问题 Flink 流处理应用中，常见的处理需求/应对方案是什么? Watermark究竟应该翻译成水印还是水位线？ Watermark本质是什么? Watermark是如何解决问题? 下面我们就来简要解答
深入浅出时序数据库之预处理篇
01-27
- 流式处理：数据实时路由到流处理框架，如Spark或Flink，在内存中实时计算并写入时序数据库。流式处理强调数据流的实时性和一致性，需要解决数据流的调度问题，以确保相同数据流在相同计算单元中聚合。 批处理适用...
【Flink篇07】Flink之时间语义和WaterMark1
08-04
当Flink接收到数据时，会根据数据中的最大Event Time生成Watermark，一旦Watermark超过了窗口的结束时间，那么窗口就会被触发并进行计算。 例如，假设我们有两个窗口，一个是从1s到5s，另一个是从6s到10s。当时间戳...
flink开发实战之flink原理解析
01-27
我们知道目前流处理的主要流行的计算引擎有，Storm，SparkStreaming。...Flink的出现完美的解决了以上问题，这也是flink出现的原因，flink不仅能提供同时支持高吞吐和exactly-once语义的实时计算，
【Flink篇09】Flink之状态编程1
08-04
【Flink篇09】Flink之状态编程1 在大数据处理领域，Flink作为一款强大的流处理框架，其核心特性之一是有状态流处理。本文将深入探讨有状态流处理的概念、重要性以及Flink中如何实现和管理状态。 有状态流处理与无...
Flink流处理之迭代案例
01-27
但是对于流处理（DataStream），Flink同样提供了对迭代的支持，这一节我们主要来分析流处理中的迭代，我们将会看到流处理中的迭代相较于批处理有相似之处，但差异也是十分之明显。 可迭代的流处理程序允许定义“步...
深入浅出Flink 07 之 SavePoint
澜水清风的博客
07-13 905
SavePoint是一个重量级的Checkpoint,你可以把它当做在某个时间点程序状态全局镜像，以后程序在进 行升级，或者修改并发度等情况，还能从保存的状态位继续启动恢复。可以保存数据源offset， operator操作状态等信息，可以从应用在过去任意做了savepoint的时刻开始继续消费。 Checkpint和SavePoint 概念： Checkpoint 是 自动容错机制 ， Savepoint 程序全局状态镜像 。 目的： Checkpoint 是程序自动容错，快速恢复 。 Savepoi
深入浅出 Flink 03 之 Sink
澜水清风的博客
07-13 442
Flink 03 之 Sink1.1 print() / printToErr()1.2 writeAsText()1.3 Flink提供的sink1.4 DataSet算子操作1.5 Flink之广播变量1.6 Flink之Counter（计数器） 1.1 print() / printToErr() 打印每个元素的toString()方法的值到标准输出或者标准错误输出流中 1.2 writeAsText() /** * 数据源：1 2 3 4 5.....源源不断过来 * 通过map打印一下接受到
深入浅出Flink 13 之 内存模型
澜水清风的博客
07-14 284
Flink 13 之 内存模型1.1 Flink运行流程回顾1.2 TaskManager之间的数据传输1.3 Flink内存管理 1.1 Flink运行流程回顾 Flink任务运行流程 Task 1.2 TaskManager之间的数据传输 1.3 Flink内存管理 Java对象存储密度低：一个只包含boolean属性的对象占用16个字节内存：对象头占了8个， boolean属性占了1个，对其填充占了7个，而实际只需要一个bit（1/8字节）就够了。 Full GC会极大地影响性能，尤其是为
深入浅出 Flink 01 之 数据源（DataStream）
澜水清风的博客
07-12 229
Flink 01 之 数据源（DataStream）1.1 source简介1.2 数据源之collection1.3 自定义单并行度数据源1.4 自定义多并行度数据源 1.1 source简介 source是程序的数据源输入，你可以通过StreamExecutionEnvironment.addSource(sou rceFunction) 来为你的程序添加一个source。 flink提供了大量的已经实现好的source方法，也可以自定义source： 1. 通过实现sourceFunction接口来自
flink watermark
最新发布
04-12
Flink 中的 Watermark 是一种用于处理事件时间的机制。在处理流数据时，事件时间是指数据本身所携带的时间戳，而 Watermark 是一种特殊的标记，用于表示在该标记之前的所有事件都已经到达。在 Flink 中，Watermark 的主要作用是用于触发窗口操作，即当一个窗口的所有数据的事件时间都小于 Watermark 时，该窗口将被触发并输出计算结果。因此，Watermark 的产生方式和大小直接影响到窗口的触发时间和结果。在 Flink 中，可以通过自定义 WatermarkGenerator 的方式来生成 Watermark。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值