Flink-ContinuousProcessingTimeTrigger源码解析及一个小问题处理

背景

工作中遇到一个需求，需要按天划分窗口，并且每隔固定时间段触发一次窗口计算，时间语义为ProcessingTime。在测试过程中发现，使用ContinuousProcessingTimeTrigger会有一个问题：当窗口到达EndTime时并不会触发。

测试

在本地测试时使用自造数据：类别，数量，时间。然后统计每分钟的总量，每10秒钟触发一次窗口计算，并且触发窗口计算后立即清除已经计算过的所有数据，累计的总量值通过状态保存。

public class demo2 {
    private static class DataSource extends RichParallelSourceFunction>{
        private volatile boolean isRunning=true;
        @Override
        public void run(SourceContext> ctx) throws Exception{
            Random random=new Random();
            while(isRunning){
                Thread.sleep((getRuntimeContext().getIndexOfThisSubtask()+1)*1000*8);
                String key="类别"+(char)('A'+random.nextInt(1));
                int value=random.nextInt(10)+1;
                String dt=dateTime.transferLongToDate("yyyy-MM-dd HH:mm:ss.SSS",System.currentTimeMillis());
                System.out.println(String.format("Emits\t(%s,%d,%s)",key,value,dt));
                ctx.collect(new Tuple3<>(key,value,dt));
            }
        }
        @Override
        public void cancel(){
            isRunning=false;
        }
    }
    public static void main(String[] args) throws Exception{
        StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(2);
        env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);
        DataStream> ds =env.addSource(new DataSource());
        SingleOutputStreamOperator res=ds
                .keyBy(
                (KeySelector, String>) in -> in.f0
        )
                .window(TumblingProcessingTimeWindows.of(Time.seconds(60)))
                .trigger(ContinuousProcessingTimeTrigger.of(Time.seconds(10)))
                .evictor(CountEvictor.of(0,true))
                .process(new ProcessWindowFunction, String, String, TimeWindow>() {
                    private static final long serialVersionUID = 3091075666113786631L;
                    private ValueState valueState;
                    @Override
                    public void open(Configuration parameters) throws Exception {
                        ValueStateDescriptor desc=new ValueStateDescriptor<>("value_state",Integer.class);
                        valueState=getRuntimeContext().getState(desc);
                        super.open(parameters);
                    }
                    @Override
                    public void process(String tuple, Context context, Iterable> iterable, Collector collector) throws Exception {
                        //测试输出：窗口的每次触发时间
                        System.out.println("trigger:"+dateTime.transferLongToDate("yyyy-MM-dd HH:mm:ss.SSS",context.currentProcessingTime()));
                        int res=0;
                        if(valueState.value()!=null){
                            res=valueState.value();
                        }
                        for(Tuple3 val:iterable){
                            res+=val.f1;
                        }
                        valueState.update(res);
                        String out=dateTime.transferLongToDate("yyyy-MM-dd HH:mm:ss",context.window().getStart())+
                                ","+tuple.toString()+":"+valueState.value();
                        collector.collect(out);
                    }
                    @Override
                    public void clear(Context context) throws Exception {
                        //状态清理时间
                        System.out.println("Start Clear:"+dateTime.transferLongToDate("yyyy-MM-dd HH:mm:ss.SSS",System.currentTimeMillis()));
                        valueState.clear();
                        super.clear(context);
                    }
                });
        res.process(new ProcessFunction() {
            @Override
            public void processElement(String s, Context context, Collector