Spark MapwithState快照不可缩放（Java）

我正在使用spark从Kafka Stream接收数据，以接收有关定期发送健康更新的物联网设备的状态以及设备中存在的各种传感器的状态。我的Spark应用程序侦听单个主题，使用Spark direct stream从Kafka流接收更新消息。我需要根据每个设备的传感器状态触发不同的警报。然而，当我添加更多使用Kakfa向spark发送数据的物联网设备时，spark无法扩展，尽管添加了更多的机器，并且执行器的数量增加了。下面我给出了Spark应用程序的精简版本，其中通知触发部分已删除，但性能问题相同

   // Method for update the Device state , it just a in memory object which tracks the device state  .
private static Optional<DeviceState> trackDeviceState(Time time, String key, Optional<ProtoBufEventUpdate> updateOpt,
            State<DeviceState> state) {
            int batchTime = toSeconds(time);
            ProtoBufEventUpdate eventUpdate = (updateOpt == null)?null:updateOpt.orNull();
            if(eventUpdate!=null)
                eventUpdate.setBatchTime(ProximityUtil.toSeconds(time));
            if (state!=null && state.exists()) {
                DeviceState deviceState = state.get();
                if (state.isTimingOut()) {
                    deviceState.markEnd(batchTime);
                }
                if (updateOpt.isPresent()) {
                        deviceState = DeviceState.updatedDeviceState(deviceState, eventUpdate);
                        state.update(deviceState);
                }
            } else if (updateOpt.isPresent()) {
                DeviceState deviceState = DeviceState.newDeviceState(eventUpdate);
                state.update(deviceState);              
                return Optional.of(deviceState);
            } 

        return Optional.absent();
}
    SparkConf conf = new SparkConf()
    .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    .set("spark.streaming.receiver.writeAheadLog.enable", "true")
    .set("spark.rpc.netty.dispatcher.numThreads", String.valueOf(Runtime.getRuntime().availableProcessors()))
     JavaStreamingContext context= new JavaStreamingContext(conf, Durations.seconds(10));
Map<String, String> kafkaParams = new HashMap<String, String>();
        kafkaParams.put( “zookeeper.connect”, “192.168.60.20:2181,192.168.60.21:2181,192.168.60.22:2181”);
        kafkaParams.put("metadata.broker.list", “192.168.60.20:9092,192.168.60.21:9092,192.168.60.22:9092”);
        kafkaParams.put(“group.id”, “spark_iot”);
        HashSet<String> topics=new HashSet<>();
        topics.add(“iottopic”);

JavaPairInputDStream<String, ProtoBufEventUpdate> inputStream = KafkaUtils.
            createDirectStream(context, String.class, ProtoBufEventUpdate.class,  KafkaKryoCodec.class, ProtoBufEventUpdateCodec.class, kafkaParams, topics);

JavaPairDStream<String, ProtoBufEventUpdate> updatesStream = inputStream.mapPartitionsToPair(t -> {
            List<Tuple2<String, ProtoBufEventUpdate>> eventupdateList=new ArrayList<>();
            t.forEachRemaining(tuple->{
                    String key=tuple._1;
                    ProtoBufEventUpdate eventUpdate =tuple._2;                  
                    Util.mergeStateFromStats(eventUpdate);
                    eventupdateList.add(new Tuple2<String, ProtoBufEventUpdate>(key,eventUpdate));

            });
            return eventupdateList.iterator();
});

JavaMapWithStateDStream<String, ProtoBufEventUpdate, DeviceState, DeviceState> devceMapStream = null;

devceMapStream=updatesStream.mapWithState(StateSpec.function(Engine::trackDeviceState)
                             .numPartitions(20)
                             .timeout(Durations.seconds(1800)));
devceMapStream.checkpoint(new Duration(batchDuration*1000));


JavaPairDStream<String, DeviceState> deviceStateStream = devceMapStream
                .stateSnapshots()
                .cache();

deviceStateStream.foreachRDD(rdd->{
                if(rdd != null && !rdd.isEmpty()){
                    rdd.foreachPartition(tuple->{
                    tuple.forEachRemaining(t->{
                        SparkExecutorLog.error("Engine::getUpdates Tuple data  "+ t._2);
                    });
                });
                }
});

---

目前Spark正在努力在10秒内完成处理（我甚至尝试了不同的批处理持续时间，如5、10、15等）。完成一个批次需要15-23秒，输入速率为每秒1600条记录，每个批次有17000条记录。我需要使用statesteam定期检查设备的状态，以查看设备是否发出任何警报或任何传感器是否停止响应。我不确定如何提高spark应用程序的性能

mapWithState

执行以下操作：

将函数应用于此流的每个键值元素，同时为每个唯一键维护一些状态数据

根据其文件：

这也意味着，对于每个批处理，具有相同密钥的所有元素都是按顺序处理的，而且由于

StateSpec

中的函数是任意的，由我们提供，没有定义状态组合器，因此无论在

mapWithState

之前如何划分数据，它都无法进一步并行化。也就是说，当密钥不同时，并行化会很好，但是如果所有RDD元素中只有几个唯一的密钥，那么整个批次将主要由与唯一密钥数相等的内核数进行处理

在您的情况下，钥匙来自卡夫卡：

            t.forEachRemaining(tuple->{
                String key=tuple._1;

而您的代码片段并没有显示它们是如何生成的

根据我的经验，这就是可能发生的情况：批处理的某些部分正在被多个内核快速处理，而另一部分，对于整个批处理的大部分具有相同的密钥，需要更多的时间并延迟批处理，这就是为什么您看到大多数时间只运行一些任务，而执行器负载不足的原因

要想知道这是不是真的，请检查您的密钥分布，每个密钥有多少个元素，可能仅仅几个密钥就有20%的元素吗？如果这是真的，您有以下选项：

• 更改密钥生成算法
• 在

  mapWithState

  之前人为地分割有问题的键，并在以后合并状态快照以使整个系统有意义
• 限制每个批次中要处理的具有相同密钥的元素的数量，或者忽略每个批次中前N个之后的元素，或者将它们发送到其他地方，进入一些“无法及时处理”的Kafka流，并分别处理它们

---

查看Spark UI时，哪个任务占用的时间最多？deviceStateStream.foreachRDD，此任务几乎需要6-9秒。为什么要使用

rdd.collect（）？它会将所有数据洗牌到运行驱动程序的节点，这是不健康的，您不应该在生产中这样做。还有，为什么要缓存状态快照？我只是使用rdd.collect（）来说明应用程序逻辑。在真正的代码中，我不是在做collect，而是在做rdd.foreachPartition（destinationTuples->{//一些基于设备状态发送通知的逻辑}）；我会更新这个问题。我只是在缓存状态快照，因为它将计算结果保存到DeviceState中的不同集合中，我想单独迭代以发送警报。在缓存的状态快照上发生多个操作。因为我在与第一个问题作斗争，所以我对其他问题进行了评论。
            t.forEachRemaining(tuple->{
                String key=tuple._1;