RDD的五大特点

RDD源码
abstract class RDD[T: ClassTag](
    @transient private var _sc: SparkContext,
    @transient private var deps: Seq[Dependency[_]]
  ) extends Serializable with Logging {
...
}

• 详情查看官网：https://github.com/apache/spark/blob/master/core/src/main/scala/org/apache/spark/rdd/RDD.scala

解读：
1）抽象类（abstract）：不能直接使用，需要借助于子类实现，使用时直接使用其子类即可 

2）序列化：在分布式计算框架里，序列化框架性能的好坏直接影响整个框架性能的优劣 

3）logging：日志记录，2.0版本后不自带，需要自己写一个 

4）T：泛型 支持各种数据类型 

5）sparkcontext 

6）@transient

 *  - 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由很多partition构成，在spark中，计算式，有多少partition就对应有多少个task来执行，一个分区在一台机器上，一个分区其实就是放在一台机器的内存上，
  一台机器上可以有多个分区
2）A function for computing each split
   对RDD做计算，相当于对RDD的每个split或partition做计算
3）A list of dependencies on other RDDs
   RDD之间有依赖关系，可溯源
  eg:rdd1.map(_*10).flatMap(..).map(..).reduceByKey(...)

     构建成为DAG,这个DAG会构造成很多个阶段，这些阶段叫做stage，RDDstage之间会有依赖关系，后面根据前面的依赖关系来构建，如果前面的数据丢了，

     它会记住前面的依赖，从前面进行重新恢复。每一个算子都会产生新的RDD.
     textFile 与flatMap会产生两个RDD.

     spark中的DAG就是rdd内部的转换关系，这些转换关系会被转换成依赖关系，进而被划分成不同阶段，从而描绘出任务的先后顺序。

    最优的位置去计算，也就是数据的本地性
   计算每个split时，在split所在机器的本地上运行task是最好的，避免了数据的移动；split有多个副本，所以preferred location不止一个
  数据在哪里，应优先把作业调度到数据所在机器上，减少数据的IO和网络传输，这样才能更好地减少作业运行时间
（木桶原理：作业运行时间取决于运行最慢的task所需的时间），提高性能，不过数据进行最后汇总的时候就要走网络。（hdfs file的block块）

/**
   * Implemented by subclasses to return the set of partitions in this RDD. This method will only
   * be called once, so it is safe to implement a time-consuming computation in it.
   *
   * The partitions in this array must satisfy the following property:
   *   `rdd.partitions.zipWithIndex.forall { case (partition, index) => partition.index == index }`
   */
protected def getPartitions: Array[Partition]

/**
   * :: DeveloperApi ::
   * Implemented by subclasses to compute a given partition.
   */
  @DeveloperApi
def compute(split: Partition, context: TaskContext): Iterator[T]

 /**
   * Implemented by subclasses to return how this RDD depends on parent RDDs. This method will only
   * be called once, so it is safe to implement a time-consuming computation in it.
   */
protected def getDependencies: Seq[Dependency[_]] = deps

/**
   * Optionally overridden by subclasses to specify placement preferences.
   */
protected def getPreferredLocations(split: Partition): Seq[String] = Nil

/** Optionally overridden by subclasses to specify how they are partitioned. */
@transient val partitioner: Option[Partitioner] = None