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

广播状态

广播状态

本课解决“规则流如何实时分发到所有并行算子”这一问题。你将使用 Broadcast State 保存动态规则,再让业务流按最新规则完成匹配,并掌握更新顺序、状态一致性和恢复边界。

学习目标

  • 理解广播流、主业务流与并行任务之间的关系
  • 使用 MapStateDescriptor 和 KeyedBroadcastProcessFunction 动态更新规则
  • 能验证规则是否生效,并识别规则乱序和状态膨胀问题

为什么需要广播状态

普通 keyBy 会把数据按键分区,同一条规则只能到达某个分区;但风控阈值、路由表、黑名单等规则通常需要被每个并行实例读取。广播状态会把规则流复制到下游所有实例,使每个实例都维护一份内容相同的只读规则视图。

主业务流仍按键分区,因此订单、设备或用户数据可以并行处理。规则流负责更新共享规则,业务流负责读取规则并计算,二者通过 connect 进入同一个双输入算子。

工作机制

规则流调用 broadcast 后,每条规则会发送给所有下游并行实例。processBroadcastElement 可以写广播状态;processElement 只能通过只读视图查询广播状态,避免业务数据处理过程产生不一致更新。

广播状态的数据分发与读取关系

广播状态属于算子状态。开启 Checkpoint 后,它会随作业状态一起保存和恢复;扩缩容恢复时,Flink 会重新分配广播状态,使新并行实例获得规则副本。

完整示例

下面的示例把一条高额订单规则广播到两个并行任务,再匹配订单金额。示例中的订单源故意延迟一秒,只用于稳定演示“先更新规则、后处理订单”,生产环境不能依赖两个输入流的到达先后。

java
import org.apache.flink.api.common.state.MapStateDescriptor;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.streaming.api.datastream.BroadcastStream;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.co.KeyedBroadcastProcessFunction;
import org.apache.flink.streaming.api.functions.source.SourceFunction;
import org.apache.flink.util.Collector;

public class BroadcastStateDemo {
    private static final MapStateDescriptor<String, Rule> RULES =
            new MapStateDescriptor<>(
                    "rules",
                    Types.STRING,
                    TypeInformation.of(Rule.class));

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

        DataStream<Rule> ruleStream =
                env.fromElements(new Rule("high-value", 100.0));
        BroadcastStream<Rule> broadcastRules = ruleStream.broadcast(RULES);

        DataStream<Order> orders =
                env.addSource(new DelayedOrderSource()).setParallelism(1);

        orders.keyBy(order -> order.userId)
                .connect(broadcastRules)
                .process(new RuleMatcher())
                .print()
                .setParallelism(1);

        env.execute("broadcast-state-demo");
    }

    public static class RuleMatcher
            extends KeyedBroadcastProcessFunction<String, Order, Rule, String> {
        @Override
        public void processBroadcastElement(
                Rule rule, Context ctx, Collector<String> out) throws Exception {
            // 只有广播输入侧可以修改规则状态
            ctx.getBroadcastState(RULES).put(rule.name, rule);
            out.collect("RULE_UPDATED " + rule.name + "=" + rule.threshold);
        }

        @Override
        public void processElement(
                Order order, ReadOnlyContext ctx, Collector<String> out)
                throws Exception {
            Rule rule = ctx.getBroadcastState(RULES).get("high-value");
            if (rule == null) {
                out.collect("NO_RULE " + order.orderId);
            } else if (order.amount >= rule.threshold) {
                out.collect("MATCH " + order.orderId + " amount=" + order.amount);
            } else {
                out.collect("IGNORE " + order.orderId + " amount=" + order.amount);
            }
        }
    }

    public static class DelayedOrderSource implements SourceFunction<Order> {
        private volatile boolean running = true;

        @Override
        public void run(SourceContext<Order> ctx) throws Exception {
            Thread.sleep(1000);
            if (running) {
                synchronized (ctx.getCheckpointLock()) {
                    ctx.collect(new Order("o-1001", "u-1", 120.0));
                    ctx.collect(new Order("o-1002", "u-2", 80.0));
                }
            }
        }

        @Override
        public void cancel() {
            running = false;
        }
    }

    public static class Rule {
        public String name;
        public double threshold;

        public Rule() {}

        public Rule(String name, double threshold) {
            this.name = name;
            this.threshold = threshold;
        }
    }

    public static class Order {
        public String orderId;
        public String userId;
        public double amount;

        public Order() {}

        public Order(String orderId, String userId, double amount) {
            this.orderId = orderId;
            this.userId = userId;
            this.amount = amount;
        }
    }
}

预期输出如下。不同运行环境中的日志前缀可能不同,但业务结果应一致。

text
RULE_UPDATED high-value=100.0
MATCH o-1001 amount=120.0
IGNORE o-1002 amount=80.0

关键边界

广播状态不保证规则流与业务流之间的全局先后关系。如果订单可能早于首条规则到达,应定义默认策略,例如暂存、拒绝、使用内置默认规则或输出到侧输出流,不能假设规则一定先到。

规则更新应具备版本号或生效时间。多个来源同时发布规则时,必须拒绝旧版本覆盖新版本。广播状态会复制到每个并行实例,规则集合过大会按并行度放大内存与 Checkpoint 开销,因此它适合较小、读取频繁、更新相对低频的数据。

广播侧的更新逻辑必须是确定性的:所有实例接收同一条规则后应执行相同操作。不要在 processBroadcastElement 中依赖本机时间、随机数或实例局部条件生成不同状态。

验证与排错

验证时先观察 RULE_UPDATED,再检查匹配结果。若持续出现 NO_RULE,应依次确认规则源是否有数据、描述符名称和类型是否完全一致、规则键是否正确,以及规则是否在作业恢复后被旧 Checkpoint 覆盖。

规则更新已打印但部分实例仍使用旧值时,应检查是否错误地把规则保存在普通成员变量中。只有通过广播状态读取,才能在并行实例间获得一致且可恢复的规则副本。

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

目录与阅读设置

阅读设置

17

记录一个想法

广播状态

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

登录哪都通