理解Spark序列化

Question

在Spark中，如何知道哪些对象在driver上实例化，哪些对象在executor上实例化，因此如何确定哪些类需要实现Serializable？

Answer 1

序列化对象意味着将其状态转换为字节流，以便字节流可以恢复为对象的副本。如果Java对象的类或其任何超类实现Java.io.serializable接口或子接口Java.io.Externalizable,则该对象是可序列化的。

类从不序列化，只有类的对象才序列化。如果对象需要持久化或通过网络传输，则需要对象序列化。

Class Component            Serialization
instance variable           yes
Static instance variable    no
methods                     no
Static methods              no
Static inner class          no
local variables             no

让我们以一个示例Spark代码并经历各种场景

public class SparkSample {

      public int instanceVariable                =10 ;
      public static int staticInstanceVariable   =20 ;

      public int run(){

         int localVariable                       =30;

         // create Spark conf
         final SparkConf sparkConf = new SparkConf().setAppName(config.get(JOB_NAME).set("spark.serializer", "org.apache.spark.serializer.KryoSerializer");

         // create spark context 
         final JavaSparkContext sparkContext = new JavaSparkContext(sparkConf);

        // read DATA 
        JavaRDD<String> lines = spark.read().textFile(args[0]).javaRDD(); 


        // Anonymous class used for lambda implementation
        JavaRDD<String> words = lines.flatMap(new FlatMapFunction<String, String>() {
                @Override
                public Iterator<String> call(String s) {
                // How will the listed varibles be accessed in RDD across driver and Executors 
                System.out.println("Output :" + instanceVariable + " " + staticInstanceVariable + " " + localVariable);
                return Arrays.asList(SPACE.split(s)).iterator();
        });

        // SAVE OUTPUT
        words.saveAsTextFile(OUTPUT_PATH));

      }

       // Inner Static class for the funactional interface which can replace the lambda implementation above 
       public static class MapClass extends FlatMapFunction<String, String>() {
                @Override
                public Iterator<String> call(String s) {
                System.out.println("Output :" + instanceVariable + " " + staticInstanceVariable + " " + localVariable);
                return Arrays.asList(SPACE.split(s)).iterator();
        }); 

        public static void main(String[] args) throws Exception {
            JavaWordCount count = new JavaWordCount();
            count.run();
        }
}

    Inner class        | Instance Variable (Outer class) | Static Instance Variable (Outer class) | Local Variable (Outer class)

    Anonymous class    | Accessible And Serialized       | Accessible yet not Serialized          | Accessible And Serialized 

    Inner Static class | Not Accessible                  | Accessible yet not Serialized          | Not Accessible 

如果在内部类中访问了任何外部类实例变量，编译器会应用不同的逻辑来访问它们，因此外部类是否被序列化取决于您访问的是什么。

就Java而言，整个争论都是关于外部类与内部类以及访问外部类引用和变量如何导致序列化问题的。

各种方案：

anonymo-class（）{

 final Outer-class reference;

 Anonymous-class( Outer-class outer-reference){

reference = outer-reference;

}

}

外部类被序列化并与内部匿名类的序列化对象一起发送

引用外部类对象和局部变量refrence的匿名类。

外部类对象用于访问实例变量

anonymo-class（）{

 final Outer-class reference;

final Local-variable localRefrence ;

 Anonymous-class( Outer-class outer-reference, Local-variable localRefrence){

reference = outer-reference;

this.localRefrence = localRefrence;

}

无法访问

无法访问

由于静态变量没有序列化，因此没有外部类对象被序列化。

>

遵循Java序列化规则来选择需要序列化的类对象。

使用javap-p-c“abc.class”打开字节码，查看编译器生成的代码

根据您试图在外部类的内部类中访问的内容，编译器生成不同的字节代码。

任何声明为瞬态的实例变量都不会在驱动程序上序列化。