Spark中cache、persist、checkpoint三者的比较

已于 2022-05-05 10:47:10 修改
阅读量2.5k 收藏 5
点赞数 5
分类专栏： SPARK 文章标签： 大数据 spark
于 2022-04-23 20:41:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AnameJL/article/details/124362219
版权

  在Spark的数据处理过程中我们可以通过cache、persist、checkpoint这三个算子将中间的结果数据进行保存，这里主要就是介绍这三个算子的使用方式和使用场景

1. 三者的使用

1.1 cache的讲解与使用

  cache算子可以将spark任务的中间结果数据缓存到内存当中，用以优化数据处理的时效性，这里结合代码进行讲解。
  首先这里准备好数据文件

# 通过命令我们可以看到数据文件有4592639 行
[root@lx01 bin]# wc -l /root/log-t.txt
4592639 /root/log-t.txt
# 将数据文件上传至hdfs，并对文件重命名
[root@lx01 ~]# hdfs dfs -put /root/log-t.txt /log/log01
[root@lx01 ~]# hdfs dfs -put /root/log-t.txt /log/log02
[root@lx01 ~]# hdfs dfs -put /root/log-t.txt /log/log03
[root@lx01 ~]# hdfs dfs -put /root/log-t.txt /log/log04
[root@lx01 ~]# hdfs dfs -put /root/log-t.txt /log/log05
[root@lx01 ~]# hdfs dfs -put /root/log-t.txt /log/log06
[root@lx01 ~]# hdfs dfs -put /root/log-t.txt /log/log07

在这里插入图片描述
这里可以看到文件的大小是65.7MB

# 这里为了方便直接启动spark-shell对数据进行处理
[root@lx01 bin]# ./spark-shell --master spark://lx01:7077 --executor-memory 4G --total-executor-cores 2

进入spark-shell后，我们对文件简单的做一个行数统计，然后看一下耗时时间

Welcome to
      ____              __
     / __/__  ___ _____/ /__
    _\ \/ _ \/ _ `/ __/  '_/
   /___/ .__/\_,_/_/ /_/\_\   version 3.0.0
      /_/

Using Scala version 2.12.10 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_231)
Type in expressions to have them evaluated.
Type :help for more information.

scala>  val lines = sc.textFile("hdfs://lx01:8020/log")
lines: org.apache.spark.rdd.RDD[String] = hdfs://lx01:8020/log MapPartitionsRDD[1] at textFile at <console>:24

scala> lines.count
res0: Long = 32148480

scala> lines.count
res1: Long = 32148480

scala> lines.count
res2: Long = 32148480

scala> lines.count
res3: Long = 32148480

统计完可以看到是32148480，这里我们看一下时间
在这里插入图片描述
通过上图我们可以看到查询这里数据总耗时最快可达到2s，这里我们开始使用cache算子，将数据缓存到内存当中，然后再查询数据的总行数，这里要注意cache算子并非action算子，所以要执行一次action算子cache算子才会生效。

# 这里我们还是使用的action算子还是count
scala> lines.cache
res4: lines.type = hdfs://lx01:8020/log MapPartitionsRDD[1] at textFile at <console>:24

scala> lines.count
res5: Long = 32148480

我们先砍一下将数据存储到内存中，然后在使用count算子计算总行数的耗时时长
在这里插入图片描述

通过上图我们可以看到，这次使用cache算子后，比未使用cache算子的耗时时长还要多5s，这是因为我们在执行count时不仅要从hdfs中读取数据计算行数，还要将数据存储到内存中，所以时间更长，下面我们在直接执行一次count并看一下耗时时长

scala> lines.count
res3: Long = 18370560

在这里插入图片描述
通过上图我们可以看到，数据存储到内存中后我们再直接使用count时，计算速度提高了几十倍，从这里也说明了一个问题，只有中间结果的数据被重复利用的时候，我们使用cache算子才有意义，如果整个spark程序对同一数据只执行一次action算子，我们将数据存储到内存中不仅没有任何意义，还会降低数据处理的时效性，并且浪费资源，这里为什么说浪费资源，因为cache算子是将数据以java对象的形式存储，作为开发人员我们都清楚以java对象进行存储的方式是很重的，这里我读取的文件每个都是65.7MB，一共读取了7个，我们看一下数据存储到内存中后的大小
在这里插入图片描述

通过上图我们可以看到，459.9MB的数据存储到内存中后就变成了2.3GB，从这里就可以看出，cache算子对内存的开销是极大的，如果不对脏数据进行处理，或者进行一些数据筛选，直接将数据存储到内存中，是很浪费资源的，再就是上面提到的，只有一次action不要使用cache算子，其实persist也是一样的。

1.2 persist的讲解与使用

  persist算子相对于cache算子要更加的灵活，persist可以配置中间结果数据存储级别，存储数据的副本数据量等。而且通过翻看源码我们可以看到cache算子底层调用的就是persist算子

  /**
   * Persist this RDD with the default storage level (`MEMORY_ONLY`).
   */
  def cache(): this.type = persist()

通过上面的源码我们可以看到cache算子使用的就是persist算子的MEMORY_ONLY，这里我们官网看一下persist的存储级别都有哪些
在这里插入图片描述
通过上图我们可以看到persist的存储级别是很丰富的，这里我们可以根据具体的需求选择对应的存储级别。
这里我们重新开启一个spark-shell，用以测试persist算子

[root@lx01 bin]# ./spark-shell --master spark://lx01:7077 --executor-memory 4G --total-executor-cores 2
Welcome to
      ____              __
     / __/__  ___ _____/ /__
    _\ \/ _ \/ _ `/ __/  '_/
   /___/ .__/\_,_/_/ /_/\_\   version 3.0.0
      /_/

Using Scala version 2.12.10 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_231)
Type in expressions to have them evaluated.
Type :help for more information.

scala>

这里我们先测试persist的DISK_ONLY的效率,还是以相同的文件

# 这里还是先测试直接做count的时效
scala> val lines = sc.textFile("hdfs://lx01:8020/log")
lines: org.apache.spark.rdd.RDD[String] = hdfs://lx01:8020/log MapPartitionsRDD[1] at textFile at <console>:24

scala> lines.count
res0: Long = 32148480

scala> lines.count
res1: Long = 32148480

scala> lines.count
res2: Long = 32148480

scala> lines.count
res3: Long = 32148480

在这里插入图片描述
可以看到最高时效还是2s
这里我们再将数据以DISK_ONLY的方式进行存储

# 因为这里使用的是spark-shell,我们要先进行导包
scala> import org.apache.spark.storage.StorageLevel
import org.apache.spark.storage.StorageLevel

scala> lines.persist(StorageLevel.DISK_ONLY)
res4: lines.type = hdfs://lx01:8020/log MapPartitionsRDD[1] at textFile at <console>:24

scala> lines.count
res5: Long = 32148480

在这里插入图片描述
通过上图我们可以看到,使用persist算子的DISK_ONLY存储耗时为6s,和使用cache算子时的原理是相同的,不仅要从hdfs读取数据做count计算,还要将数据存储到本地磁盘,但是我们可以看到,将数据存储到本地磁盘比存储到内存的总耗时小,我们在使用cache的时候耗时7s,使用persist的DISK_ONLY存储耗时6s,造成这样的原因就是存储到本地磁盘的数据是从hdfs读取的原始数据文件,而存储到内存中的数据是以java对象的形式存储,多了很多附加信息,如下图
在这里插入图片描述
每个文件为65.7MB,7个文件正好是459.9MB
这里我们再测试一下,存储到磁盘后的数据计算时效性

scala> lines.count
res3: Long = 18370560

在这里插入图片描述
通过上图可以看到,将数据存储到本地磁盘后,在做count计算用时1s,相对于直接做count的计算速度还是翻倍的,但是相对于存储到内存中还是慢了不少,比直接做count快是因为做计算时是从本地磁盘读取的数据,而不从hdfs上读取的数据,而且数据量越大,时效性的差距越明显.
使用本地磁盘的存储方式和内存存储相比,虽然时效性下降,但是可利用的存储资源更多,而且比内存存储更节约资源.
这里我们在测试一下内存和磁盘并用,重复的代码这里就省略了

scala> lines.persist(StorageLevel.MEMORY_AND_DISK)
res0: lines.type = hdfs://lx01:8020/log MapPartitionsRDD[1] at textFile at <console>:24

scala> lines.count
res1: Long = 32148480

在这里插入图片描述
这里可以看到将数据做count计算的同时,并将数据存储到内存和本地磁盘中总耗时19s

这里我们在直接执行一次count计算,看一下耗时

scala> lines.count
res2: Long = 32148480

在这里插入图片描述
可以看到总耗时为0.1s,和直接将数据存储到内存后再进行计算的速度是相同的,这是因为我们将数据同时存储到内存和本地磁盘中后,再重复利用这些数据时,会优先读取内存中的数据.当内存中的数据丢失时才会读取本地磁盘中存储的数据.

1.3checkpoint 的讲解与使用

  checkpoint算子同样是将中间结果数据进行存储,不过它是将数据存储到高可靠,高可用的文件系统HDFS,相对于cache和persist是更加安全的.

# 使用checkpoint的时候注意,一定要先设置checkpoint在hdfs存储数据的路径
scala> sc.setCheckpointDir("hdfs://lx01:8020/check")

scala> val lines = sc.textFile("hdfs://lx01:8020/log")
lines: org.apache.spark.rdd.RDD[String] = hdfs://lx01:8020/log MapPartitionsRDD[1] at textFile at <console>:24

scala> lines.checkpoint

scala> lines.count
res2: Long = 32148480

这里我们先看一下已经配置好的checkpoint的HDFS路径是否有数据
在这里插入图片描述
用过上图可以看到在check路径下已经有了7个数据块
在这里插入图片描述
这里执行了6s,比直接执行count算子要多出4s,就是因为我们在计算数据的同时也在将数据存储到HDFS上.

2. 三者的比较

2.1 优缺点

  • cache
    优点: 对相同的数据进行处理是,时效性最高,可以大大提高spark程序的时效性能
    缺点: 很耗费内存资源,如果数据量较大并不适用cache
  • persist
    优点: 可以进行灵活的配置,如果内存不够大,可以将中间结果数据存储到本地磁盘,同cache相比时效性降低,但是同样比直接从hdfs读取数据做计算要高出几倍的效率,而且如果将数据存储到本地磁盘相对于只将数据存储到内存中要更加安全
    缺点: 虽然persist可以将数据存储到内存或者磁盘,但是对单节点的磁盘和内存资源存在一定的限制性
  • checkpoint
    优点: 将中间结果数据存储到HDFS中能更加能确保中间结果数据的安全性
    缺点: 重复利用中间结果数据时,还是和HDFS进行交互,时效性相对于内存存储和本地磁盘存储较低

2.2 使用场景

  • cache
    当中间结果数据的数据量较小,并且要求的时效性较高时比较适合使用cache算子
  • persist
    当单一的内存存储无法满足业务需求时,或者中间结果数据给内存造成很大压力时,可以使用persist算子
  • checkpoint
    当中间结果数据极其宝贵,对数据的安全要求较高时,比如使用机器学习可能程序执行几天才的到的模型数据,这一类数据的安全性能要求相对较高,就比较适用于checkpoint算子.

以上就是对cache,persist,checkpoint的介绍,这三者有一个共同点,就是数据的重复利用,如果对相同的中间结果数据只执行一次action算子是没有必要使用这三个算子的,读取中间结果数据的优先级:内存<–磁盘<–hdfs,对于这三者的介绍就结束了,相对来说比较齐浅显,希望对有疑问的朋友有所帮助.

飞天小老头
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark中cache和persist函数区别详解
CSDN 精品推荐
08-19 352
cache()存储级别默认为可以选择不同的存储级别使用场景想要使用默认存储级别持久化 RDD 时需要根据资源和性能需求选择不同存储级别时灵活性较低（使用默认的存储级别）高（可以选择不同的存储级别）简单来说，cache()是一种简化的持久化方式，适合于需要快速、简单持久化的场景。而persist()提供了更大的灵活性，允许开发者根据具体的需求选择不同的存储级别。
Spark中cache、persist、checkPoints函数区别详解
最新发布
CSDN 精品推荐
08-19 224
请注意，选择何种方式来处理RDD，取决于具体的应用场景和资源状况。例如，在需要高容错性和数据在跨job中共享的场景下，可能会倾向于使用。而在追求计算性能和资源优化的场景下，可能会使用。
spark 的checkpoint与cache、persist的区别
祁东握力的博客
02-18 537
转载自：https://www.jianshu.com/p/b0a66c64bd85 ----- 这一段是我的补充 persist其实也可以选择把数据存到磁盘中（没找到能够存hdfs的方法，所以应该是存在executor执行的机器的本地磁盘，当然，可以存多份） 而checkpoint既可以选择存在本地磁盘，也可以选择存到hdfs，具体在配置文件中配置。 其他的区别其实就是下面正文讲的了。...
Spark cache、persist和checkpoint
paccumtreal的博客
07-05 300
先简单的说一下对spark  core的一些理解：spark核心是RDD，也就是弹性分布式数据集。一个RDD上有多个partition。计算过程是一个有向无环图DAG。DAG由一个个的stage组成。stage划分规则是遇到宽依赖就划分一个stage。宽依赖和shuffle有关，在lineage中，父RDD上partition数据分配到子RDD的partition上,一对一，可直接传递数据，不需要...
Spark入门-Cache、Persist and Checkpoint
汪巡的博客
09-11 115
Spark 在运算过程中提供了几个不同程度的持久化操作，通过将数据保存在内存中、磁盘中或者 HDFS 中来满足我们计算中的持久化需求。 持久化（Persist、Cache） 在实际开发中某些 RDD 的计算或转换可能会比较耗费时间，如果这些 RDD 后续还会频繁的被使用到，那么可以将这些 RDD 进行持久化/缓存，这样下次再使用到的时候就不用再重新计算了，提高了程序运行的效率。Spark 提供了 Persist 和 Cache 两个操作对 RDD 的运算结果进行持久化。 先看一个例子，我们要对一个文件内的单
spark中cache()、persist()、checkpoint()解析
微信公众号：一颗向上的草莓
05-03 465
Spark对RDD的持久化操作(cache()、persist()、checkpoint())是很重要的，可以将rdd存放在不同的存储介质中，方便后续的操作能重复使用。 cache() persist() cache和persist都是用于将一个RDD进行缓存，这样在之后使用的过程中就不需要重新计算，可以大大节省程序运行时间。 cache和persist的区别：cache只有一个默认的缓存级...
Spark cache和checkpoint
freefish_yzx的博客
08-26 1124
本文阐述了Spark中几种数据持久化方法Cache/Persist/Checkpoint的用法以及区别和联系，对于计算链条过长或者数据量较大的Spark任务有指导意义。原文来自：https://github.com/JerryLead/SparkInternals/blob/master/markdown/6-CacheAndCheckpoint.md           作为区
《Spark 6》--Spark的缓存机制（cache 和 persist）、检查点（checkpoint）机制、以及二者的联系与区别
yk_3215123的博客
08-06 1219
缓存 ：cache / persist 1.spark的缓存级别参照【org.apache.spark.storage.StorageLevel.scala】 在persist()中可以指定一个StorageLevel,当StorageLevel为MEMORY_ONLY时就是cache. ...
spark中cache persis checkpoint的区别
04-26
在Spark中，cache、persist和checkpoint这三个操作都可以用来提高RDD的计算性能，但它们的作用并不完全相同。 cache操作是把RDD数据缓存在内存中，以便重复使用，可以提高计算速度。 persist操作跟cache操作类似，...
Spark Cache 和 Checkpoint 区别
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
02-22 495
cache checkpoint rdd.persist(StorageLevel.DISK_ONLY) 使用场景 会被重复使用的（但不能太大） 运算时间很长或运算量太大才能得到的 RDD，computing chain 过长或依赖其他 RDD 很多的 RDD 存储位置 内存 磁盘或HDFS 磁盘或HDFS 是否保存血缘关系 保存血缘关系（内存不可靠，cache丢失时可以重新计算） 不保存血缘关系（HDFS可靠保存） ...
SparkRDD三种数据持久化/数据重用（persist cache checkpoint）
楠楠好难
04-25 529
一般情况下，RDD的计算过程是不会保留数据的。所以在重复使用RDD对象时，并不会重用数据，而是又重新计算了一遍，浪费资源、时间。 为了实现数据的重用，避免重复计算，需要进行持久化操作 当然，对于某些大数据量、计算时间过长的操作来说，因为有可能出现计算错误而导致从源头开始又计算一遍的情况，所以也需要进行数据持久化操作。 persist() persist()会把数据临时缓存在内存、磁盘当中（可手动指定）。若涉及到磁盘IO，则性能会受到影响。但保存在磁盘时数据也会较为安全。如果只保存在内存当中（StorageL
SparkRDD缓存机制（cache,persist）检查点机制（容错机制）：Checkpoint 
徐磊的博客
02-04 1077
目录 RDD缓存（缓存算子都是延迟算子，都需要执行算子激活） 一、persist 二、cache 三、persist和cache的缺点： 注意事项： 四、persist和cache的 不同点： 相同点： 五、Checkpoint 5.1、使用Checkpoint的必要性 5.2、Persist和Checkpoint使用场景 5.3、Checkpoint使用方法 ...
Spark:cache和persist和checkpoint
weixin_48109576的博客
08-14 157
只缓存到内存 cache底层调用的是persist方法，可以指定其他存储级别 cache和persist方法，严格来说，不是Transformation，应为没有生成新的RDD，只是标记当前rdd要cache或persist cache、persist的使用场景：一个application多次触发Action，为了复用前面RDD计算好的数据，避免反复读取HDFS（数据源）中的数据和重复计算缓存，可以将数据缓存到内存或磁盘【executor所在的磁盘】，第一次触发action才放入到内存或磁盘，以后再出
循序渐进大数据组件之--Spark中cache和persist的区别
Alex的博客
12-29 532
1.首先解释一下这两个方法的作用： 为spark做持久化，cache和persist都是用于将一个RDD进行缓存的，这样在之后使用的过程中就不需要重新计算了，可以大大节省程序运行时间 Spark 中一个很重要的能力是将数据持久化（或称为缓存），在多个操作间都可以访问这些持久化的数据。当持久化一个 RDD 时，每个节点的其它分区都可以使用 RDD 在内存中进行计算，在该数据上的其他 action 操作将直接使用内存中的数据。这样会让以后的 action 操作计算速度加快（通常运行速度会加速 10 倍）。缓
spark中cache和persist算子的区别
jiedaodezhuti的博客
10-12 481
基于spar-k2.4.0的源码对两个算子进行分析它们之间的区别 首先，看下cache（）算子的源码 def cache(self): """ Persist this RDD with the default storage level (`MEMORY_ONLY`). """ self.is_cached = True self.persist(StorageLevel.MEMORY_ONLY) return self 该算子调用了persist()算子
Spark中CheckPoint、Cache、Persist的用法、区别
Alian_W的博客
02-07 1559
Spark中CheckPoint、Cache、Persist 大家好，我是一拳就能打爆A柱的猛男 这几天看到一套视频《尚硅谷2021迎新版大数据Spark从入门到精通》，其中有关于检查点（CheckPoint）的内容，所以就给大家以文字的形式复盘一下。接下来的顺序是：Spark关于持久化的描述、Cache用法、Persist用法、CheckPoint用法。中间会讲解三者之间的关系。 1、Spark关于持久化的描述 在Spark官网，我可以找到关于RDD持久化的全部内容就是如下的内容： RDD Persis
persist、cache和checkpoint的区别与联系
Aspirin's Nest
12-08 817
相同点 这这三个函数是出于不同情况下的容灾和性能考虑而出现的三个函数。他们的主要作用就是将中间结果缓存到存储介质中以便一定程度的对程序进行优化。 但是如果不明白他们的区别与内涵还是很容易会用不好的。 欢迎关注公众号：大数据报文 persist persist还是它们三个之中变换最多的函数，所以先从persist讲起。 persist提供了很多常量参数作为存储等级： useDisk, u...
Spark的缓存Cache
qq_45578476的博客
11-28 178
使用原因 Spark RDD是惰性求值的，当对于RDD使用简单的调用操作时，Spark会每次都重算RDD及其依赖，增大损耗。为了减轻损耗避免RDD的重算且复用RDD的目的，就需要使用Spark的缓存Cache。 在spark交互中：同样的处理数据比较缓存和不缓存的区别 启动hdfs,zookeeper,spark 在Spark下的bin中启动spark-shell 交互指令快速生成：在bin目录...
Spark中的cache和persist
Mr.Phoebe的专栏
02-08 5781
Spark中cache和persist的作用以及存储级别 前言 Spark开发高性能的大数据计算作业并不是那么简单。如果没有对Spark作业进行合理的调优，Spark作业的执行速度可能会很慢，这样就完全体现不出Spark作为一种快速大数据计算引擎的优势来。因此，想要用好Spark，就必须对其进行合理的性能优化。 有一些代码开发基本的原则，避免创建重复的RDD，尽可能复用同一个RDD，如下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值