class StorageLevel private(
                              private var _useDisk: Boolean,
                              private var _useMemory: Boolean,
                              private var _useOffHeap: Boolean,
                              private var _deserialized: Boolean,
                              private var _replication: Int = 1
                            )

object StorageLevel {
  // 不缓存
  val NONE = new StorageLevel(false, false, false, false)

  // 仅仅使用磁盘存储RDD的数据（未经序列化）。
  val DISK_ONLY = new StorageLevel(true, false, false, false)
  // 2的意思是会将数据备份到集群中两个不同的节点，其余情况类似。
  val DISK_ONLY_2 = new StorageLevel(true, false, false, false, 2)
  
  // 默认选项，RDD的（分区）数据直接以Java对象的形式存储于JVM的内存中，如果内存空间不足，某些分区的数据将不会被缓存
  val MEMORY_ONLY = new StorageLevel(false, true, false, true)
  val MEMORY_ONLY_2 = new StorageLevel(false, true, false, true, 2)
  
  // RDD的数据（Java对象）序列化之后存储于JVM的内存中
  // 能够有效节约内存空间，但读取数据时需要更多的CPU开销
  val MEMORY_ONLY_SER = new StorageLevel(false, true, false, false)
  val MEMORY_ONLY_SER_2 = new StorageLevel(false, true, false, false, 2)

  
  // RDD的数据直接以Java对象的形式存储于JVM的内存中
  // 如果内存空间不中，某些分区的数据会被存储至磁盘，使用的时候从磁盘读取。
  val MEMORY_AND_DISK = new StorageLevel(true, true, false, true)
  val MEMORY_AND_DISK_2 = new StorageLevel(true, true, false, true, 2)
 
  // 与 MEMORY_AND_DISK 相同，除了会序列化
  val MEMORY_AND_DISK_SER = new StorageLevel(true, true, false, false)
  val MEMORY_AND_DISK_SER_2 = new StorageLevel(true, true, false, false, 2)
  
  // RDD的数据序例化之后存储至Tachyon （基于内存的文件系统）
  //  默认未与Spark整合，未整合设置会报错
  val OFF_HEAP = new StorageLevel(false, false, true, false)

    使用

rdd.persist(StorageLevel.MEMORY_ONLY)

    清除缓存（一般不需要，Spark会自动处理）

rdd.unpersit()

       简化版 persist ，持久化等级为 MEMORY_ONLY

 1、cache和persist都是懒执行，需要action类算子触发执行
 2、cache或者persist的返回值必须赋值给一个变量（不然没有意义，因为没有引用）
            在接下来的job中直接使用这个变量那就是使用了内存中的数据了
3、cache和persist后面不能立即紧跟action类算子 （也没意义，因为action类算子返回值不是RDD）

问题：在一个job中对某一个 RDD进行频繁的重复操作，有必要进行持久化吗？
      没有必要！！！ 因为持久化的算子只有遇到action类算子  才会将RDD的数据写入到内存中
      val rdd = sc.textFile(path)
      val filterRDD = rdd.filter
      val mapRDD = rdd.map
      val unionRDD = filterRDD.union(mapRDD)
      unionRDD.count
      val cacheRDD = rdd.cache

rdd.cache()

 SparkConf conf = new SparkConf();
 conf.setMaster("local").setAppName("checkpoint");
 JavaSparkContext sc = new JavaSparkContext(conf);
 sc.setCheckpointDir("./checkpoint");
 JavaRDD<Integer> parallelizeRDD = sc.parallelize(Arrays.asList(1,2,3));
 parallelizeRDD .checkpoint();
 parallelizeRDD .count();
 sc.stop();