Spark05： RDD持久化

一、RDD持久化原理

1. 持久化原理

Spark中有一个非常重要的功能就是可以对RDD进行持久化。当对RDD执行持久化操作时，每个节点都会将自己操作的RDD的partition数据持久化到内存中，并且在之后对该RDD的反复使用中，直接使用内存中缓存的partition数据。这样的话，针对一个RDD反复执行多个操作的场景，就只需要对RDD计算一次即可，后面直接使用该RDD，而不需要反复计算多次该RDD。因为正常情况下这个RDD的数据使用过后内存中是不会一直保存的。

val dataRDD = sc.parallelize(Array(1,2,3,4,5))
val mapRDD = dataRDD.map(...)
mapRDD.foreach(...)
mapRDD.saveAsTextFile(...)
mapRDD.collect()

例如这样的操作：针对mapRDD需要多次使用的，巧妙使用RDD持久化，在某些场景下，对spark应用程序的性能有很大提升。特别是对于迭代式算法和快速交互式应用来说，RDD持久化，是非常重要的。

2. 如何使用持久化

要持久化一个RDD，只需要调用它的cache()或者persist()方法就可以了。在该RDD第一次被计算出来时，就会直接缓存在每个节点中。

3. Spark持久化自动容错

而且Spark的持久化机制还是自动容错的，如果持久化的RDD的任何partition数据丢失了，那么Spark会自动通过其源RDD，使用transformation算子重新计算该partition的数据。

4. cache()和persist()的区别

cache()是persist()的一种简化方式，cache()的底层就是调用的persist()的无参版本，也就是调用persist(MEMORY_ONLY)，将数据持久化到内存中。如果需要从内存中清除缓存，那么可以使用unpersist()方法。

二、持久化策略

策略	介绍
MEMORY_ONLY	以非序列化的方式持久化在JVM内存中
MEMORY_AND_DISK	同上，但是当某些partition无法存储在内存中时，会持久化到磁盘中
MEMORY_ONLY_SER	同MEMORY_ONLY，但是会序列化
MEMORY_AND_DISK_SER	同MEMORY_AND_DSK，但是会序列化
DISK_ONLY	以非序列化的方式完全存储到磁盘上
MEMORY_ONLY_2、MEMORY_AND_DISK_2	尾部加了2的持久化级别，表示会将持久化数 据复制一份，保存到其他节点

补充说明：

• MEMORY_ONLY：以非序列化的Java对象的方式持久化在JVM内存中。如果内存无法完全存储RDD所有的partition，那么那些没有持久化的partition就会在下一次需要使用它的时候，重新被计算。
• MEMORY_AND_DISK：当某些partition无法存储在内存中时，会持久化到磁盘中。下次需要使用这些partition时，需要从磁盘上读取，不需要重新计算
• MEMORY_ONLY_SER：同MEMORY_ONLY，但是会使用Java的序列化方式，将Java对象序列化后进行持久化。可以减少内存开销，但是在使用的时候需要进行反序列化，因此会增加CPU开销。
• MEMORY_AND_DISK_SER：同MEMORY_AND_DSK。但是会使用序列化方式持久化Java对象。
• DISK_ONLY：使用非序列化Java对象的方式持久化，完全存储到磁盘上。
• MEMORY_ONLY_2、MEMORY_AND_DISK_2等：如果是尾部加了2的持久化级别，表示会将持久化数据复制一份，保存到其它节点，从而在数据丢失时，不需要重新计算，只需要使用备份数据即可。

三、如何选择RDD持久化策略

 Spark提供了多种持久化级别，主要是为了在CPU和内存消耗之间进行取舍。
下面是一些通用的持久化级别的选择建议：
1. 优先使用MEMORY_ONLY，纯内存速度最快，而且没有序列化不需要消耗CPU进行反序列化操作，缺点就是比较耗内存
2. MEMORY_ONLY_SER，将数据进行序列化存储，纯内存操作还是非常快，只是在使用的时候需要消耗CPU进行反序列化

注意：
（1）如果需要进行数据的快速失败恢复，那么就选择带后缀为_2的策略，进行数据的备份，这样在失败时，就不需要重新计算了
（2）能不使用DISK相关的策略，就不要使用，因为有的时候，从磁盘读取数据，还不如重新计算一次。

 四、案例：使用RDD的持久化

在没有添加cache之前，每一次都耗时很长时间，加上cache之后，在第二次计算耗时就很少了。

1. Scala代码

package com.sanqian.scala

import org.apache.spark.{SparkConf, SparkContext}

object PersistRddScala {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setAppName("PersistRddScala").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val rdd = sc.textFile("D:\\data\\part-00000").cache()

    var startTime = System.currentTimeMillis()
    var count = rdd.count()

    var endTime = System.currentTimeMillis()

    println("第一次耗时:" + (endTime - startTime))

    startTime = System.currentTimeMillis()
    count = rdd.count()
    endTime = System.currentTimeMillis()
    println("第二次耗时:" + (endTime - startTime))

  }
}

2. Java代码

package com.sanqian.java;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;

public class PersistRddJava {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf();
        conf.setAppName("PersistRddJava").setMaster("local[*]");
        JavaSparkContext sc = new JavaSparkContext(conf);

        JavaRDD<String> rdd = sc.textFile("D:\\data\\part-00000").cache();
        long startTime = System.currentTimeMillis();
        long count = rdd.count();
        long endTime = System.currentTimeMillis();
        System.out.println("第一次耗时:" + (endTime - startTime));

        startTime = System.currentTimeMillis();
        count = rdd.count();

        System.out.println(count);
        endTime = System.currentTimeMillis();
        System.out.println("第二次耗时:" + (endTime - startTime));
    }
}