大数据 - Spark系列《六》- RDD详解

Spark系列文章:

大数据 - Spark系列《一》- 从Hadoop到Spark:大数据计算引擎的演进-CSDN博客

大数据 - Spark系列《二》- 关于Spark在Idea中的一些常用配置-CSDN博客

大数据 - Spark系列《三》- 加载各种数据源创建RDD-CSDN博客

大数据 - Spark系列《四》- Spark分布式运行原理-CSDN博客

大数据 - Spark系列《五》- Spark常用算子-CSDN博客

目录

6.1 RDD 属性

1.分区列表

2.分区计算逻辑

3.RDD 之间的依赖关系

4.可选的分区器

5.计算任务的首选地址

6.2 RDD 分区

6.2.1 原始RDD

1.集合

2.文件

textFile的切片原理和设置切片大小的规则

3.数据库

6.2.2 由转换算子转换的RDD

实例1:(distinct算子可以指定分区个数)

实例2:(union操作后的分区个数)

实例3:(join操作之后的分区个数)

实例4:(交集差集笛卡尔积操作之后的分区个数)

repartition和coalesce

groupBy不一定会Shuffle


RDD 分布式弹性数据集 , 是spark编程的核心抽象对象 ,在rdd上调用算子编程

  • 分布式RDD被设计为分布在集群的多个节点上。它们内部包含有关数据分区的信息,允许Spark在多个节点上并行计算。这使得Spark能够有效地处理大规模数据集。

  • 弹性:可恢复的 ,可复原, 安全可靠 , rdd调用转换算子返回新的rdd

可以通过RDD上下游的关系进行推导出

  • 数据集:本身是不存储数据的 底层是迭代器 ,迭代自的数据大数据 - Spark系列《六》- RDD详解_第1张图片

6.1 RDD 属性

abstract class RDD 是一个抽象类 , 一切皆对象, 类中包含的信息:

*  - A list of partitions
*  - A function for computing each split
*  - A list of dependencies on other RDDs
*  - Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned)
*  - Optionally, a list of preferred locations to compute each split on (e.g. block locations for
*    an HDFS file)
1.分区列表

RDD 包含一个分区列表,每个分区都是数据的一个子集。这些分区是并行计算的基本单位,允许 Spark 在集群中的多个节点上同时处理数据。

2.分区计算逻辑

对于每个分区,RDD 包含一个用于计算该分区的函数。这意味着在 RDD 上应用转换算子时,该函数将在每个分区上执行相同的计算逻辑。

3.RDD 之间的依赖关系

RDD 可以依赖于其他 RDD,形成一个有向无环图(DAG)。这些依赖关系允许 Spark 追踪数据的来源,从而实现容错和数据恢复,即使在节点故障时也能重新计算丢失的数据

4.可选的分区器

某些类型的 RDD,特别是键值对 RDD(例如通过 groupBy 或 reduceByKey 生成的 RDD),可能具有可选的分区器。这些分区器指定了如何重新分区数据,以便在后续计算中更有效地进行并行处理。

大数据 - Spark系列《六》- RDD详解_第2张图片

5.计算任务的首选地址

对于每个分区,RDD 可以指定首选的计算位置列表。这些位置可能是数据存储的位置,如 HDFS 文件的块位置,或者其他 Spark 节点的位置。指定首选位置可以提高计算效率,尤其是在节点之间的数据传输成本较高的情况下。

大数据 - Spark系列《六》- RDD详解_第3张图片

6.2 RDD 分区

RDD的分区个数?

6.2.1 原始RDD

1.集合

如果RDD是由集合创建的,默认情况下,其分区数由 Spark 集群的总核心数(totalCores)确定。这是通过spark.default.parallelism参数设置的。如果未设置该参数,则默认使用 Spark 集群的总核心数。 除此之外,也可以通过在创建RDD时手动指定分区数来覆盖默认值。

package com.doit.day0217
import org.apache.spark.rdd.{JdbcRDD, RDD}
import org.apache.spark.{SparkConf, SparkContext}

import java.sql.{DriverManager, ResultSet}
import org.apache.log4j.{Level, Logger}
/**
 * @日期: 2024/2/17
 * @Author: Wang NaPao
 * @Blog: https://blog.csdn.net/weixin_40968325?spm=1018.2226.3001.5343
 * @Tips: 和我一起学习吧
 * @Description:
 */


object Test01 {
  def main(args: Array[String]): Unit = {
    // 创建SparkConf对象,并设置应用程序名称和运行模式
    val conf = new SparkConf()
      .setAppName("Starting...") // 设置应用程序名称
      .setMaster("local[*]") // 设置运行模式为本地模式

    // 创建SparkContext对象,并传入SparkConf对象
    val sc = new SparkContext(conf)

    val rdd1 = sc.makeRDD(List(1, 2, 3))
    val rdd2 = sc.parallelize(Array(1, 2, 3),4)

    println(rdd1.getNumPartitions) //16 默认集群总核数
    println(rdd2.getNumPartitions) //4  指定分区数

    sc.stop()
  }
}
2.文件

当从文件中创建RDD时,Spark会根据计算任务的切片大小和输入路径下的文件大小来确定分区数。通常情况下,至少会有两个分区。这样做是为了确保数据可以被并行处理。

textFile的切片原理和设置切片大小的规则
  • 切片规则:

  1. 对于作业(job)的输入路径中的每个文件,单独切片。

  2. 判断每个文件是否支持切片:

    • 如果支持切片,根据指定的切片大小对文件进行切片。

    • 如果不支持切片,则将整个文件作为一个切片。

  • 切片大小计算

// 切片大小计算规则
splitSize = Math.max(minSize, Math.min(goalSize, blockSize))

参数说明

1)minSize:指定最小的切片大小。可以通过设置参数 mapreduce.input.fileinputformat.split.minsizemapred.min.split.size 来指定。默认值为 1L

2)goalSize:根据需求设定的期望切片大小。

goalSize=所有文件大小总和/指定的切片个数(可以通过参数传递)textFile(path,2)

3)blockSize:本地目录的切片大小为 32M,HDFS目录的切片大小为 128M256M,具体取决于 HDFS 文件块的配置。

大数据 - Spark系列《六》- RDD详解_第4张图片

3.数据库

当从数据库等外部数据源创建RDD时,通常可以在创建RDD时通过参数指定分区数。这可以根据数据规模和处理需求进行调整,以实现更好的并行处理效果。

6.2.2 由转换算子转换的RDD

当对原始RDD进行转换操作时,可以通过设置参数来指定新RDD的分区数,从而控制转换后RDD的分区个数。例如,在进行 mapflatMapfilter 等转换操作时,可以通过传递参数来指定分区数。通常情况下,Spark 会尽可能地保留原始RDD的分区数,但也可以手动指定分区数来满足特定的计算需求。

转换算子产生的RDD的分区数
1) 原则上分区个数是不变的
2) 有些算子可以调用的时候指定分区个数   distinct   join  groupBy  groupByKey

3) 特殊的算子 有特殊规定   
join 1)spark.default.parallelism  2)分区数多的哪个rdd的分区数
val rdd3 = rdd1.intersection(rdd2)  // 取大的
val rdd3 = rdd1.union(rdd2)  //两个rdd分区之和
val rdd4 = rdd1.subtract(rdd2) // 前面的RDD分区数
println(rdd1.cartesian(rdd2).getNumPartitions) // 两个分区个数乘积
注意: 可能产生Shuffle的算子可以指定分区个数的
distinct(p)     减少
groupBy(_._1 , p)    Shuffle 
groupByKey( p)       Shuffle 
groupByKey(_+_, p)   Shuffle 
join( , p)
实例1:(distinct算子可以指定分区个数)
package com.doit.day0217
import org.apache.spark.rdd.{JdbcRDD, RDD}
import org.apache.spark.{SparkConf, SparkContext}

import java.sql.{DriverManager, ResultSet}
import org.apache.log4j.{Level, Logger}
/**
 * @日期: 2024/2/17
 * @Author: Wang NaPao
 * @Blog: https://blog.csdn.net/weixin_40968325?spm=1018.2226.3001.5343
 * @Tips: 和我一起学习吧
 * @Description:
 */


object Test01 {
  def main(args: Array[String]): Unit = {
    // 创建SparkConf对象,并设置应用程序名称和运行模式
    val conf = new SparkConf()
      .setAppName("Starting...") // 设置应用程序名称
      .setMaster("local[*]") // 设置运行模式为本地模式
      .set("spark.default.parallelism","8")

    // 创建SparkContext对象,并传入SparkConf对象
    val sc = new SparkContext(conf)

    val rdd1 = sc.parallelize(Array(1, 2, 3, 1,4,5,6,7,8,9,1,1),4)

    println(rdd1.getNumPartitions) //4  指定分区数

    val rdd2 = rdd1.map(_ * 10)
    println(rdd2.getNumPartitions) //4

    val rdd3 = rdd2.distinct(2)
    println(rdd3.getNumPartitions) //2
    sc.stop()
  }
}
实例2:(union操作后的分区个数)
package com.doit.day0217
import org.apache.spark.rdd.{JdbcRDD, RDD}
import org.apache.spark.{SparkConf, SparkContext}

import java.sql.{DriverManager, ResultSet}
import org.apache.log4j.{Level, Logger}
/**
 * @日期: 2024/2/17
 * @Author: Wang NaPao
 * @Blog: https://blog.csdn.net/weixin_40968325?spm=1018.2226.3001.5343
 * @Tips: 和我一起学习吧
 * @Description:
 */


object Test01 {
  def main(args: Array[String]): Unit = {
    // 创建SparkConf对象,并设置应用程序名称和运行模式
    val conf = new SparkConf()
      .setAppName("Starting...") // 设置应用程序名称
      .setMaster("local[*]") // 设置运行模式为本地模式
      .set("spark.default.parallelism","8")

    // 创建SparkContext对象,并传入SparkConf对象
    val sc = new SparkContext(conf)

    val rdd1 = sc.parallelize(Array(1, 2, 3,3,4,5),2)
    val rdd2 = sc.parallelize(Array(1,2,3,4,4,5),3)
    val rdd3 = rdd1.union(rdd2)
    rdd3.foreach(println)
    println(rdd3.getNumPartitions)   //5
    sc.stop()
  }
}

大数据 - Spark系列《六》- RDD详解_第5张图片

实例3:(join操作之后的分区个数)
package com.doit.day0217

import org.apache.spark.rdd.{JdbcRDD, RDD}
import org.apache.spark.{SparkConf, SparkContext}

import java.sql.{DriverManager, ResultSet}
import org.apache.log4j.{Level, Logger}

/**
 * @日期: 2024/2/17
 * @Author: Wang NaPao
 * @Blog: https://blog.csdn.net/weixin_40968325?spm=1018.2226.3001.5343
 * @Tips: 和我一起学习吧
 * @Description:
 */


object Test02 {
  def main(args: Array[String]): Unit = {
    // 创建SparkConf对象,并设置应用程序名称和运行模式
    val conf = new SparkConf()
      .setAppName("Starting...") // 设置应用程序名称
      .setMaster("local[*]") // 设置运行模式为本地模式
     // .set("spark.default.parallelism","8")  //如果这里设置了,那么join后的rdd分区数为8
    
    // 创建SparkContext对象,并传入SparkConf对象
    val sc = new SparkContext(conf)

    val rdd1 = sc.makeRDD(List(("aaa", 1), ("bbb", 2), ("ccc", 3)),2)
    val rdd2 = sc.makeRDD(List(("aaa", "F"), ("bbb", "M"), ("ccc", "M")),3)

    val rdd3 = rdd1.join(rdd2)
    rdd3.foreach(println)
    println(rdd3.getNumPartitions)   //3

    sc.stop()
  }
}
实例4:(交集差集笛卡尔积操作之后的分区个数)
package com.doit.day0217
import org.apache.spark.rdd.{JdbcRDD, RDD}
import org.apache.spark.{SparkConf, SparkContext}

import java.sql.{DriverManager, ResultSet}
import org.apache.log4j.{Level, Logger}
/**
 * @日期: 2024/2/17
 * @Author: Wang NaPao
 * @Blog: https://blog.csdn.net/weixin_40968325?spm=1018.2226.3001.5343
 * @Tips: 和我一起学习吧
 * @Description:
 */


object Test01 {
  def main(args: Array[String]): Unit = {
    // 创建SparkConf对象,并设置应用程序名称和运行模式
    val conf = new SparkConf()
      .setAppName("Starting...") // 设置应用程序名称
      .setMaster("local[*]") // 设置运行模式为本地模式
     // .set("spark.default.parallelism","8")

    // 创建SparkContext对象,并传入SparkConf对象
    val sc = new SparkContext(conf)

    val rdd1 = sc.parallelize(Array(1, 2, 3,3,4,5),2)
    val rdd2 = sc.parallelize(Array(1,2,3,4,4,5),3)
    val rdd3 = rdd1.union(rdd2)
    val rdd4 = rdd1.intersection(rdd2)
    val rdd5 = rdd1.subtract(rdd2)
    val rdd6 = rdd1.cartesian(rdd2)

    println(rdd3.getNumPartitions)   //5 之和
    println(rdd4.getNumPartitions)   //3 取大的
    println(rdd5.getNumPartitions)   //2 取前面的
    println(rdd6.getNumPartitions)   //6 乘积
    sc.stop()
  }
}
repartition和coalesce

repartition 是一个广泛使用的方法,它用于增加 RDD 的分区数量。它的工作原理是通过随机洗牌(shuffle)将数据重新分配到新的分区中。

val rdd = sc.parallelize(1 to 100, 3) // 创建一个初始分区数为 3 的 RDD
val repartitionedRDD = rdd.repartition(5) // 增加分区数为 5

coalesce 方法用于减少 RDD 的分区数量,它的工作原理是在不触发 shuffle 的情况下,将多个分区合并为较少的分区。因为不涉及 shuffle 操作,所以相比于 repartition 方法,coalesce 方法的开销更小。

println(rdd1.coalesce(1, true).getNumPartitions)  //减少
println(rdd1.coalesce(3, true).getNumPartitions)  //增加
// 不允许Shuffle就不能增加分区
println(rdd1.coalesce(3, false).getNumPartitions)  //增加失败
println(rdd1.coalesce(1, false).getNumPartitions)  //减少  不会Shuffle

总结

  • repartition 用于增加 RDD 的分区数量,会触发 shuffle 操作,开销较大。

  • coalesce 用于减少 RDD 的分区数量,可以选择是否触发 shuffle 操作,开销较小。

  • 如果需要增加分区数或者进行重分区时,通常首选 repartition 方法;如果需要减少分区数且不触发 shuffle 操作,通常首选 coalesce 方法。

groupBy不一定会Shuffle

Shuffle:上游一个分区的数据可能被下游所有分区引用

大数据 - Spark系列《六》- RDD详解_第6张图片

package com.doit.com.doit.day0128

import org.apache.spark.SparkContext.jarOfObject
import org.apache.spark.rdd.RDD
import org.apache.spark.{HashPartitioner, SparkConf, SparkContext}

/**
 * @日期: 2024/1/29
 * @Author: Wang NaPao
 * @Blog: https://blog.csdn.net/weixin_40968325?spm=1018.2226.3001.5343
 * @Tips: 我是技术大牛
 * @Description:
 */


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

    val rdd1 = sc.makeRDD(List("a b c d e f g"), 2)

    val rdd2: RDD[String] = rdd1.flatMap(_.split("\\s+"))

    val wordOne = rdd2.map(line=>{
      println("aaaaaa")
      (line,1)
    })   //2

    //对数据使用HashPartitioner在分区 2
    val rdd3 = wordOne.partitionBy(new HashPartitioner(3))

    rdd3.mapPartitionsWithIndex((p,iter)=>{
      iter.map(e=>(p,e))
    }).foreach(println)

    //底层默认是HashPartition分区 2
    val rdd4: RDD[(String, Iterable[(String, Int)])] = rdd3.groupBy(_._1, 3)

    val rdd5: RDD[(Int, (String, Iterable[(String, Int)]))] = rdd4.mapPartitionsWithIndex((p, iter) => {
      iter.map(e => (p, e))
    })

    rdd5.foreach(println)
    
    sc.stop()
  }
}

结果

大数据 - Spark系列《六》- RDD详解_第7张图片

在 Spark 中,groupBy 操作并不一定会触发 Shuffle,具体是否触发 Shuffle 取决于操作前后的分区情况。在上面的示例中,通过使用 HashPartitioner 对数据进行重新分区,避免了不必要的 Shuffle 操作,从而提高了计算效率。

你可能感兴趣的:(spark,大数据,spark,分布式)