Spark系列文章：
大数据 - Spark系列《一》- 从Hadoop到Spark：大数据计算引擎的演进-CSDN博客
大数据 - Spark系列《二》- 关于Spark在Idea中的一些常用配置-CSDN博客
大数据 - Spark系列《三》- 加载各种数据源创建RDD-CSDN博客
大数据 - Spark系列《四》- Spark分布式运行原理-CSDN博客
大数据 - Spark系列《五》- Spark常用算子-CSDN博客
目录
RDD 分布式弹性数据集 , 是spark编程的核心抽象对象 ,在rdd上调用算子编程
-
分布式：RDD被设计为分布在集群的多个节点上。它们内部包含有关数据分区的信息，允许Spark在多个节点上并行计算。这使得Spark能够有效地处理大规模数据集。
-
弹性：可恢复的 ,可复原, 安全可靠 , rdd调用转换算子返回新的rdd
可以通过RDD上下游的关系进行推导出
-
数据集：本身是不存储数据的 底层是迭代器 ,迭代自的数据
🐶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），可能具有可选的分区器。这些分区器指定了如何重新分区数据，以便在后续计算中更有效地进行并行处理。
5.🥙计算任务的首选地址
对于每个分区，RDD 可以指定首选的计算位置列表。这些位置可能是数据存储的位置，如 HDFS 文件的块位置，或者其他 Spark 节点的位置。指定首选位置可以提高计算效率，尤其是在节点之间的数据传输成本较高的情况下。
🐶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的切片原理和设置切片大小的规则
-
切片规则：
-
对于作业（job）的输入路径中的每个文件，单独切片。
-
判断每个文件是否支持切片：
-
如果支持切片，根据指定的切片大小对文件进行切片。
-
如果不支持切片，则将整个文件作为一个切片。
-
-
切片大小计算
// 切片大小计算规则
splitSize = Math.max(minSize, Math.min(goalSize, blockSize))参数说明
1)minSize：指定最小的切片大小。可以通过设置参数 mapreduce.input.fileinputformat.split.minsize 或 mapred.min.split.size 来指定。默认值为 1L。
2)goalSize：根据需求设定的期望切片大小。
goalSize=所有文件大小总和/指定的切片个数(可以通过参数传递）textFile(path,2)
3)blockSize：本地目录的切片大小为 32M，HDFS目录的切片大小为 128M 或 256M，具体取决于 HDFS 文件块的配置。
3.🥙数据库
当从数据库等外部数据源创建RDD时，通常可以在创建RDD时通过参数指定分区数。这可以根据数据规模和处理需求进行调整，以实现更好的并行处理效果。
6.2.2 由转换算子转换的RDD
当对原始RDD进行转换操作时，可以通过设置参数来指定新RDD的分区数，从而控制转换后RDD的分区个数。例如，在进行 map、flatMap、filter 等转换操作时，可以通过传递参数来指定分区数。通常情况下，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()
}
}
🧀实例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) // 增加分区数为 5coalesce 方法用于减少 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：上游一个分区的数据可能被下游所有分区引用
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 中，groupBy 操作并不一定会触发 Shuffle，具体是否触发 Shuffle 取决于操作前后的分区情况。在上面的示例中，通过使用 HashPartitioner 对数据进行重新分区，避免了不必要的 Shuffle 操作，从而提高了计算效率。
1116
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
