Spark的数据结构——RDD

最新推荐文章于 2024-03-27 07:57:34 发布

bluedraam_pp

最新推荐文章于 2024-03-27 07:57:34 发布

阅读量782

点赞数 13

分类专栏： Spark 文章标签： spark 数据结构大数据

本文链接：https://blog.csdn.net/bluedraam_pp/article/details/136552069

版权

Spark 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

RDD 的 5 个特征

下面来说一下 RDD 这东西，它是 Resilient Distributed Datasets 的简写。

咱们来看看 RDD 在源码的解释。

A list of partitions: 在大数据领域，大数据都是分割成若干个部分，放到多个服务器上，这样就能做到多线程的处理数据，这对处理大数据量是非常重要的。分区意味着，可以使用多个线程了处理。
A function for computing each split：作用在每个分区里面的函数，当我们读取数据之后，当然是要对其加工的，加工的定义就是我们编写的函数，这些函数主要包含转化算子、控制算子、行动算子。
A list of dependencies on other RDDs。一个 Spark Application 下面可以有多个 Job ，一个 action 算子就可以分出一个 job ，一个 job 里面又可以分出若干个 stage ，一个 stage 中又有多个 RDD ，RDD 之间是用上下游关系的，就像流水线的工序，公休之间也会有先后之分的，例如，手机装壳之后才能上螺丝，这种上下游关系，使用依赖描述的，依赖又分为窄依赖和宽依赖。那两个 RDD 为例，rdd2 依赖于 rdd1 ，
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)

RDD 源代码

RDD 的代码是非常多的，一个 RDD.scala 类就有 2000 多行。我们只捡能说明问题的就行了。

abstract class RDD[T: ClassTag](
    // SparkContext 是代码的运行环境，SparkContext 中有一个 TaskSchedule 和 DAGSchedule ，前者是申请资源，后者是将 job 分割为多个 Stage ，然后提交给相应的 Executor
    @transient private var _sc: SparkContext,
    // deps 代表了上游算子依赖，上游可能有多个依赖，所以这里是一个 Seq .
    // 这个 Seq 就是 RDD 中依赖的具体体现
    @transient private var deps: Seq[Dependency[_]]
  ) extends Serializable with Logging {
  // compute 函数代表了 RDD 第二个特征，作用在 partition 上面的函数。
  @DeveloperApi
  def compute(split: Partition, context: TaskContext): Iterator[T]
  // 此函数是 RDD 第一个特征的具体表现，各个 RDD 的具体实现，可以根据它获得 RDD 中的分区
  protected def getPartitions: Array[Partition]
  // 还是依赖相关的函数
  protected def getDependencies: Seq[Dependency[_]] = deps
  // 此函数对应了 RDD 的第 5 个特征。各个 RDD 的实现类，在此函数中，实现就近数据的查找。
  protected def getPreferredLocations(split: Partition): Seq[String] = Nil
  // 此函数对应了 RDD 的第四个特征，针对 PairRDDFunction 的分区器。
  @transient val partitioner: Option[Partitioner] = None

  def sparkContext: SparkContext = sc

  val id: Int = sc.newRddId()

  final def dependencies: Seq[Dependency[_]] = {
    ... 
  }

  final private def internalDependencies: Option[Seq[Dependency[_]]] = {
    ... 
  }

  final def partitions: Array[Partition] = {
     ...
  }

  final def preferredLocations(split: Partition): Seq[String] = {
    checkpointRDD.map(_.getPreferredLocations(split)).getOrElse {
      getPreferredLocations(split)
    }
  }

  final def iterator(split: Partition, context: TaskContext): Iterator[T] = {
  }
}

object RDD {

  private[spark] val CHECKPOINT_ALL_MARKED_ANCESTORS =
    "spark.checkpoint.checkpointAllMarkedAncestors"
  implicit def rddToPairRDDFunctions[K, V](rdd: RDD[(K, V)])
    (implicit kt: ClassTag[K], vt: ClassTag[V], ord: Ordering[K] = null): PairRDDFunctions[K, V] = {
    new PairRDDFunctions(rdd)
  }
  // 此方法对应了 RDD 的第四个特征，有了它，只要将 RDD 中的数据转化为 tuple2 的数据格式，就能自动调用 PairRDDFunction 中的函数。
  implicit def rddToAsyncRDDActions[T: ClassTag](rdd: RDD[T]): AsyncRDDActions[T] = {
    new AsyncRDDActions(rdd)
  }
}

还有更重要的一点，就是第二个特征，作用在分区上的函数，RDD 加上 PairRDDFunction 上的函数有很多，可以在上一篇 Spark 核心API 中找到。

下面以 Workd Count 为例子，画图来说明 RDD 的特性。

val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName(this.getClass.getCanonicalName.init)
val sc: SparkContext = new SparkContext(conf)
sc.textfile("hdfs://nameservice/user/test_data/file.txt")
.flapMap(_.split(","))
.map((_,1))
.reduceByKey(_+_)
.foreach(println)

先来看看 textFile 底层是什么？

// SparkContext 
def textFile(
    path: String,
    minPartitions: Int = defaultMinPartitions): RDD[String] = withScope {
  assertNotStopped()
  hadoopFile(path, classOf[TextInputFormat], classOf[LongWritable], classOf[Text],
    minPartitions).map(pair => pair._2.toString).setName(path)
}
def hadoopFile[K, V](
    path: String,
    inputFormatClass: Class[_ <: InputFormat[K, V]],
    keyClass: Class[K],
    valueClass: Class[V],
    minPartitions: Int = defaultMinPartitions): RDD[(K, V)] = withScope {
  assertNotStopped()
  FileSystem.getLocal(hadoopConfiguration)
  val confBroadcast = broadcast(new SerializableConfiguration(hadoopConfiguration))
  val setInputPathsFunc = (jobConf: JobConf) => FileInputFormat.setInputPaths(jobConf, path)
  // 最后返回的是 HadoopRDD ，这是我们认识的第一个 RDD 
  new HadoopRDD(
    this,
    confBroadcast,
    Some(setInputPathsFunc),
    inputFormatClass,
    keyClass,
    valueClass,
    minPartitions).setName(path)

以 HadoopRDD 为例子，我们来看看 RDD 的五个特性。
第一个特征是分区，来看一下 HadoopRDD 的 getPartitions 方法。

override def getPartitions: Array[Partition] = {
  val jobConf = getJobConf()
  try {
    // 获取 splite , 这其实就是将一个 HDFS 文件切分成若干个分区。 
    val allInputSplits = getInputFormat(jobConf).getSplits(jobConf, minPartitions)
    val inputSplits = if (ignoreEmptySplits) {
      allInputSplits.filter(_.getLength > 0)
    } else {
      allInputSplits
    }
    // 根据分区大小来提示优化策略
    if (inputSplits.length == 1 && inputSplits(0).isInstanceOf[FileSplit]) {
      ...
    }
    // 将 FileSplite 组成 hadoopPartition
    val array = new Array[Partition](inputSplits.size)
    for (i <- 0 until inputSplits.size) {
      array(i) = new HadoopPartition(id, i, inputSplits(i))
    }
    array
  } catch {
    ... 
  }
}

从 getPatitions 方法，可以看到使用 hadoop-client 的接口，将 HDFS 的文件切成若干 HadoopPartition ，然后返回一个数组 Array[Partition]。

第二个特征是作用在分区上的函数，那就来到来 compute 函数。

override def compute(theSplit: Partition, context: TaskContext): InterruptibleIterator[(K, V)] = {
  // 构造 NextIterator 迭代器
  val iter = new NextIterator[(K, V)] {
    ...
    private var reader: RecordReader[K, V] = null
    ...
    reader =
      try {
        inputFormat.getRecordReader(split.inputSplit.value, jobConf, Reporter.NULL)
      } catch {
         ... 
      }

    private val key: K = if (reader == null) null.asInstanceOf[K] else reader.createKey()
    private val value: V = if (reader == null) null.asInstanceOf[V] else reader.createValue()
    // 重新 getNext 方法，此方法其实就是从 HDFS 的文件中哪里一行数据，
    // K 为对应此行在文件中的位置，
    // V 为此行的数据
    override def getNext(): (K, V) = {
      try {
        finished = !reader.next(key, value)
      } catch {
         ... 
      }
      (key, value)
    }
    // 关闭 HDFS 客户端和服务器端的连接
    override def close(): Unit = {
    }
  }
  new InterruptibleIterator[(K, V)](context, iter)
}

上面的代码中 inputSplit 其实是 FileInputSplit ，reader 是 LineRecordReader 。HadoopRDD 的功能就是从 HDFS 中取数据，向后发送，所以没有数据处理的逻辑。

第三个特征是描述 RDD 中的依赖。HadoopRDD 是第一个 RDD 所以它前面已经没有了 RDD 。从下面 HadoopRDD 的定义就能看出来。Dependency 为 Nil

class HadoopRDD[K, V](
   sc: SparkContext,
   broadcastedConf: Broadcast[SerializableConfiguration],
   initLocalJobConfFuncOpt: Option[JobConf => Unit],
   inputFormatClass: Class[_ <: InputFormat[K, V]],
   keyClass: Class[K],
   valueClass: Class[V],
   minPartitions: Int)
 // RDD构造函数是 RDD(SparkContext , Dependency)
 // 从下面的代码中，可以看到 Dependency 为 Nil 。
 extends RDD[(K, V)](sc, Nil){
 ...
}

preferedLocation 和 key-value RDDS 的特征在 HadoopRDD 没有体现出来。

下面再看 flatMap ，

  def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U] = withScope {
    val cleanF = sc.clean(f)
    new MapPartitionsRDD[U, T](this, (_, _, iter) => iter.flatMap(cleanF))
  }

从上面代码中可以看到，MapPartitionsRDD 是 flatMap 的 RDD。还是这五个特征来看 MapPartitionsRDD ，

// MapPartitionsRDD#getPartitions
override def getPartitions: Array[Partition] = firstParent[T].partitions
// RDD#firstParent
protected[spark] def firstParent[U: ClassTag]: RDD[U] = {
  dependencies.head.rdd.asInstanceOf[RDD[U]]
}

从上面的代码，可以看出，getPartitions 方法取出是第一个父 RDD 的分区，这是第一个特征。

第二个特征是作用在分区上面的计算，flatMap 是将 line 分裂成单个的单词，所以这里需要函数，就是 f ，
f 其实是在 flatMap 函数中定义的 (_, _, iter) => iter.flatMap(cleanF) , 而 cleanF 就是
我们自定义的 _.split(“\s”) 的,而接收它的是一个 iterator 的 flatMap ，这个 flatMap 是 scala
原生的，并不是 RDD#flatMap。

override def compute(split: Partition, context: TaskContext): Iterator[U] =
  f(context, split.index, firstParent[T].iterator(split, context))

从代码中，看到 f 的第三个入参是第一个父 RDD 的迭代器。

第三个特征是依赖关系，可以从 MapPartitionsRDD 的定义看出。

private[spark] class MapPartitionsRDD[U: ClassTag, T: ClassTag](
    var prev: RDD[T],
    f: (TaskContext, Int, Iterator[T]) => Iterator[U],  // (TaskContext, partition index, iterator)
    preservesPartitioning: Boolean = false,
    isFromBarrier: Boolean = false,
    isOrderSensitive: Boolean = false)
  extends RDD[U](prev) {...}
  
 def this(@transient oneParent: RDD[_]) =
    this(oneParent.context, List(new OneToOneDependency(oneParent)))

现在只要弄清楚 pre 是那个 RDD 就可以了，当我们调用 sc.textFile(path).flatMap(_.split(“\s”))，其实 textFile 返回的是 HadoopRDD，所以是 HadoopRDD 调用的 flatMap ，所以 prev 就是 HadoopRDD 的引用。到这里，问题应该就清晰了，OneToOneDependency保存的父 RDD ，再有明显可以看出是窄依赖，一对一嘛。

preferedLocation 和 key-value RDD 同样都没体现出来。

下面来看看 map((_,1)) 使用了什么 RDD。

 def map[U: ClassTag](f: T => U): RDD[U] = withScope {
   val cleanF = sc.clean(f)
   new MapPartitionsRDD[U, T](this, (_, _, iter) => iter.map(cleanF))
 }

从代码来看，f 函数被 map 调用了，对应的 RDD 也是 MapPartitionRDD ，就是迭代器调用的方法发生了改变。还是按照老办法，把五个特征找出来。

第一个是 getPartitions 返回还是第一个 parent RDD 的分区。
第二个是 compute 中调用的是第一个 parentRDD 分区的迭代器。
第三个是 dependency 是 flatMap 对应的 MapPartiionRDD
preferedLocation 和 key-value RDD 同样都没体现出来。

最后是 reduceByKey(+) , reduceByKey 是 PairRDDFunction 的函数，这是咋回事，map((_,1)) 返回的不是 MapPartitionRDD 吗？怎么又变成 PairRDDFunction 了，这就要讲到 Scala 的隐式转化，请看下面的代码：

object RDD {
...
  implicit def rddToPairRDDFunctions[K, V](rdd: RDD[(K, V)])
    (implicit kt: ClassTag[K], vt: ClassTag[V], ord: Ordering[K] = null): PairRDDFunctions[K, V] = {
    new PairRDDFunctions(rdd)
  }
...
}

当调用某个类的方法，发现此类没有这个方法，则就取找隐式方法，这里隐式方法是 rddToPairRDDFunctions，它最终将 MapPartitionRDD 转化为了 PairRDDFunction ，这样就实现了自动化的转化，所以这里能够调用 reduceByKey 方法，这也对应了 RDD 的第四个特性，key-value RDD 。看到这里，它的意思就是将那些数据类型为 (key , value) 的 RDD 自动转化为 PairRDDFunctiono , 并且调用上面的方法。

接着看 reduceByKey 的源码，

def reduceByKey(func: (V, V) => V): RDD[(K, V)] = self.withScope {
  reduceByKey(defaultPartitioner(self), func)
}
def reduceByKey(partitioner: Partitioner, func: (V, V) => V): RDD[(K, V)] = self.withScope {
  combineByKeyWithClassTag[V]((v: V) => v, func, func, partitioner)
}

从上面的源码看出，reduceByKey 底层使用的是 combinerByKey() , combinerByKey 在之前的文章已经讲过了，

  def combineByKeyWithClassTag[C](
      createCombiner: V => C,
      mergeValue: (C, V) => C,
      mergeCombiners: (C, C) => C,
      partitioner: Partitioner,
      mapSideCombine: Boolean = true,
      serializer: Serializer = null)(implicit ct: ClassTag[C]): RDD[(K, C)] = self.withScope {
....
    val aggregator = new Aggregator[K, V, C](
      self.context.clean(createCombiner),
      self.context.clean(mergeValue),
      self.context.clean(mergeCombiners))
    if (self.partitioner == Some(partitioner)) {
      ... 
    } else {
      new ShuffledRDD[K, V, C](self, partitioner)
        .setSerializer(serializer)
        .setAggregator(aggregator)
        .setMapSideCombine(mapSideCombine)
    }
  }

从代码得，combineByKey 底层使用的是 ShuffleRDD 。

override def getPartitions: Array[Partition] = {
  Array.tabulate[Partition](part.numPartitions)(i => new ShuffledRDDPartition(i))
}
override def compute(split: Partition, context: TaskContext): Iterator[(K, C)] = {
  val dep = dependencies.head.asInstanceOf[ShuffleDependency[K, V, C]]
  val metrics = context.taskMetrics().createTempShuffleReadMetrics()
  SparkEnv.get.shuffleManager.getReader(
    dep.shuffleHandle, split.index, split.index + 1, context, metrics)
    .read()
    .asInstanceOf[Iterator[(K, C)]]
}

在 compute 中并没有从依赖中取出迭代器，而是调用了 ShuffleManager#getReader 方法，这是因为 combineByKey 是做分区操作的，所以要将相同 key 的数据通过网络发送到不同的机器上，其实就是 Map-Reduce 计算引擎的 shuffle 过程，这里也是一样的，这也是 ShuffleRDD 名称的由来。

paritition 的特性：

parttion 特性，在 compute 函数中，使用 ShuffleManager 拿到 shuffle 到本分区的数据。这里是根据 key 进行了重新的分区
compute 的特性，ShuffleRDD 的计算函数是封装在了 aggregator 成员变量了，而 aggregator 又被保存到了ShuffleDependency 中，其实是在 BlockStoreShuffleReader 中调用了 combinerBykey 中的我们自定义的函数。
依赖的是 ShuffleDependency ，就是宽依赖。
key-value RDD 的特性，其实就是 PairRDDFunction 的隐式转化，在 reduceByKey 中体现的比较明显。
preferedLocation 还是没有找对应的逻辑。

下面以图的方式来总结一下，HadoopRDD、MapPartitionsRDD、ShuffleRDD 这三个 RDD 在 word count 这个例子中的对应关系。

wordcount的 RDD 结构图