Spark RDD优化

于 2024-08-06 10:35:41 发布
阅读量1.2k 收藏 14
点赞数 36
分类专栏： Spark 文章标签： spark 大数据 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79349971/article/details/140947860
版权

一、分区优化

  • 分区数调整：RDD的分区数可以通过repartition和coalesce方法进行调整。合理的分区数可以提高并行度，但过多的分区会增加管理开销。通常，分区数应根据数据规模和集群资源进行调整。
  1. 缩小分区

        存在过多的小任务的时候收缩合并分区，减少分区的个数，减少任务调度成本
默认情况下，不会对数据重组，比如：3个合成2个，采用 {1+2}，{3}，容易导致数据倾斜
若需数据均衡，则将 shuffle 参数设置为 true 即可

        2、 扩大分区

若需要扩大分区，shuffle 参数必须设置为 true
若将2个分区拆分成3个，必须打乱重新分区，否则数据还是在两个分区(有一个分区为空)，{1}，{2}，{空} 

  • 数据本地性：Spark会尽量将数据分配给与数据源相同的计算节点上，以减少数据移动的开销。在创建RDD时，可以通过设置分区偏好（如preferredLocations）或自定义分区来优化数据本地性，以最小化网络传输并最大化计算效率。

         自定义分区

// 自定义分区器
class MyPartitioner(numPartitions: Int) extends Partitioner {
  override def numPartitions: Int = numPartitions   // 返回分区器的分区数量
  override def getPartition(key: Any): Int = {
      // 这里需要实现分区逻辑
      // 返回值是一个整数，表示该键应该被分配到哪个分区
  }
}

// 使用自定义分区器重新分区  
val partitionedRDD = rdd.partitionBy(new MyPartitioner(2))  // 传入分区个数
  • 处理数据倾斜：数据倾斜是指某些分区包含的数据远远多于其他分区，导致计算资源分配不均。可以使用repartition或coalesce方法重新分区RDD，或使用reduceByKey、groupByKey的变体等特定操作来减轻数据倾斜的影响。

二、持久化优化

  • 持久化策略：对于需要多次使用的RDD，应该进行持久化操作，以避免重复计算。持久化策略包括内存持久化（如MEMORY_ONLY）、磁盘持久化（如DISK_ONLY）以及内存和磁盘混合持久化（如MEMORY_AND_DISK）等。

  • 序列化：使用序列化可以进一步减少内存消耗，并提高持久化效率。Spark支持多种序列化框架，如Java序列化、Kryo序列化等。Kryo序列化通常比Java序列化更快，且占用空间更小。

// 临时存储于【xx】重用，job结束后自动删除 
val rddCache: RDD[T] = rdd.cache()					// 到内存上
val rdd: RDD[T] = rdd.persist(level:StorageLevel)
// cache() 		等价于persist(StorageLevel.MEMORY_ONLY)
// persisit() 	参数如下

StorageLevel.MEMORY_ONLY				只写到内存上
StorageLevel.DISK_ONLY					只写到磁盘上
StorageLevel.OFF_HEAP					使用堆外内存
StorageLevel.MEMORY_AND_DISK			先内存，后磁盘 
StorageLevel.MEMORY_AND_DISK_SER		先内存，后磁盘，采取序列化方式
StorageLevel.MEMORY_AND_DISK_SER_2 		先内存，后磁盘，采取二代序列化方式

  • 检查点：对于需要长时间运行或可能遭受故障的应用，设置检查点（Checkpoint）可以将RDD的状态保存到稳定存储中，以便在故障后恢复。检查点会切断RDD的血统关系，从而避免重新计算整个血统链。

// checkpoint 长久存储于【磁盘】重用，job结束后不会删除，涉及IO性能较差，安全且一般和cache组合使用
val conf = new SparkConf()
    .setAppName("spark_rdd")
    .setMaster("local[4]")
val sc = SparkContext.getOrCreate(conf)
// 设置检查点路径
sc.setCheckpointDir("hdfs://ip:9000/spark/checkpoint")
// ... 
rdd.checkpoint()	// 将该 RDD 的内容写入到设置的路径，并在该 RDD 的计算图中插入一个检查点（Checkpoint）节点

 三、依赖优化

  •  宽依赖与窄依赖：RDD之间的依赖关系分为宽依赖和窄依赖。窄依赖有助于实现数据本地性，而宽依赖则可能导致数据移动和网络开销。在设计RDD转换操作时，应尽量避免不必要的宽依赖。

1、Driver程序提交后

1、Spark调度器将所有的RDD看成是一个Stage
2、然后对此Stage进行逆向回溯，遇到Shuffle就断开，形成一个新的Stage
3、遇到窄依赖，则归并到同一个Stage
4、等到所有的步骤回溯完成，便生成一个DAG图

 2、为什么要划分阶段

1、基于数据的分区，本着传递计算的性能远高于传递数据，所以数据本地化是提升性能的重要途径之一
2、一组串行的算子，无需 Shuffle，基于数据本地化可以作为一个独立的阶段连续并行执行
3、经过一组串行算子计算，遇到 Shuffle 操作，默认情况下 Shuffle 不会改变分区数量，但会因为 numPartitions:Int, partitioner:Partitioner 等参数重新分配，过程数据会【写盘供子RDD拉取(类MapReduce)】

 3、RDD依赖关系

  •         Lineage：血统、遗传

RDD最重要的特性之一，保存了RDD的依赖关系

RDD实现了基于Lineage的容错机制

  •          依赖关系 org.apache.spark.Dependency

窄依赖 NarrowDependency，1V1 OneToOneDependency，1VN RangeDependency
宽依赖 ShuffleDependency

  •          当RDD分区丢失时

 对于窄依赖，Spark只需要重新计算丢失分区的父RDD分区即可。
对于宽依赖，Spark需要重新执行整个shuffle过程，以重新生成丢失的数据。
若配合持久化更佳：cache, persist, checkpoint

 

类型
窄依赖map，flatMap，mapPartitions，mapPartitionsWithIndex，glom，filter，distinct，intersection，sample，union，subtract，zip…，cogroup
宽依赖sortBy，sortByKey，groupByKey，reduceByKey，cogroup，join，partitionBy，repartition
不一定的情况在Spark中，并非所有操作都可以明确地归类为宽依赖或窄依赖。有些操作可能根据具体的实现或上下文而有所不同。然而，在大多数情况下，上述提到的算子可以清晰地划分为宽依赖或窄依赖。

 

 

 

如：reduceByKey(【partitioner: Partitioner】, func: (V, V) => V)
若使用的是带 partitioner 的重载且 Partitioner 和父RDD的 Partitioner一致
则为窄依赖RDD，否则为宽依赖ShuffledRDD
  • 优化转换操作：在可能的情况下，使用能够减少shuffle操作的转换函数，如mapPartitions代替map，reduceByKey代替groupByKey等。这些操作可以减少数据在网络中的传输量，从而提高性能。 
shuffle性能较差：因为shuffle必须落盘，内存中等数据会OOM
groupByKey只分组(存在Shuffle) + reduce只聚合
    <=结果同，性能不同=>
reduceByKey先分组、预聚合、再聚合(存在Shuffle)

四、共享变量优化

  •  广播大变量：当Spark作业中需要使用到较大的外部变量时，可以将这些变量广播到每个节点的Executor上，而不是每个Task都复制一份。这样可以减少网络传输开销和内存消耗。
val bc:Broadcast[T] = sc.broadcast(value:T)		// 创建广播变量  
rdd.mapPartitions(itPar=>{
    val v:T = bc.value	// 在每个分区内部，通过bc.value获取广播变量的值  
    ...					// 使用v进行计算...
})
  •  累加器（Accumulators）：累加器提供了一种有效的手段来进行分布式计算中的统计和计数操作，减少通信开销，并简化聚合操作。

累加器：accumulate：只能 add 操作，常用于计数
1、定义在Driver端的一个变量，Cluster中每一个Task都会有一份Copy
2、所有的Task都计算完成后，将所有Task中的Copy合并到驱动程序中的变量中
非累加器：在所有Task中的都会是独立Copy，不会有合并

val accLong: LongAccumulator = sc.longAccumulator("longAcc")	// 定义累加器
val accDouble: DoubleAccumulator = sc.doubleAccumulator("doubleAcc")
rdd.mapPartitions(itPar=>{
    ...
    accLong.add(v:Long)		// 将值添加到累加器中
    accDouble.add(v:Double)
    ...
})
accXxx.reset()		// 重置累加器
val isZero:Boolean = accXxx.isZero	// 检查累加器是否为零值
val num:Long|Double = accXxx.value|sum|count|avg // 获取累加器的值、总和、计数或平均值

// 定义一个累加器，用于统计 "bad" 记录的数量
val errorCount = sc.longAccumulator("Error Count")
val data = sc.parallelize(Array("good", "bad", "good", "bad", "good"))
data.foreach(record => if (record == "bad") errorCount.add(1))
// 打印累加器的值，即 "bad" 记录的总数
 println(s"Total errors: ${errorCount.value}")

 自定义累加器：

写一个类继承 import org.apache.spark.util.AccumulatorV2[IN, OUT]

abstract class AccumulatorV2[IN, OUT] extends Serializable {
    // 返回是否为零值累加器
    def isZero: Boolean

    // 创建此累加器的新副本，其为零值
    def copyAndReset(): AccumulatorV2[IN, OUT] = {...}

    // 创建此累加器的新副本
    def copy(): AccumulatorV2[IN, OUT]

    // 重置此累加器为零值
    def reset(): Unit

    // 添加：接收输入并累加
    def add(v: IN): Unit

    // 合并：合并另一个相同类型的累加器并更新其状态
    def merge(other: AccumulatorV2[IN, OUT]): Unit

    // 当前累加器的值
    def value: OUT
}

  • 自定义计量器优化（Custom Metrics）：自定义计量器允许用户定义和收集特定的性能指标，提供更细粒度的作业监控和调优能力。通过 SparkListener 接口，可以实现自定义的监听器来监控和记录所需的指标。

 五、提交模式与运行模式优化

  • 提交模式：Spark支持Client模式和Cluster模式两种提交方式。Client模式便于查看日志和结果，但可能消耗较多资源；Cluster模式则更适合大规模作业，但查看日志和结果可能不太方便。应根据实际情况选择合适的提交模式。
spark-submit --class <MainClass> --master <MasterURL> --deploy-mode <DeployMode> <PathToJar>

<MainClass>：包含 main 方法的主类的名称。

<MasterURL>：指定集群的 Master URL。

<DeployMode>：指定提交模式，可以是 client 或 cluster。

<PathToJar>：包含 Spark 应用程序的 JAR 文件的路径。

spark-submit --class SparkClientModeApp --master yarn --deploy-mode client /path/to/your/jarfile.jar	
spark-submit --class SparkClientModeApp --master yarn --deploy-mode cluster /path/to/your/jarfile.jar
  • 运行模式：Spark支持多种运行模式，如Local模式、Standalone模式、YARN模式等。不同的运行模式适用于不同的场景和需求。例如，Local模式适用于本地开发和测试；Standalone模式适用于构建独立的Spark集群；YARN模式则适用于与Hadoop生态系统集成

local: 在单核上运行
local[N]: 在指定数量的 N 个核上运行，如 “local[4]”
local[*]: 使用所有可用的核
spark://HOST:PORT: 连接到指定的 Spark standalone cluster
yarn: 连接到 YARN 集群
mesos://HOST:PORT: 连接到 Mesos 集群

 六、其他优化

  • 序列化框架选择：除了Kryo序列化外，还可以考虑使用其他高效的序列化框架来优化Spark作业的性能。
  • 监控与调优：使用Spark提供的监控工具和API（如Spark UI、getStorageLevel方法等）来监控作业的运行状态和性能瓶颈，并根据监控结果进行调优。
遗憾还会等她吗
关注
  • 36
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二、Spark性能调优——RDD优化
嘻哈吼嘿呵的博客
10-09 234
1 RDD 复用 在对 RDD 进行算子时， 要避免相同的算子和计算逻辑之下对 RDD 进行重复的计算， 优化前如图 优化后如图 2 RDD 持久化 在 Spark 中，当多次对同一个 RDD 执行算子操作时， 每一次都会对这个 RDD以之前的父 RDD 重新计算一次，这种情况是必须要避免的，对同一个 RDD 的重复计算是对资源的极大浪费，因此， 必须对多次使用的 RDD 进行持...
spark性能优化指南
a814046606的博客
09-26 254
在大数据计算领域，Spark已经成为了越来越流行、越来越受欢迎的计算平台之一。Spark的功能涵盖了大数据领域的离线批处理、SQL类处理、流式/实时计算、机器学习、图计算等各种不同类型的计算操作，应用范围与前景非常广泛。在美团•大众点评，已经有很多同学在各种项目中尝试使用Spark。大多数同学（包括笔者在内），最初开始尝试使用Spark的原因很简单，主要就是为了让大数据计算作业的执行速度更快、性能...
【Spark】性能优化：RDD优化
sunwenxu的博客
08-02 391
1、对于RDD中某些函数使用注意 （1）能不使用groupByKey函数就不使用，除非不得已 redcueByKey（combiner） = groupBy+ map(变量值相加) redcueByKey可以先进行本地聚合操作 （2）尽量使用XXPartition函数代替XX函数 xx:map/foreach/zip def foreach(f: T => Unit): Unit f:针对...
Spark性能优化：RDD方法优化
Iamarookie999的博客
08-02 364
对于RDD中某些函数使用注意 1.能不使用groupByKey函数就不使用，除非不得已 redcueByKey（combiner） = groupBy+ map(变量值相加) redcueByKey可以先进行本地聚合操作 2.尽量使用XXPartition函数代替XX函数 xx:map/foreach/zip def foreach(f: T...
SparkRDD优化（二）之SparkRDD共享变量（广播变量，累加器）
qianchun22的博客
11-13 285
一、广播变量(broadcast variable) 广播变量：允许开发者将一个只读变量（Driver端）缓存到每个节点（Executor）上，而不是每个任务传递一个副本 图解： 定义广播变量 val arr = Array("java","scala","spark") val broadcast = sc.broadcast(arr) 注意：变量一旦被定义为一个广播变量，那么这个变量只能读，不能修改 访问广播变量方式 val c = broadcast.value 案例： object Broad
hbase-rdd：Spark RDD从HBase读取，写入和删除
02-05
要将 Spark 与 HBase 集成，我们需要使用 `hbase-rdd` 库，它提供了 Spark 和 HBase 之间的桥梁。这个库允许我们将 HBase 表作为 RDD 处理，并且支持将 RDD 写回到 HBase。 1. **配置 Spark 与 HBase 连接** 在...
Spark RDD分区和数据分布：优化大数据处理
晓晓的天空
12-28 1397
在Spark中，RDD（弹性分布式数据集）是数据处理的核心抽象，而RDD的分区是Spark中的重要概念之一。分区是将RDD的数据划分成多个逻辑块的方式，每个分区都包含数据的一部分。这些分区可以并行处理，以充分利用集群的计算资源。分布式性：RDD的分区将数据分布在集群中的多个计算节点上，以实现并行计算。每个计算节点都可以处理自己的分区，从而提高性能。数据局部性：分区通常会尽量将数据放置在与数据源相同的计算节点上，以减少数据移动的开销。这有助于提高性能，因为在同一节点上访问本地数据比跨节点访问数据要快得多。
Spark 优化之：RDD算子优化(篇幅很长，耐心看完收获满满)
AriesLY0411的博客
04-26 906
RDD算子调优 1. 避免RDD复用 在对RDD进行算子时，要避免相同的算子和计算逻辑之下对RDD进行重复的计算，如下图所示 对上图中的RDD计算架构进行修改，得到如下图所示的优化结果： 一个简单的案例 // 需要对名为“hello.txt”的HDFS文件进行一次map操作，再进行一次reduce操作。 //也就是说，需要对一份数据执行两次算子操作。 // 错误的做法：对于同一份数据执行多次算子操作时，创建多个RDD。 // 这里执行了两次textFile方法，针对同一个HDFS.
Spark RDD详解与优化
s441764347的博客
09-03 700
Spark RDD详解与优化Spark的特性RDD的五大属性Spark的运行模式Spark提交模式RDD的shuffleRDD的广播变量RDD的stage及宽窄依赖和血统RDD的persist、cache与checkpointSpark分布执行时的序列化问题Spark常见JDBChbase on Spark和Spark on hbaseCassandra on SparkSpark on hive和hive on SparkRDD的常用算子转换算子（其返回值为另一个RDD的算子）action算子（返回值非R
Spark优化(一)：避免重复RDD
Winner941112的博客
09-29 2339
避免创建重复的RDD 通常来说，我们在开发一个Spark作业时，首先是基于某个数据源（比如Hive表或HDFS文件）创建一个初始的RDD；接着对这个RDD执行某个算子操作，然后得到下一个RDD，以此类推，循环往复，直到计算出最终我们需要的结果。   在这个过程中，多个RDD会通过不同的算子操作（比如map、reduce等）串起来，这个“RDD串”，就是RDD lineage，也就是“RDD...
理解 SparkSQL DataFrame 对 RDD 的优化
最新发布
fanghailiang2016的博客
04-06 826
Spark 只知道开发者要做 map、filter，但并不知道开发者打算怎么做 map 和 filter。换句话说，对于 Spark 来说，辅助函数 f 是透明的。在 RDD 的开发框架下，Spark Core 只知道开发者要“做什么”，而不知道“怎么做”。这让 Spark Core 两眼一抹黑，除了把函数 f 以闭包的形式打发到 Executors 以外，实在是没有什么额外的优化空间。而这，就是 RDD 之殇。
spark新能优化之多次使用RDD的持久化或checkPoint
weixin_34062469的博客
07-13 132
如果程序中，对某一个RDD，基于它进行了多次transformation或者action操作。那么就非常有必要对其进行持久化操作，以避免对一个RDD反复进行计算。 此外，如果要保证在RDD的持久化数据可能丢失的情况下，还要保证高性能，那么可以对RDD进行Checkpoint操作。（也就是多次用到中间RDD的生成值时可以持久化再checkPoint（当持久化数据没的时候会去checkPoint中寻...
总结：Spark性能优化上的一些总结
MrLevo520的博客
08-13 2418
Spark性能调优 整理来自于： Spark性能优化指南——基础篇​ 会增加： 一些其他博客的内容 自己的理解和pyspark代码的补充实践 开发调优 Spark性能优化的第一步，就是要在开发Spark作业的过程中注意和应用一些性能优化的基本原则。开发调优，就是要让大家了解以下一些Spark基本开发原则，包括：RDD lineage设
spark性能调优之重构RDD架构，RDD持久化
涛涛的专栏
09-28 2411
当第一次对RDD2执行算子，获取RDD3的时候，就会从RDD1开始计算，就是读取HDFS文件，然后对RDD1执行算子，获取到RDD2，然后再计算，得到RDD3 默认情况下，多次对一个RDD执行算子，去获取不同的RDD；都会对这个RDD以及之前的父RDD，全部重新计算一次；读取HDFS->RDD1->RDD2-RDD4 这种情况，是绝对绝对，一定要避免的，一旦出现一个RDD重复计算的情况
Spark性能调优：RDD的复用以及RDD持久化
行走的树
12-04 6915
避免创建重复的RDD通常来说，开发一个Spark作业时，首先是基于某个数据源（比如Hive表或HDFS文件）创建一个初始的RDD；接着对这个RDD执行某个算子操作，然后得到下一个RDD；以此类推，循环往复，直到计算出最终我们需要的结果。在这个过程中，多个RDD会通过不同的算子操作（比如map、reduce等）串起来，这个“RDD串”，就是RDD lineage，也就是“RDD的血缘关系链”。我们在开
[Spark进阶]-- rdd详解及开发优化
欢迎来到我的博客，一起探索代码里的世界！
11-12 2728
spark rdd详解及开发优化 文章英文来源：http://spark.apache.org/docs/latest/programming-guide.html 一、Spark RDD详解   1、RDD是什么？RDD：Spark的核心概念是RDD (resilientdistributed dataset)，指的是一个只读的，可分区的分布式数据集，            这个数据集的...
Spark性能优化指南——高级篇
美团技术团队
05-12 8026
前言 继基础篇讲解了每个Spark开发人员都必须熟知的开发调优与资源调优之后，本文作为《Spark性能优化指南》的高级篇，将深入分析数据倾斜调优与shuffle调优，以解决更加棘手的性能问题。 数据倾斜调优 调优概述 有的时候，我们可能会遇到大数据计算中一个最棘手的问题——数据倾斜，此时Spark作业的性能会比期望差很多。数据倾斜调优，就是使用各种技术方案解决不同类型的数据倾斜问题...
Spark RDD API详解与核心操作
使用Spark的RDD API时，需要注意的是，尽管Transformations不会立即执行，但每次调用Action都会触发整个计算流程，因此合理设计Transformations和Actions的组合可以优化性能。此外，使用`persist()`或`cache()`可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值