即使有一个 .cache() d rdd，spark似乎仍然序列化每个任务运行的数据。考虑以下代码：

class LoggingSerializable() extends Externalizable {
  override def writeExternal(out: ObjectOutput): Unit = {
    println("xxx serializing")
  }

  override def readExternal(in: ObjectInput): Unit = {
    println("xxx deserializing")
  }
}

object SparkSer {
  def main(args: Array[String]) = {
    val conf = new SparkConf().setAppName("SparkSer").setMaster("local")
    val spark = new SparkContext(conf)
    val rdd: RDD[LoggingSerializable] = spark.parallelize(Seq(new LoggingSerializable())).cache()
    println("xxx done loading")
    rdd.foreach(ConstantClosure)
    println("xxx done 1")
    rdd.foreach(ConstantClosure)
    println("xxx done 2")
    spark.stop()
  }
}

object ConstantClosure extends (LoggingSerializable => Unit) with Serializable {
  def apply(t: LoggingSerializable): Unit = {
    println("xxx closure ran")
  }
}

它打印出来了

xxx done loading
xxx serializing
xxx deserializing
xxx closure ran
xxx done 1
xxx serializing
xxx deserializing
xxx closure ran
xxx done 2

尽管我打过电话 .cache() 在 rdd ，spark仍然序列化每个调用的数据 .foreach . 官方文件说
当您持久化rdd时，每个节点将其计算的任何分区存储在内存中，并在该数据集（或从该数据集派生的数据集）上的其他操作中重用这些分区。
然后呢 MEMORY_ONLY 方法
将rdd作为反序列化的java对象存储在jvm中。
请注意，spark在序列化任务时尝试序列化数据，但是 ConstantClosure 不关闭任何内容，所以我不明白为什么需要序列化任何数据。
我之所以这么问是因为我希望能够在本地模式下运行spark而不损失任何性能，但是对于每个rdd操作，必须在rdd中序列化大型元素可能会非常昂贵。我不确定这个问题是否是本地模式独有的。spark似乎不可能通过有线将rdd中的数据发送给每个操作的工人，即使rdd被缓存了。
我用的是spark core 3.0.0。