Spark Drive 端的 List 无法获取 Executor 中的数据吗？

shengjk12025-02-14 19:31

你好，我是 shengjk1，多年大厂经验，努力构建 通俗易懂的、好玩的编程语言教程。 欢迎关注！你会有如下收益：

  1. 了解大厂经验
  2. 拥有和大厂相匹配的技术等

希望看什么，评论或者私信告诉我！

一、背景

好久没有写 Spark 相关的代码了，结果写了一个如下类似的代码，在 drive 端 new 了一个 arrayList，然后再 Executor 端进行 add 操作，最后再在 drive 端打印 这个 list .size。结果发现这个 size 为0，顿时好奇心就上来了。

bash 复制代码 
 	    List<SuggestFeedback> slows = new ArrayList<>();

        rowJavaRDD.foreachPartition(rowIterator -> {
            while (rowIterator.hasNext()) {
                Row row = rowIterator.next();
                SuggestFeedback suggestFeedback = new SuggestFeedback();
                suggestFeedback.setDeviceId( Objects.isNull(row.getAs("device_id")) ? "" : row.getAs("device_id").toString());
                String suggest = suggestFeedback.getLevel1_mass_category();
                if (suggest.equals("卡顿问题")) {
                    slows.add(suggestFeedback);
                } 
       }
       System.out.print(slow.size())

二、spark 中解决方案( 其他分布式计算引擎也类似 )

在 Apache Spark 中，Driver 端和 Executor 端（TaskManager）运行在不同的 JVM 进程中，因此它们之间的内存是不共享的。如果你在 Driver 端创建了一个 List，并尝试在 Executor 端（TaskManager）通过 list.add 添加数据，这是不会生效的，因为 Executor 端操作的是它自己的内存空间，而不是 Driver 端的内存空间。

解决方案

如果你需要在 Driver 端收集 Executor 端的数据，可以使用以下几种方式：

1. 使用 collect 方法

collect 方法会将 Executor 端的数据收集到 Driver 端。你可以在 Executor 端处理数据，然后使用 collect 将结果返回到 Driver 端。

scala 复制代码 
val rdd = sc.parallelize(Seq(1, 2, 3, 4, 5))
val result = rdd.map(x => x * 2).collect()  // 将数据收集到 Driver 端
val list = result.toList  // 转换为 List

2. 使用 aggregate 或 reduce 方法

如果你需要在 Executor 端进行聚合操作，并将结果返回到 Driver 端，可以使用 aggregate 或 reduce 方法。

scala 复制代码 
val rdd = sc.parallelize(Seq(1, 2, 3, 4, 5))
val sum = rdd.reduce(_ + _)  // 在 Executor 端进行聚合操作，结果返回到 Driver 端

3. 使用累加器（Accumulator）

累加器是一种特殊的变量，可以在 Executor 端进行累加操作，最终结果会在 Driver 端可见。

scala 复制代码 
val accum = sc.longAccumulator("My Accumulator")
rdd.foreach(x => accum.add(x))
println(accum.value)  // 在 Driver 端获取累加器的值

4. 使用广播变量（Broadcast Variable）

如果你需要在 Executor 端访问 Driver 端的数据，可以使用广播变量。广播变量会将 Driver 端的数据发送到每个 Executor 端，但 Executor 端不能修改广播变量的值。

scala 复制代码 
val list = List(1, 2, 3, 4, 5)
val broadcastVar = sc.broadcast(list)
val rdd = sc.parallelize(Seq(1, 2, 3))
val result = rdd.map(x => x + broadcastVar.value.sum).collect()

总结

在 Spark 中，Driver 端和 Executor 端的内存是隔离的，因此无法直接在 Executor 端修改 Driver 端的数据结构（如 List）。你需要通过 collect、aggregate、累加器或广播变量等方式在 Driver 端和 Executor 端之间传递数据。

三、为什么不会生效和报错

在 Apache Spark 或 Apache Flink 中，如果你在 Executor 端（TaskManager） 尝试修改 Driver 端（JobManager） 创建的 List 或其他数据结构，程序不会直接报错，但修改不会生效。这是因为 Executor 端和 Driver 端运行在不同的 JVM 进程中，内存是隔离的。以下详细解释为什么不会报错，以及背后的原理。

1. 为什么不会报错？

  • Spark 和 Flink 都是分布式计算框架，它们的任务执行模型是基于 Driver-Executor 或 JobManager-TaskManager 的架构。
  • Driver 端（JobManager） 负责协调任务，而 Executor 端（TaskManager） 负责实际执行任务。
  • Executor 端 和 Driver 端 运行在不同的 JVM 进程中，它们之间的内存是隔离的。

Java 对象的序列化和传递

  • 当你将一个 List 或其他对象传递给 Executor 端 时，Spark 或 Flink 会将该对象序列化并发送到 Executor 端。
  • 在 Executor 端 ，这个对象会被反序列化，生成一个 新的对象 ，这个对象与 Driver 端 的对象是完全独立的。
  • 因此，在 Executor 端 对这个对象的任何修改（如 list.add）只会影响 Executor 端 的副本，而不会影响 Driver 端 的原始对象。

为什么不会报错？

  • Executor 端 的操作是在自己的 JVM 进程中执行的，修改的是自己的副本，因此不会触发任何异常。
  • Driver 端 和 Executor 端 之间的内存隔离是设计上的特性，而不是错误。框架本身不会对这种行为进行检查或报错。

2. 为什么修改不会生效？

内存隔离

  • Driver 端 和 Executor 端 运行在不同的 JVM 进程中，它们的内存是完全隔离的。
  • 即使你在 Executor 端 修改了 List，这些修改只会影响 Executor 端 的副本，而不会同步回 Driver 端。

对象的序列化和反序列化

  • 当你将一个对象（如 List）传递给 Executor 端 时，Spark 或 Flink 会将该对象序列化并发送到 Executor 端。
  • 在 Executor 端 ，这个对象会被反序列化，生成一个 新的对象 。这个新对象与 Driver 端 的对象是完全独立的。
  • 因此，在 Executor 端 对这个对象的任何修改（如 list.add）只会影响 Executor 端 的副本，而不会影响 Driver 端 的原始对象。

3. 如何避免这种问题？

为了避免在 Executor 端 修改 Driver 端 的数据结构而不生效的问题，可以采用以下方法：

在 Spark 中

  1. 使用 collect 方法：

    • 将 Executor 端 的数据收集到 Driver 端 ，然后在 Driver 端 进行修改。
    scala 复制代码 
    val rdd = sc.parallelize(Seq(1, 2, 3, 4, 5))
val result = rdd.map(x => x * 2).collect()  // 将数据收集到 Driver 端
val list = result.toList  // 转换为 List

  2. 使用累加器（Accumulator）：

    • 累加器可以在 Executor 端 进行累加操作，最终结果会在 Driver 端 可见。
    scala 复制代码 
    val accum = sc.longAccumulator("My Accumulator")
rdd.foreach(x => accum.add(x))
println(accum.value)  // 在 Driver 端获取累加器的值

  3. 使用广播变量（Broadcast Variable）：

    • 广播变量可以将 Driver 端 的数据分发到所有 Executor 端 ，但 Executor 端 只能读取广播变量，不能修改。
    scala 复制代码 
    val list = List(1, 2, 3, 4, 5)
val broadcastVar = sc.broadcast(list)
val rdd = sc.parallelize(Seq(1, 2, 3))
val result = rdd.map(x => x + broadcastVar.value.sum).collect()

  1. 使用 DataSet 或 DataStream API：

    • 将 TaskManager 端 的数据返回到 JobManager 端。
    java 复制代码 
    ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
DataSet<Integer> data = env.fromElements(1, 2, 3, 4, 5);
DataSet<Integer> result = data.map(x -> x * 2);
List<Integer> resultList = result.collect(); // 将数据收集到 JobManager 端

  2. 使用累加器（Accumulator）：

    • 累加器可以在 TaskManager 端 进行累加操作，最终结果会在 JobManager 端 可见。
    java 复制代码 
    StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
LongCounter counter = new LongCounter();
env.fromElements(1, 2, 3, 4, 5)
   .map(x -> {
       counter.add(1); // 在 TaskManager 端累加
       return x;
   })
   .print(); // 触发任务执行
env.execute();
System.out.println("Counter value: " + counter.getLocalValue()); // 在 JobManager 端获取累加器的值

  3. 使用广播变量（Broadcast Variable）：

    • 广播变量可以将 JobManager 端 的数据分发到所有 TaskManager 端 ，但 TaskManager 端 只能读取广播变量，不能修改。
    java 复制代码 
    StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Integer> data = env.fromElements(1, 2, 3, 4, 5);
DataStream<Integer> broadcastData = env.fromElements(10, 20, 30);

data.connect(broadcastData.broadcast())
    .process(new BroadcastProcessFunction<Integer, Integer, Integer>() {
        @Override
        public void processElement(Integer value, ReadOnlyContext ctx, Collector<Integer> out) {
            // 访问广播变量
            for (Integer broadcastValue : ctx.getBroadcastState().get("broadcastState")) {
                out.collect(value + broadcastValue);
            }
        }

        @Override
        public void processBroadcastElement(Integer value, Context ctx, Collector<Integer> out) {
            // 更新广播状态
            ctx.getBroadcastState().put("broadcastState", value);
        }
    })
    .print();
env.execute();

4. 总结

  • Executor 端 和 Driver 端 的内存是隔离的，因此在 Executor 端 修改 Driver 端 的数据结构不会生效。
  • 这种行为不会报错，因为 Executor 端 操作的是自己的副本，而不是 Driver 端 的原始对象。
  • 为了避免这种问题，可以使用框架提供的机制（如 collect、累加器、广播变量等）来实现 Driver 端 和 Executor 端 之间的数据传递和共享。

四、总结

Driver 端 和 Executor 端 运行在不同的 JVM 进程中，内存隔离导致 Executor 端 对 Driver 端 数据结构的修改不会生效。

数据从 Driver 端 传递到 Executor 端 是通过序列化和反序列化实现的，这是一个单向过程，修改不会同步回 Driver 端。

解决方案包括使用 collect 方法将数据收集到 Driver 端、使用累加器进行分布式累加、使用广播变量共享数据等。

这种行为不会报错，因为 Executor 端 操作的是自己的副本，而不是 Driver 端 的原始对象。

相关推荐
Elastic 中国社区官方博客3 小时前
Elasticsearch 混合搜索 - Hybrid Search
大数据·人工智能·elasticsearch·搜索引擎·ai·语言模型·全文检索
一位卑微的码农3 小时前
深入解析Spring Cloud Config：构建高可用分布式配置中心
分布式·spring cloud·微服务·架构
@心都3 小时前
机器学习数学基础：29.t检验
人工智能·机器学习
9命怪猫3 小时前
DeepSeek底层揭秘——微调
人工智能·深度学习·神经网络·ai·大模型
kcarly5 小时前
KTransformers如何通过内核级优化、多GPU并行策略和稀疏注意力等技术显著加速大语言模型的推理速度？
人工智能·语言模型·自然语言处理
Asthenia04126 小时前
浏览器缓存机制深度解析：电商场景下的性能优化实践
后端
MinIO官方账号6 小时前
使用 AIStor 和 OpenSearch 增强搜索功能
人工智能
江江江江江江江江江7 小时前
深度神经网络终极指南：从数学本质到工业级实现（附Keras版本代码）
人工智能·keras·dnn
Fansv5877 小时前
深度学习-2.机械学习基础
人工智能·经验分享·python·深度学习·算法·机器学习
专注API从业者7 小时前
分布式电商系统中的API网关架构设计
大数据·数据仓库·分布式·架构
热门推荐
01本地部署DeepSeek教程（Mac版本）02如何在WPS和Word/Excel中直接使用DeepSeek功能03DeepSeek本地部署详细指南04太炸裂了！清华大学deepseek从入门到精通使用手册又出第三版了，《普通人如何抓住DeepSeek红利》（无套路，直接下载）05DeepSeek各版本说明与优缺点分析06DeepSeek r1本地安装全指南07本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程08DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具09在Windows下安装Ollama并体验DeepSeek r1大模型10Page Assist - 本地Deepseek模型 Web UI 的安装和使用