RDD缓存与RDD序列化缓存的大小对比

最新推荐文章于 2020-12-14 17:43:41 发布
最新推荐文章于 2020-12-14 17:43:41 发布
阅读量170 收藏
点赞数
原文链接：http://www.cnblogs.com/xuziyu/p/10914701.html
版权

RDD的缓存一般就是用cache和persist，那二者之间有什么关系，又有什么区别呢？

关系：

  • persist()内部调用了persist(StorageLevel.MEMORY_ONLY)
  • cache()调用了persist()

区别：

  • persist有一个 StorageLevel 类型的参数，这个表示的是RDD的缓存级别。
  • cache只有一个默认的缓存级别MEMORY_ONLY ，而persist可以根据情况设置其它的缓存级别。

StorageLevel部分源码

object StorageLevel {
  val NONE = new StorageLevel(false, false, false, false)
  val DISK_ONLY = new StorageLevel(true, false, false, false)
  val DISK_ONLY_2 = new StorageLevel(true, false, false, false, 2)
  val MEMORY_ONLY = new StorageLevel(false, true, false, true)
  val MEMORY_ONLY_2 = new StorageLevel(false, true, false, true, 2)
  val MEMORY_ONLY_SER = new StorageLevel(false, true, false, false)
  val MEMORY_ONLY_SER_2 = new StorageLevel(false, true, false, false, 2)
  val MEMORY_AND_DISK = new StorageLevel(true, true, false, true)
  val MEMORY_AND_DISK_2 = new StorageLevel(true, true, false, true, 2)
  val MEMORY_AND_DISK_SER = new StorageLevel(true, true, false, false)
  val MEMORY_AND_DISK_SER_2 = new StorageLevel(true, true, false, false, 2)
  val OFF_HEAP = new StorageLevel(true, true, true, false, 1)
          。。。。。。
}

注解

MEMORY_ONLY
使用未序列化的Java对象格式，将数据保存在内存中。如果内存不够存放的所有数据，则数据可能就不会进行持久化。那么下次对这个RDD执行算子操作时，那些没有被持久化的数据，需要从源头上重新计算一遍。这是默认的持久化策略。使用cache()方法时，实际就是使用这种持久化策略 
MEMORY_ONLY_SER
 基本上含义同MEMORY_ONLY一样。唯一的区别是，会将RDD中的数据进行序列化，RDD的每个patition会被序列化成一个字节数组。这种方式更加节省内存，从而可以避免持久化的数据占用过多的内存导致频繁的GC
MEMORY_AND_DISK
 用未序列化的java对象格式，优先尝试将数据保存在内存中。如果内存不够存放数据，会将数据写入磁盘文件中，下次对这个RDD执行算子时，持久化在磁盘文件中的数据会被读取出来使用
MEMORY_AND_DISK_SER
 基本含义同MEMORY_AND_DISK。唯一的区别是，会将RDD中的数据进行序列化，RDD的每个partition会被序列化成一个字节数组。这种方式更加节省内存，从而可以避免持久化的数据占用过多内存导致频繁GC。
  
DISK_ONLY
 使用未序列化的Java对象格式，将数据全部写入磁盘文件中。
  
MEMORY_ONLY_2，MEMORY_AND_DISK_2
等		 

对于上述任意一种持久化策略，如果加上后缀_2，代表的是将每个持久化的数据，都复制一份副本，并将副本保存到其他节点上。这种基于副本的持久化机制主要用于进行容错。假如某个节点挂掉，节点的内存或磁盘中的持久化数据丢失了，那么后续对RDD计算时还可以使用该数据在其他节点上的副本。如果没有副本的话，就只能将这些数据从源头处重新计算一遍了。

 

持久化级别的选择

  • MEMORY_ONLY是我们最理想的持久化选择，因为它不需要序列化与反序列化的操作，就避免了这块性能的开销，对于这个RDD的后续操作都是基于内存里的数据，不需要从磁盘中读取数据，这样就实现了数据本地化，性能非常高，也是我们最理想的状态，相比于带“_2”的持久化级别，MEMORY_ONLY也不需要传送一份备份数据到远程节点上。但是，这一切都要基于内存足够大的基础上，并且如果你的数据量很大，这种情况基本上就是不存在的，因为没有序列化，就会导致数据很大，基本上是原来的2-3倍，假设每天有10亿数据，那每天你要缓存相当于30亿的数据。这时，直接用这种持久化级别，会导致JVM的OOM内存溢出异常。
  • 如果使用MEMORY_ONLY级别时发生了内存溢出，那么建议尝试使用MEMORY_ONLY_SER级别。该级别会将RDD数据序列化后再保存在内存中，此时每个partition仅仅是一个字节数组而已，大大减少了对象数量，并降低了内存占用。这种级别比MEMORY_ONLY多出来的性能开销，主要就是序列化与反序列化的开销。但是后续算子可以基于纯内存进行操作，因此性能总体还是比较高的。此外，可能发生的问题同上，如果RDD中的数据量过多的话，还是可能会导致OOM内存溢出的异常
  • 如果纯内存的级别都无法使用，那么建议使用MEMORY_AND_DISK_SER策略，而不是MEMORY_AND_DISK策略。因为既然到了这一步，就说明RDD的数据量很大，内存无法完全放下。序列化后的数据比较少，可以节省内存和磁盘的空间开销。同时该策略会优先尽量尝试将数据缓存在内存中，内存缓存不下才会写入磁盘。
  • 通常不建议使用DISK_ONLY和后缀为_2的级别：因为完全基于磁盘文件进行数据的读写，会导致性能急剧降低，有时还不如重新计算一次所有RDD。后缀为_2的级别，必须将所有数据都复制一份副本，并发送到其他节点上，数据复制以及网络传输会导致较大的性能开销，除非是要求作业的高可用性，否则不建议使用。

持久化级别测试

 1.MEMORY_ONLY没有注册没有序列化

package com.ruozedata.spark1
import org.apache.spark.storage.StorageLevel
import org.apache.spark.{SparkConf, SparkContext}

/**
  * 使用kryo序列化数据对象,
  * 1、生产山spark.serializer这个配置直接写到spark-default配置文件中即可
  */
object KryoApp {

  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("KyroApp").setMaster("local[2]")
//      conf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
//    conf.registerKryoClasses(Array(classOf[Logger]))

    val sc = new SparkContext(conf)
    val logRDD = sc.textFile("C:\\Users\\小十七\\Desktop/CDN_click.log")
      .map(x => {
      val logFields = x.split(",")
      Logger(logFields(0), logFields(1), logFields(2), logFields(3),
        logFields(4), logFields(5), logFields(6), logFields(7))
    })
     val pesisitRDD = logRDD.persist(StorageLevel.MEMORY_ONLY)
 //val pesisitRDD = logRDD.persist(StorageLevel.MEMORY_ONLY_SER)

    println("总条数" + pesisitRDD.count())
    Thread.sleep(2000000)
    sc.stop()

  }

  case class Logger(filed1: String, filed2: String, filed3: String,
                    filed4: String, filed5: String, filed6: String,
                    filed7: String, filed8: String)

}

 

 

 

从图中可以看出读入的时候是93.6M

缓存以后就是560.4M，是原来的6倍

2.MEMORY_ONLY_SER

package com.ruozedata.spark1
import org.apache.spark.storage.StorageLevel
import org.apache.spark.{SparkConf, SparkContext}

/**
  * 使用kryo序列化数据对象,
  * 1、生产山spark.serializer这个配置直接写到spark-default配置文件中即可
  */
object KryoApp {


  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setAppName("KyroApp").setMaster("local[2]")
//      conf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
//    conf.registerKryoClasses(Array(classOf[Logger]))

    val sc = new SparkContext(conf)
    val logRDD = sc.textFile("C:\\Users\\小十七\\Desktop/CDN_click.log")
      .map(x => {
      val logFields = x.split(",")
      Logger(logFields(0), logFields(1), logFields(2), logFields(3),
        logFields(4), logFields(5), logFields(6), logFields(7))
    })


    // val pesisitRDD = logRDD.persist(StorageLevel.MEMORY_ONLY)
 val pesisitRDD = logRDD.persist(StorageLevel.MEMORY_ONLY_SER)


    println("总条数" + pesisitRDD.count())


    Thread.sleep(2000000)
    sc.stop()

  }

  case class Logger(filed1: String, filed2: String, filed3: String,
                    filed4: String, filed5: String, filed6: String,
                    filed7: String, filed8: String)


}

 

 

由上图可以看出序列化以后，缓存减小到了116M

3.使用Kryo但不注册不序列化

package com.ruozedata.spark1
import org.apache.spark.storage.StorageLevel
import org.apache.spark.{SparkConf, SparkContext}

/**
  * 使用kryo序列化数据对象,
  * 1、生产山spark.serializer这个配置直接写到spark-default配置文件中即可
  */
object KryoApp {


  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setAppName("KyroApp").setMaster("local[2]")
      conf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    //conf.registerKryoClasses(Array(classOf[Logger]))

    val sc = new SparkContext(conf)
    val logRDD = sc.textFile("C:\\Users\\小十七\\Desktop/CDN_click.log")
      .map(x => {
      val logFields = x.split(",")
      Logger(logFields(0), logFields(1), logFields(2), logFields(3),
        logFields(4), logFields(5), logFields(6), logFields(7))
    })


   val pesisitRDD = logRDD.persist(StorageLevel.MEMORY_ONLY)
// val pesisitRDD = logRDD.persist(StorageLevel.MEMORY_ONLY_SER)


    println("总条数" + pesisitRDD.count())


    Thread.sleep(2000000)
    sc.stop()

  }

  case class Logger(filed1: String, filed2: String, filed3: String,
                    filed4: String, filed5: String, filed6: String,
                    filed7: String, filed8: String)


}

 

4.使用Kryo但不注册序列化

package com.ruozedata.spark1
import org.apache.spark.storage.StorageLevel
import org.apache.spark.{SparkConf, SparkContext}

/**
  * 使用kryo序列化数据对象,
  * 1、生产山spark.serializer这个配置直接写到spark-default配置文件中即可
  */
object KryoApp {


  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setAppName("KyroApp").setMaster("local[2]")
      conf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    //conf.registerKryoClasses(Array(classOf[Logger]))

    val sc = new SparkContext(conf)
    val logRDD = sc.textFile("C:\\Users\\小十七\\Desktop/CDN_click.log")
      .map(x => {
      val logFields = x.split(",")
      Logger(logFields(0), logFields(1), logFields(2), logFields(3),
        logFields(4), logFields(5), logFields(6), logFields(7))
    })


//   val pesisitRDD = logRDD.persist(StorageLevel.MEMORY_ONLY)
   val pesisitRDD = logRDD.persist(StorageLevel.MEMORY_ONLY_SER)


    println("总条数" + pesisitRDD.count())


    Thread.sleep(2000000)
    sc.stop()

  }

  case class Logger(filed1: String, filed2: String, filed3: String,
                    filed4: String, filed5: String, filed6: String,
                    filed7: String, filed8: String)


}

5.使用Kryo但注册不序列化

package com.ruozedata.spark1
import org.apache.spark.storage.StorageLevel
import org.apache.spark.{SparkConf, SparkContext}

/**
  * 使用kryo序列化数据对象,
  * 1、生产山spark.serializer这个配置直接写到spark-default配置文件中即可
  */
object KryoApp {


  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setAppName("KyroApp").setMaster("local[2]")
      conf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    conf.registerKryoClasses(Array(classOf[Logger]))

    val sc = new SparkContext(conf)
    val logRDD = sc.textFile("C:\\Users\\小十七\\Desktop/CDN_click.log")
      .map(x => {
      val logFields = x.split(",")
      Logger(logFields(0), logFields(1), logFields(2), logFields(3),
        logFields(4), logFields(5), logFields(6), logFields(7))
    })


   val pesisitRDD = logRDD.persist(StorageLevel.MEMORY_ONLY)
//   val pesisitRDD = logRDD.persist(StorageLevel.MEMORY_ONLY_SER)


    println("总条数" + pesisitRDD.count())


    Thread.sleep(2000000)
    sc.stop()

  }

  case class Logger(filed1: String, filed2: String, filed3: String,
                    filed4: String, filed5: String, filed6: String,
                    filed7: String, filed8: String)


}

6.使用Kryo注册并序列化

package com.ruozedata.spark1
import org.apache.spark.storage.StorageLevel
import org.apache.spark.{SparkConf, SparkContext}

/**
  * 使用kryo序列化数据对象,
  * 1、生产山spark.serializer这个配置直接写到spark-default配置文件中即可
  */
object KryoApp {


  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setAppName("KyroApp").setMaster("local[2]")
      conf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    conf.registerKryoClasses(Array(classOf[Logger]))

    val sc = new SparkContext(conf)
    val logRDD = sc.textFile("C:\\Users\\小十七\\Desktop/CDN_click.log")
      .map(x => {
      val logFields = x.split(",")
      Logger(logFields(0), logFields(1), logFields(2), logFields(3),
        logFields(4), logFields(5), logFields(6), logFields(7))
    })


//   val pesisitRDD = logRDD.persist(StorageLevel.MEMORY_ONLY)
   val pesisitRDD = logRDD.persist(StorageLevel.MEMORY_ONLY_SER)


    println("总条数" + pesisitRDD.count())


    Thread.sleep(2000000)
    sc.stop()

  }

  case class Logger(filed1: String, filed2: String, filed3: String,
                    filed4: String, filed5: String, filed6: String,
                    filed7: String, filed8: String)


}

总结：

  1. 上边的6种情况分别对MEMORY_ONLY，MEMORY_ONLY_SER做了是否序列化和是否使用Kryo注册的测试，从Web界面的Size in Memory这个参数可以看出凡是经过序列化的缓存以后的值不会很大，但是不序列化，无论注册与否值都是非常大的，对于序列化的使用Kryo并注册以后的的值是最理想的，和原始文件的大小非常贴近，只是使用Kryo序列化，而不注册，缓存值稍微大一点113M左右
  2. 对于spark core 生产中只选择MEMORY_ONLY和MEMORY_ONLY_SER这两种存储级别,cpu的计算速度远远大于从内存中读取数据的速度更大于从磁盘中读取数据的速度，有时重新计算数据比读取缓存的数据速度更快，故不需要将数据存多份或者存储磁盘，故spark core生产只选择上述两种存储类型
  3. 序列化使得占用的内存更少，但是序列化以及反序列化是需要耗时的，同时耗费CPU，故具体要根据资源以及业务去选择使用缓存，最好养成结束释放缓存的良好规范

 

 

转载于:https://www.cnblogs.com/xuziyu/p/10914701.html

weixin_38166557
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
每次进步一点点——spark中cache和persist的区别
housir的专栏
09-09 4万+
昨天面试被问到了cache和persist区别，当时只记得是其中一个调用了另一个，但没有回答出二者的不同，所以回来后重新看了源码，算是弄清楚它们的区别了。cache和persist都是用于将一个RDD进行缓存的，这样在之后使用的过程中就不需要重新计算了，可以大大节省程序运行时间。
spark RDD持久化
weixin_34148508的博客
07-18 61
2019独角兽企业重金招聘Python工程师标准>>> ...
RDD的持久化
u012110804的专栏
06-14 326
为什么要持久化 action操作时，触发之前的transform算子，action执行完，只保留了最后的结果，之前的RDD会被丢掉，如果后面又要进行action操作，则需要从最初的RDD重新计算。rdd持久化后，只在第一次计算时，进行计算，之后再使用该RDD直接读取缓存，无需计算。 持久化方式 persist()或cache()，二者的区别是，cache() 方法其实调用的就是persist()
Spark持久化、持久化级别
Black eyes的博客
01-11 2280
一、RDD持久化 Spark 中一个很重要的能力是将数据持久化（或称为缓存），在多个操作间都可以访问这些持久化的数据。当持久化一个 RDD 时，每个节点的其它分区都可以使用 RDD 在内存中进行计算，在该数据上的其他 action 操作将直接使用内存中的数据。这样会让以后的 action 操作计算速度加快（通常运行速度会加速 10 倍）。缓存是迭代算法和快速的交互式使用的重要工具。 RDD 可...
Spark源码之persist方法，cache方法以及StorageLevel
学习，我们是认真的
07-07 5469
今天看Spark源码的时候看到了persist方法与cache方法，这里就说明一下两者的区别，也解决了自己之前的疑惑。cache方法Spark2.11关于cache方法的源码是这样的： /** * Persist this RDD with the default storage level (`MEMORY_ONLY`). * 缓存RDD，缓存级别为仅在内存中 * 这里的cach
【SparkCore篇05】RDD缓存和checkpoint1
08-04
默认情况下，`persist()`使用的是StorageLevel.MEMORY_ONLY，即以序列化形式存储在JVM堆内存中。`cache()`实际上是`persist()`的一个别名，同样默认采用内存存储。当触发一个action操作时，Spark才会真正执行缓存...
Spark RDD以及其特性.rar_RDD_Spark!_parallelbwz_spark_特性
最新发布
09-21
5. **缓存与持久化**：Spark支持将RDD缓存在内存或磁盘中，以便后续任务可以快速重用。持久化有多种级别，如内存仅存储、内存序列化存储、磁盘存储等，用户可以根据需求选择合适的级别。 6. **宽依赖与窄依赖**：...
spark rdd 论文翻译_中文_spark老汤
09-14
例如，它可能包含了关于如何利用Tungsten项目优化内存管理和序列化，以及如何通过shuffle操作的优化来减少网络通信开销的内容。 总结来说，Spark的RDD模型是其高效处理大数据的关键。通过理解RDD的不可变性、血统...
RDD编程初级实践数据集
06-05
- **持久化级别**：可以选择不同的持久化策略，如内存（不序列化、序列化）、磁盘、混合存储等。 7. **交互式编程** - **Spark Shell**：提供了一个交互式的环境，用于快速测试和开发RDD操作。 8. **案例实践** ...
2.rdd使用1
08-03
为了在多个行动操作中重用RDD，可以使用`persist()`方法将RDD缓存到内存中。第一次计算后，Spark会将RDD的分区存储在集群的各个节点上，后续行动操作可以重用这些数据，提高性能。默认情况下，RDD不会自动缓存，因为...
spark Streaming 存储级别定义StorageLevel
swcj的专栏
09-19 6105
目前在kafka 存储级别选项如下：     MEMORY_ONLY 默认选项，RDD的（分区）数据直接以Java对象的形式存储于JVM的内存中，如果内存空间不足，某些分区的数据将不会被缓存，需要在使用的时候根据世代信息重新计算。 MYMORY_AND_DISK RDD的数据直接以Java对象的形式存储于JVM的内存中，如果内存空间不中，某些分
Spark Storage之MemoryStore
u011564172的博客
08-20 4092
介绍MemoryStore的实现及几个重要方法
spark优化----序列化持久化
多哥仁慈的骆驼
10-07 234
简介： 除了对多次使用的RDD进行持久化操作之外，还可以进一步优化其性能，因为很有可能，RDD的数据是持久化到内存，或者磁盘中的，那么此时如果内存大小不是特别充足，完全可以使用序列化的持久化级别， 如下： 1.MEMORY_ONLY_SER 2.MEMORY_AND_DISK_SER 使用RDD.persist(StorageLeve...
大数据入门：Spark持久化存储策略
shuimuzh123的博客
12-14 561
持久化存储是Spark非常重要的一个特性，通过持久化存储，提升Spark应用性能，以更好地满足实际需求。而Spark的持久化存储，根据不同的需求现状，可以选择不同的策略方案。今天的大数据入门分享，我们就来具体讲讲Spark持久化存储策略。 所谓的Spark持久化存储，就是将一个RDD持久化到内存或磁盘中，以便重用该RDD，省去重新计算的环节，以空间换时间。RDD持久化，是一个分布式的过程，其内部的每个Partition各自缓存到所在的计算节点上，根据复用的需求再来读取。 RDD持久化 在Spark
spark序列化溢出
keyuquan的博客
06-17 4134
序列化缓存溢出 Causedby：org.apache.spark.SparkException：Kryo序列化失败：缓冲区溢出。可用：0，必需：21.要避免此情况，请增加spark.kryoserializer.buffer.max Caused by:org.apache.spark.SparkException: Kryo serialization failed: Buffer ove
RDD概念、特性、缓存策略与容错
weixin_30552635的博客
04-01 727
一、RDD概念与特性 1. RDD的概念 　　RDD（Resilient Distributed Dataset），是指弹性分布式数据集。数据集：Spark中的编程是基于RDD的，将原始数据加载到内存变成RDD，RDD再经过若干次转化，仍为RDD。分布式：读数据一般都是从分布式系统中去读，如hdfs、kafka等，所以原始文件存在磁盘是分布式的，spark加载完数据的RDD也是分布式的，换句话...
Spark 调优之RDD持久化级别及kryo序列化性能测试
weixin_33984032的博客
05-19 284
我们上篇文章中讲了，RDD的持久化是spark优化中必须掌握的，并且，在内存不足的情况下，我们可以将持久化类型选择为MEMORY_ONLY_SER，减少内存的占用，持久化更多的partition，并且不同的序列化方法也会影响序列化性能。下面，我们就来测试下，持久化级别和序列化方法的选择对RDD持久化大小的影响。我选择了一个170.9MB的日志文件，传到了百度网盘 提取码：ffae 测试环境是win...
Spark RDD Persistence
zdy0_2004的专栏
11-15 2018
http://www.cnblogs.com/yurunmiao/p/4966393.html Spark最为重要的特性之一就是可以在多个操作（Action）之间，将一个或多个RDD关联的数据集（Dataset）以分区（Partition）为单位进行持久化（Persist）或缓存（Cache），存储介质通常是内存（Memory）。   被持久化或缓存的RDD A可以在两种情况下被
rdd.cache()和rdd.persist(Storage.MEMORY_ONLY)
yisun123456的博客
11-07 245
rdd.cache()和rdd.persist(Storage.MEMORY_ONLY) cache 底层也是调用了persist，但是当内存不足时 persist会吃就会到磁盘，但是cache不会。 所以在绝大数场景下最好使用persist
Spark RDD API：核心功能与操作指南
1. `__init__(self, jrdd, ctx, jrdd_deserializer)`：初始化RDD对象，`jrdd`是从Java层传递过来的RDD对象，`ctx`是SparkContext，`jrdd_deserializer`用于反序列化数据。 2. `source_codeid(self)`：返回RDD在当前...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值