1、RDD概念：
RDD 叫做 弹性分布式数据集，是spark中最基本的数据抽象。代表着一个可分区、元素可并行计算、不可变的数据集合。
RDD特点：自动容错、位置感知性调度、可伸缩性，允许用户在执行多个查询时显式地将工作集缓存在内存中，后续的查询能够重用工作集，这极大地提升了查询速度。
2、RDD原理：
（1）分区partition：RDD的基本组成单位，每个分区partition都会被一个计算任务task处理，并决定并行计算的粒度。分区partition在创建RDD的时候可以指定，若不指定就采用默认的分区数，默认是程序所分配到的CPU Core的数目。
（2）计算分区数据函数compute：RDD抽象类要求其所有子类都必须实现compute方法，目的是计算该分区中的数据，compute函数负责的是父RDD分区数据到子RDD分区数据的变换逻辑。
RDD抽象类要求其所有子类都必须实现compute方法，该方法介绍的参数之一是一个Partition对象，目的是计算该分区中的数据。以MapPartitionsRDD类为例，其compute方法如下
override def compute(split: Partition, context: TaskContext): Iterator[U] =
f(context, split.index, firstParent[T].iterator(split, context))
MapPartitionsRDD类的compute方法调用当前RDD内的第一个父RDD的iterator方法，该方法的目的是拉取父RDD对应分区的数据，iterator方法会返回一个迭代器对象，迭代器内部存储的每一个元素即父RDD对应分区内的数据记录。
RDD的粗粒度转换体现在map方法上，f函数是map转换操作函数，RDD会对一个分区(而不是一条一条数据记录)内的数据执行单的的操作f，最终返回包含所有经过转换过的数据记录的新迭代器，即新的分区。
其他RDD子类的compute方法与之类似，在需要用用到父RDD的分区数据时，就会调用iterator方法，然后根据需求在得到的数据上执行相应的操作。换句话说，compute函数负责的是父RDD分区数据到子RDD分区数据的变换逻辑。
https://blog.csdn.net/jiangpeng59/article/details/53213694
（3）分区函数 Partitioner：spark有两种分区函数，一种是 HashPartitioner、RangePartitioner，只有对于于key-value的RDD，才会有Partitioner，非key-value的RDD的Parititioner的值是None。Partitioner函数不但决定了RDD本身的分片数量，也决定了parent RDD Shuffle输出时的分片数量。
（4）分区位置列表：这个列表存储着每个分区partition所在的hdfs数据块block的位置。按照“移动数据不如移动计算”的理念，Spark在进行任务调度的时候，会尽可能地将计算任务分配到其所要处理数据块的存储位置。
3、WordCount粗图解RDD：
4、RDD的创建方式
（1）读取文件生成：
val file = sc.textFile("/spark/hello.txt")
val lines: RDD[String] = sc.textFile(args(0))
（2） 并行化方式创建RDD
a、parallelize（）
scala> val array = Array(1,2,3,4,5) array: Array[Int] = Array(1, 2, 3, 4, 5) scala> val rdd = sc.parallelize(array) rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[27] at parallelize at <console>:26 scala>
将java的list转成scala RDD
val summaries: util.List[S3ObjectSummary] = objectListing.getObjectSummaries val scalaArray: Array[S3ObjectSummary] = Array() val newRDD: RDD[S3ObjectSummary] = sc.parallelize(summaries.toArray(scalaArray))
b、makeRDD（）
val seq = List(("American Person", List("Tom", "Jim")), ("China Person", List("LiLei", "HanMeiMei")), ("Color Type", List("Red", "Blue")))
val rdd2 = sc.makeRDD(seq)
这两种创建方式的区别：
当调用parallelize()方法的时候，不指定分区数的时候，使用系统给出的分区数，而调用makeRDD()方法的时候，会为每个集合对象创建最佳分区，而这对后续的调用优化很有帮助。
两种创建方式及区别博客：https://www.iteye.com/blog/xiaotutu365-2379890
（3）其他方式：
读取数据库等等其他的操作。也可以生成RDD。
RDD可以通过其他的RDD转换而来的。
参考博客：https://www.cnblogs.com/frankdeng/p/9301653.html
5、RDD对象，RDD的实现类
1、MapPartitionRDD：是RDD类的一种实现，在word count程序中经常出现。
org.apache.spark.rdd
Class MapPartitionsRDD<U,T>
Object
org.apache.spark.rdd.RDD<U>
org.apache.spark.rdd.MapPartitionsRDD<U,T>
public class MapPartitionsRDD<U,T> extends RDD<U>
All Implemented Interfaces: java.io.Serializable, Logging
2、ParallelCollectionRDD：利用并行化方式，将集合创建为RDD的时候生的的对象
public class ParallelCollectionRDD<T> extends RDD<T>
参考官网MapPartitionsRDD：http://spark.apache.org/docs/1.2.2/api/java/org/apache/spark/rdd/MapPartitionsRDD.html
各种RDD的实现：http://spark.apache.org/docs/1.2.2/api/java/org/apache/spark/rdd/package-summary.html
6、RDD的Lineage血统
1、RDD血统：数据容错，发生错误，可以进行重算恢复。Lineage记录的是特定数据的 Transformation 转换操作。
为了保证RDD中数据的鲁棒性，RDD数据集通过所谓的血统关系(Lineage)记住了它是如何从其它RDD中演变过来的。
相比其它系统的细颗粒度的内存数据更新级别的备份或者LOG机制，RDD的Lineage记录的是粗颗粒度的特定数据转换（Transformation）操作（filter, map, join etc.)行为。当这个RDD的部分分区数据丢失时，它可以通过Lineage获取足够的信息来重新运算和恢复丢失的数据分区。这种粗颗粒的数据模型，限制了Spark的运用场合，但同时相比细颗粒度的数据模型，也带来了性能的提升
2、宽窄依赖的Lineage容错
对与Wide Dependencies，这种计算的输入和输出在不同的节点上，lineage方法对与输入节点完好，而输出节点宕机时，通过重新计算，这种情况下，这种方法容错是有效的，否则无效，因为无法重试，需要向上其祖先追溯看是否可以重试（这就是lineage，血统的意思）。
Narrow Dependencies对于数据的重算开销要远小于Wide Dependencies的数据重算开销。
在RDD计算，通过checkpoint进行容错，做checkpoint有两种方式，一个是checkpoint data，一个是logging the updates。用户可以控制采用哪种方式来实现容错，默认是logging the updates方式，通过记录跟踪所有生成RDD的转换（transformations）也就是记录每个RDD的lineage（血统）来重新计算生成丢失的分区数据。
参考博客：https://blog.csdn.net/u013063153/article/details/73865123