基本介绍
Spark 计算框架为了能够进行高并发和高吞吐的数据处理，封装了三大数据结构，用于处理不同的应用场景。三大数据结构分别是：
- RDD : 弹性分布式数据集
- 累加器：分布式共享只写变量
- 广播变量：分布式共享只读变量
RDD
RDD基本介绍
RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是Spark 中最基本的数据处理模型。代码中是一个抽象类，它代表一个弹性的、不可变、可分区、里面的元素可并行计算的集合。
（1）弹性
- 存储的弹性：内存与磁盘的自动切换；
- 容错的弹性：数据丢失可以自动恢复；
- 计算的弹性：计算出错重试机制；
- 分片的弹性：可根据需要重新分片。
（2） 分布式：数据存储在大数据集群不同节点上
（3） 数据集：RDD 封装了计算逻辑，并不保存数据
（4）数据抽象：RDD 是一个抽象类，需要子类具体实现
（5）不可变：RDD 封装了计算逻辑，是不可以改变的，想要改变，只能产生新的RDD，在
新的RDD 里面封装计算逻辑
（6）可分区、并行计算
核心属性
/**
* Internally, each RDD is characterized by five main properties:
*
* - 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 数据结构中存在分区列表，用于执行任务时并行计算，是实现分布式计算的重要性。
/**
* 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]
（2）分区计算函数
Spark 在计算时，是使用分区函数对每一个分区进行计算。
/**
* :: DeveloperApi ::
* Implemented by subclasses to compute a given partition.
*/
@DeveloperApi
def compute(split: Partition, context: TaskContext): Iterator[T]
（3） RDD 之间的依赖关系
RDD 是计算模型的封装，当需求中需要将多个计算模型进行组合时，就需要将多个 RDD 建
立依赖关系
/**
* 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
(4)分区器（可选）
当数据为KV 类型数据时，可以通过设定分区器自定义数据的分区。
/** Optionally overridden by subclasses to specify how they are partitioned. */
@transient val partitioner: Option[Partitioner] = None
（5）首选位置（可选）
计算数据时，可以根据计算节点的状态选择不同的节点位置进行计算。
/**
* Optionally overridden by subclasses to specify placement preferences.
*/
protected def getPreferredLocations(split: Partition): Seq[String] = Nil
执行原理
从计算的角度来讲，数据处理过程中需要计算资源（内存 & CPU）和计算模型（逻辑）。执行时，需要将计算资源和计算模型进行协调和整合。
Spark 框架在执行时，先申请资源，然后将应用程序的数据处理逻辑分解成一个一个的计算任务。然后将任务发到已经分配资源的计算节点上, 按照指定的计算模型进行数据计算。最后得到计算结果。
RDD 是Spark 框架中用于数据处理的核心模型，在Yarn 环境中，RDD的工作原理:
(1)启动Yarn 集群环境
(2) Spark 通过申请资源创建调度节点和计算节点
(3)Spark 框架根据需求将计算逻辑根据分区划分成不同的任务
(4)调度节点将任务根据计算节点状态发送到对应的计算节点进行计算
从以上流程可以看出 RDD 在整个流程中主要用于将逻辑进行封装，并生成Task 发送给
Executor 节点执行计算。
基础编程
RDD创建
在Spark 中创建RDD 的创建方式可以分为四种：
（1）从集合（内存）中创建 RDD
从集合中创建RDD，Spark 主要提供了两个方法：parallelize ()和makeRDD()
package com.atguigu.bigdata.spark.core.rdd.builder
import org.apache.spark.rdd.RDD
import org.apache.spark.{
SparkConf, SparkContext}
object Spark01_RDD_Memory {
def main(args: Array[String]): Unit = {
//TODO 准备环境
val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
//TODO 创建RDD
//从内存中创建：将内存中集合的数据作为处理的数据源
val seq = Seq[Int](1,2,3,4)
//parallelize：并行
// val rdd: RDD[Int] = sc.parallelize(seq)
//另外一个方法makeRDD():在底层实现时候其实就是调用了rdd对象的paralleliz方法
val rdd: RDD[Int] = sc.makeRDD(seq)
rdd.collect().foreach(println)
//TODO 关闭环境
sc.stop()
}
}
从底层代码实现来讲，makeRDD() 方法其实就是parallelize() 方法。底层代码如下：
def makeRDD[T: ClassTag](
seq: Seq[T],
numSlices: Int = defaultParallelism): RDD[T] = withScope {
parallelize(seq, numSlices)
}
（2) 从外部存储（文件）创建RDD
由外部存储系统的数据集创建RDD 包括：本地的文件系统，所有Hadoop 支持的数据集，比如HDFS、HBase 等。
package com.atguigu.bigdata.spark.core.rdd.builder
import org.apache.spark.rdd.RDD
import org.apache.spark.{
SparkConf, SparkContext}
object Spark02_RDD_File {
def main(args: Array[String]): Unit = {
//TODO 准备环境
val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
val sc = new SparkContext(sparkConf)
//TODO 创建RDD
//从内存中创建：将文件中的数据作为处理的数据源
//path路径默认以当前环境的根路径为基准，可以写绝对路径，也可以写相对路径
// val rdd: RDD[String] = sc.textFile("datas/1.txt") //相对路径
//path路径可以是文件的具体路径，也可以是目录
// val rdd: RDD[String] = sc.textFile("datas") //统计目录中所有文件
//path路径还可以使用通配符
val rdd: RDD[String] = sc.textFile("datas/1*.txt")
//path路径还可以是分布式存储系统路径：HDFS
rdd.collect().foreach(println)
//TODO 关闭环境
sc.stop()
}
}
（3）从其他RDD结果创建
主要是通过一个RDD 运算完后，再产生新的RDD。
（4）直接创建RDD（new）
RDD 并行度与分区
默认情况下，Spark 可以将一个作业切分多个任务后，发送给Executor 节点并行计算，而能
够并行计算的任务数量我们称之为并行度。这个数量可以在构建RDD 时指定。
注意：这里的并行执行的任务数量，并不是指的切分任务的数量。
package com.atguigu.bigdata.spark.core.rdd.builder
import org.apache.spark.rdd.RDD
import org.apache.spark.{
SparkConf, SparkContext}
object Spark01_RDD_Memory_Par {
def main(args: Array[String]): Unit = {
//TODO 准备环境
val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
sparkConf.set("spark.default.parallelism","4") //也可以配
val sc = new SparkContext(sparkConf)
//TODO 创建RDD
//RDD的并行度 & 分区
//makeRDD可以传第二个参数，第二个参数表示分区数
//第二个参数可以不传递，不传的话，使用默认值：defaultParallelism(默认并行度)
// val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)
// scheduler.conf.getInt("spark.default.parallelism", totalCores)
// spark在默认情况下，从配置对象中获取配置参数：spark.default.parallelism
// 如果获取不到，那么使用totalCores属性，这个属性取值为当前运行环境的最大可用核数，也可以自己配置
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
rdd.saveAsTextFile("output")
//TODO 关闭环境
sc.stop()
}
}
读取内存数据时，数据可以按照并行度的设定进行数据的分区操作，数据分区规则的Spark 核心源码如下：
def positions(length: Long, numSlices: Int): Iterator[(Int, Int)] = {
(0 until numSlices).iterator.map {
i =>
val start = ((i * length) / numSlices).toInt
val end = (((i + 1) * length) / numSlices).toInt
(start, end)
}
}
读取文件数据时，数据是按照Hadoop 文件读取的规则进行切片分区，而切片规则和数
据读取的规则有些差异，具体 Spark 核心源码如下：
public InputSplit[] getSplits(JobConf job, int numSplits)
throws IOException {
long totalSize = 0; // compute total size
for (FileStatus file: files) {
// check we have valid files
if (file.isDirectory()) {
throw new IOException("Not a file: "+ file.getPath());
}
totalSize += file.getLen();
}
long goalSize = totalSize / (numSplits == 0 ? 1 : numSplits);
long minSize = Math.max(job.getLong(org.apache.hadoop.mapreduce.lib.input.
FileInputFormat.SPLIT_MINSIZE, 1), minSplitSize);
...
for (FileStatus file: files) {
...
if (isSplitable(fs, path)) {
long blockSize = file.getBlockSize();
long splitSize = computeSplitSize(goalSize, minSize, blockSize);
...
}
protected long computeSplitSize(long goalSize, long minSize,
long blockSize) {
return Math.max(minSize, Math.min(goalSize, blockSize));
}