大数据与流处理 / 系统课时

触发器与移除器

触发器与移除器

窗口分配器只负责把元素放入窗口,真正决定“何时计算”和“计算前保留哪些元素”的是 Trigger 与 Evictor。本课通过一个可运行示例拆开两者的执行顺序,并说明覆盖默认触发器、清理状态和关闭预聚合所带来的成本。

学习目标

  • 解释 TriggerResult 中继续、触发与清空的差异
  • 说明 Evictor 在窗口函数前后移除元素的时机
  • 判断自定义触发与逐元素缓存是否值得使用

Trigger 决定何时计算

每个窗口都有 Trigger。元素到达时会调用 onElement,事件时间或处理时间定时器到期时会调用对应回调。Trigger 返回 CONTINUE 时继续等待,返回 FIRE 时执行窗口函数但保留窗口内容,返回 PURGE 时只清空内容,返回 FIRE_AND_PURGE 时先计算再清空。

调用 .trigger(...) 会覆盖窗口分配器的默认 Trigger。例如,事件时间滚动窗口默认依赖 Watermark 触发;替换为纯计数 Trigger 后,它不会再自动按窗口结束时间产出结果。需要同时满足“到时间或到数量”时,应在自定义 Trigger 中同时注册时间定时器并维护计数状态。

Trigger 自己创建的分区状态和定时器也必须在 clear 中释放。只返回 FIRE 而长期不清理窗口内容,会让后续触发重复读取历史元素;这可能是增量更新的设计,也可能演变为状态持续增长。

Trigger 与 Evictor 的窗口执行链路

Evictor 决定哪些元素参与

Evictor 只会在 Trigger 已经触发后运行。evictBefore 删除的元素不会进入本次窗口函数,evictAfter 则在窗口函数完成后再删除。内置实现包括按数量、时间范围或差值淘汰元素,但窗口内元素顺序没有稳定保证,不能把“缓冲区开头”简单理解为业务上的最早到达记录。

使用 Evictor 后,Flink 必须把窗口内的原始元素交给它检查,因此无法只保存 ReduceFunction 或 AggregateFunction 的预聚合结果。窗口越大、元素越多,状态体积、序列化和检查点成本越明显。能用增量聚合、状态 TTL 或上游过滤解决时,通常不应优先选择 Evictor。

可运行示例与成本判断

下面的程序在一分钟处理时间窗口中,每收到三个元素触发一次计算,并在计算前移除奇数。示例使用 FIRE,所以第一次保留下来的偶数会继续参与第二次计算;在已经配置 Flink DataStream 依赖的 Java 项目中可直接运行。

java
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows;
import org.apache.flink.streaming.api.windowing.evictors.Evictor;
import org.apache.flink.streaming.api.windowing.triggers.Trigger;
import org.apache.flink.streaming.api.windowing.triggers.TriggerResult;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.streaming.runtime.operators.windowing.TimestampedValue;
import org.apache.flink.util.Collector;

import java.time.Duration;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class TriggerEvictorDemo {

    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env =
                StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        env.fromElements(1, 2, 3, 4, 5, 6)
                .keyBy(value -> "all")
                .window(TumblingProcessingTimeWindows.of(Duration.ofMinutes(1)))
                .trigger(new EveryThreeElementsTrigger())
                .evictor(new OddValueEvictor())
                .process(new ProcessWindowFunction<Integer, String, String, TimeWindow>() {
                    @Override
                    public void process(
                            String key,
                            Context context,
                            Iterable<Integer> elements,
                            Collector<String> out) {
                        List<Integer> values = new ArrayList<>();
                        elements.forEach(values::add);
                        Collections.sort(values);
                        out.collect("key=" + key + ", values=" + values);
                    }
                })
                .print();

        env.execute("trigger-evictor-demo");
    }

    private static final class EveryThreeElementsTrigger
            extends Trigger<Integer, TimeWindow> {

        private final ValueStateDescriptor<Long> countDescriptor =
                new ValueStateDescriptor<>("element-count", Long.class);

        @Override
        public TriggerResult onElement(
                Integer element,
                long timestamp,
                TimeWindow window,
                TriggerContext context) throws Exception {
            ValueState<Long> count =
                    context.getPartitionedState(countDescriptor);
            long next = count.value() == null ? 1L : count.value() + 1L;

            if (next >= 3L) {
                count.clear();
                return TriggerResult.FIRE;
            }
            count.update(next);
            return TriggerResult.CONTINUE;
        }

        @Override
        public TriggerResult onProcessingTime(
                long time, TimeWindow window, TriggerContext context) {
            return TriggerResult.CONTINUE;
        }

        @Override
        public TriggerResult onEventTime(
                long time, TimeWindow window, TriggerContext context) {
            return TriggerResult.CONTINUE;
        }

        @Override
        public void clear(TimeWindow window, TriggerContext context)
                throws Exception {
            context.getPartitionedState(countDescriptor).clear();
        }
    }

    private static final class OddValueEvictor
            implements Evictor<Integer, TimeWindow> {

        @Override
        public void evictBefore(
                Iterable<TimestampedValue<Integer>> elements,
                int size,
                TimeWindow window,
                EvictorContext context) {
            Iterator<TimestampedValue<Integer>> iterator =
                    elements.iterator();
            while (iterator.hasNext()) {
                if (iterator.next().getValue() % 2 != 0) {
                    iterator.remove();
                }
            }
        }

        @Override
        public void evictAfter(
                Iterable<TimestampedValue<Integer>> elements,
                int size,
                TimeWindow window,
                EvictorContext context) {
            // 本例选择在窗口函数执行前完成淘汰。
        }
    }
}

预期输出

text
key=all, values=[2]
key=all, values=[2, 4, 6]

本地运行器可能附加并行子任务前缀。这个结果也暴露了 FIRE 的累积语义:元素 2 没有被清空。若每三条数据应形成互不重叠的一批,可改为 FIRE_AND_PURGE,并确认窗口函数不再需要历史内容。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

触发器与移除器

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通