Spark RDD基本概念、宽窄依赖、转换行为操作

本文介绍一下rdd的基本属性概念、rdd的转换/行动操作、rdd的宽/窄依赖。

目录

• RDD概述
  • RDD的内部代码
    • 先看看基本概念的代码：
    • 常用的函数/算子
  • 案例
  • 小总结
• 转换、行动算子
  • 一些常见的行动操作
• 宽、窄依赖
  • 一些常见的宽窄依赖
• Reference

RDD：Resilient Distributed Dataset 弹性分布式数据集，是Spark中的基本抽象。

RDD表示可以并行操作的元素的不变分区集合。

RDD提供了许多基本的函数（map、filter、reduce等）供我们进行数据处理。

RDD概述

通常来说，每个RDD有5个主要的属性组成：

• 分区列表

  RDD是由多个分区组成的，分区是逻辑上的概念。RDD的计算是以分区为单位进行的。

• 用于计算每个分区的函数

  作用于每个分区数据的计算函数。

• 对其他RDD的依赖关系列表

  RDD中保存了对于父RDD的依赖，根据依赖关系组成了Spark的DAG（有向无环图），实现了spark巧妙、容错的编程模型

• 针对键值型RDD的分区器

  分区器针对键值型RDD而言的，将key传入分区器获取唯一的分区id。在shuffle中，分区器有很重要的体现。

• 对每个分区进行计算的首选位置列表

  根据数据本地性的特性，获取计算的首选位置列表，尽可能的把计算分配到靠近数据的位置，减少数据的网络传输。

RDD的内部代码

先看看基本概念的代码：

//创建此RDD的SparkContext
def sparkContext: SparkContext = sc
// 唯一的id
val id: Int = sc.newRddId()
// rdd友善的名字
@transient var name: String = _
// 分区器
val partitioner: Option[Partitioner] = None
// 获取依赖列表
// dependencies和partitions中都用到了checkpointRDD，如果进行了checkpoint，checkpointRDD表示进行checkpoint后的rdd
final def dependencies: Seq[Dependency[_]] = {
    // 一对一的窄依赖
    checkpointRDD.map(r => List(new OneToOneDependency(r))).getOrElse {
        if (dependencies_ == null) {
            dependencies_ = getDependencies
        }
        dependencies_
    }
}
// 获取分区列表
final def partitions: Array[Partition] = {
    checkpointRDD.map(_.partitions).getOrElse {
        if (partitions_ == null) {
            partitions_ = getPartitions
            partitions_.zipWithIndex.foreach { case (partition, index) =>
                require(partition.index == index,
                        s"partitions($index).partition == ${partition.index}, but it should equal $index")
            }
        }
        partitions_
    }
}
// 获取分区的首选位置
final def preferredLocations(split: Partition): Seq[String] = {
    checkpointRDD.map(_.getPreferredLocations(split)).getOrElse {
        getPreferredLocations(split)
    }
}
// 对应到每个分区的计算函数
def compute(split: Partition, context: TaskContext): Iterator[T]

主要就是围绕上面5个重要属性的一些操作

常用的函数/算子

// 返回仅包含满足过滤条件的元素的新RDD。
def filter(f: T => Boolean): RDD[T] = withScope {
    val cleanF = sc.clean(f)
    new MapPartitionsRDD[T, T](
        this,
        (context, pid, iter) => iter.filter(cleanF),
        preservesPartitioning = true)
}
// 通过将函数应用于此RDD的所有元素来返回新的RDD。
def map[U: ClassTag](f: T => U): RDD[U] = withScope {
    val cleanF = sc.clean(f)
    new MapPartitionsRDD[U, T](this, (context, pid, iter) => iter.map(cleanF))
}
// 首先向该RDD的所有元素应用函数，然后将结果展平，以返回新的RDD。
def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U] = withScope {
    val cleanF = sc.clean(f)
    new MapPartitionsRDD[U, T](this, (context, pid, iter) => iter.flatMap(cleanF))
}

我们可以发现几乎每个算子都会以当前RDD和对应的计算函数创建新的RDD，每个子RDD都持有父RDD的引用。

这就印证了RDD的不变性，也表明了RDD的计算是通过对RDD进行转换实现的。

案例

val words = Seq("hello spark", "hello scala", "hello java")
val rdd = sc.makeRDD(words)
rdd
    .flatMap(_.split(" "))
    .map((_, 1))
    .reduceByKey(_ + _)
    .foreach(println(_))

上面是一个简单的RDD的操作，我们先调用makeRDD创建了一个RDD，之后对rdd进行一顿算子调用。

首先调用flatMap，flatMap内部会以当前rdd和我们传入的_.split(" ")构建新的MapPartitionsRDD；

之后map，map以上步生成的MapPartitionsRDD和我们传入的(_, 1)构造新的MapPartitionsRDD；

之后reduceByKey，reduceByKey构造新的RDD；

走到foreach，foreach是行动操作，触发计算，输出。

小总结

• RDD内部的计算除action算子以外，其他算子都是懒执行，不会触发计算，只是进行RDD的转换。
• RDD的计算是基于分区为单位计算的，我们传进去的函数，作用于分区进行计算

转换、行动算子

从上面知道RDD是懒执行的，只有遇到行动算子才执行计算。

转换操作：在内部对根据父RDD创建新的RDD，不执行计算

行动操作：内部会调用sc.runJob，提交作业、划分阶段、执行作业。

一些常见的行动操作

foreach、foreachPartition、collect、reduce、count

除行动操作外，都是转换操作

宽、窄依赖

宽窄依赖是shuffle和划分调度的重要依据。

先看看spark中与依赖有关的几个类(一层一层继承关系)：

Dependency依赖的顶级父类
	NarrowDependency 窄依赖
		OneToOneDependency 表示父RDD和子RDD分区之间的一对一依赖关系的窄依赖
		RangeDependency 表示父RDD和子RDD中分区范围之间的一对一依赖关系的窄依赖
	ShuffleDependency 宽依赖

先说宽窄依赖的概念：

窄依赖：父RDD的每个分区只被一个子RDD分区使用

宽依赖：父RDD的每个分区都有可能被多个子RDD分区使用

其实就是父RDD的一个分区会被传到几个子RDD分区的区别。如果被传到一个子RDD分区，就可以不需要移动数据（移动计算）；如果被传到多个子RDD分区，就需要进行数据的传输。

接下来看看Dependency内部的一些属性及方法：

// 依赖对应的rdd，其实就是当前rdd的父rdd。宽依赖和窄依赖都有这个属性
def rdd: RDD[T]
// 获取子分区对应的父分区（窄依赖的方法）
def getParents(partitionId: Int): Seq[Int]

// 以下是宽依赖的属性及方法
// 对应键值RDD的分区器
val partitioner: Partitioner
// 在数据传输时的序列化方法
val serializer: Serializer = SparkEnv.get.serializer
// 键的排序方式
val keyOrdering: Option[Ordering[K]] = None
// 一组用于聚合数据的功能
val aggregator: Option[Aggregator[K, V, C]] = None
// 是否需要map端预聚合
val mapSideCombine: Boolean = false
// 当前宽依赖的id
val shuffleId: Int = _rdd.context.newShuffleId()
// 向管理员注册一个shuffle，并获取一个句柄，以将其传递给任务
val shuffleHandle: ShuffleHandle =  _rdd.context.env.shuffleManager.registerShuffle(
shuffleId, _rdd.partitions.length, this)

一些常见的宽窄依赖

窄依赖：map、filter、union、mapPartitions、join(当分区器是HashPartitioner)

宽依赖：sortByKey、join(分区器不是HashPartitioner时)

最后说一下reduceByKey，顺便说一下为什么当分区器HashPartitioner时就是窄依赖。

reduceByKey是用来将key分组后，执行我们传入的函数。

它是窄依赖，它内部默认会使用HashPartitioner分区。

同一个key进去HashPartitioner得到的分区id是一样的，这样进行计算前后同一个key得到的分区都一样，父RDD的分区就只被子RDD的一个分区依赖，就不需要移动数据。

所以join、reduceByKey在分区器是HashPartitioner时是窄依赖。

end. 个人理解，如有偏差，欢迎交流指正。

Reference

• 《图解Spark核心技术与案例实战》
• 宽窄依赖：https://www.jianshu.com/p/5c2301dfa360

扶我起来，我还能学。

---

个人公众号：码农峰，定时推送行业资讯，持续发布原创技术文章，欢迎大家关注。