Spark介绍
Apache Spark™ is a fast and general engine for large-scale data
processing.
Spark Introduce
Run programs up to 100x faster than Hadoop MapReduce in memory,
or 10x faster on disk.
Apache Spark has an advanced DAG execution engine that supports
acyclic data flow and in-memory computing.
Write applications quickly in Java, Scala, Python, R.
Spark offers over 80 high-level operators that make it easy to
build parallel apps. And you can use it interactively from the
Scala, Python and R shells.
Combine SQL, streaming, and complex analytics.
Spark powers a stack of libraries including SQL and
DataFrames, MLlib for machine learning, GraphX, and Spark
Streaming. You can combine these libraries seamlessly in the
same application.
Spark是UC Berkeley AMP lab (加州大学伯克利分校的AMP实验室)所开
源的，后贡献给Apache。是一种快速、通用、可扩展的大数据分析引
擎。它是不断壮大的大数据分析解决方案家族中备受关注的明星成员，为
分布式数据集的处理提供了一个有效框架，并以高效的方式处理分布式数
据集。Spark集批处理、实时流处理、交互式查询、机器学习与图计算于
一体，避免了多种运算场景下需要部署不同集群带来的资源浪费。目前，
Spark社区也成为大数据领域和Apache软件基金会最活跃的项目之一，
其活跃度甚至远超曾经只能望其项背的Hadoop。
Spark的技术背景
无论是工业界还是学术界，都已经广泛使用高级集群编程模型来处理日益
增长的数据，如MapReduce和Dryad。这些系统将分布式编程简化为自
动提供位置感知性调度、容错以及负载均衡，使得大量用户能够在商用集
群上分析超大数据集。
大多数现有的集群计算系统都是基于非循环的数据流模型。即从稳定的物
理存储（如分布式文件系统）中加载记录，记录被传入由一组确定性操作
构成的DAG（Directed Acyclic Graph，有向无环图），然后写回稳定存
储。DAG数据流图能够在运行时自动实现任务调度和故障恢复。
尽管非循环数据流是一种很强大的抽象方法，但仍然有些应用无法使用这
种方式描述。这类应用包括：①机器学习和图应用中常用的迭代算法（每
一步对数据执行相似的函数）
②交互式数据挖掘工具（用户反复查询一个数据子集）
基于数据流的框架并不明确支持工作集，所以需要将数据输出到磁盘，然
后在每次查询时重新加载，这会带来较大的开销。针对上述问题，Spark
实现了一种分布式的内存抽象，称为弹性分布式数据集
（Resilient Distributed Dataset，RDD ）。它支持基于工作集的应用，
同时具有数据流模型的特点：自动容错、位置感知性调度和可伸缩
性。RDD允许用户在执行多个查询时显式地将工作集缓存在内存中，后
续的查询能够重用工作集，这极大地提升了查询速度。
Spark VS MapReduce
MapReduce存在的问题
一个 Hadoop job 通常都是这样的：
1）从 HDFS 读取输入数据；
2）在 Map 阶段使用用户定义的 mapper function, 然后把结果Spill到磁盘；
3）在 Reduce 阶段，从各个处于 Map 阶段的机器中读取 Map 计算的中间结果，使用用户
定义的 reduce function, 通常最后把结果写回 HDFS;
Hadoop的问题在于，一个 Hadoop job 会进行多次磁盘读写，比如写入机器本地磁盘，或
是写入分布式文件系统中（这个过程包含磁盘的读写以及网络传输）。考虑到磁盘读取比内存
读取慢了几个数量级，所以像 Hadoop 这样高度依赖磁盘读写的架构就一定会有性能瓶颈。
此外，在实际应用中我们通常需要设计复杂算法处理海量数据, 而且不是一个 Hadoop job 可
以完成的。比如机器学习领域，需要大量使用迭代的方法训练机器学习模型。而像 Hadoop
的基本模型就只包括了一个 Map 和 一个 Reduce 阶段，想要完成复杂运算就需要切分出无
数单独的 Hadoop jobs, 而且每个 Hadoop job 都是磁盘读写大户，这就让 Hadoop 显得力
不从心。
随着业界对大数据使用越来越深入，大家都呼唤一个更强大的处理框架，能够真正解决更多复
杂的大数据问题。
Spark的优势
2009年，美国加州大学伯克利分校的 AMPLab 设计并开发了名叫 Spark 的大数据处理框
架。真如其名，Spark 像燎原之火，迅猛占领大数据处理框架市场。
Spark 没有像 Hadoop 一样使用磁盘读写，而转用性能高得多的内存存储输入数据、处理中
间结果、和存储最终结果。在大数据的场景中，很多计算都有循环往复的特点，像 Spark 这
样允许在内存中缓存输入输出，上一个 job 的结果马上可以被下一个使用，性能自然要
比 Hadoop MapReduce 好得多。
同样重要的是，Spark 提供了更多灵活可用的数据操作，比如 filter, join, 以及各种
对 key value pair 的方便操作，甚至提供了一个通用接口，让用户根据需要开发定制的数据
操作。
此外，Spark 本身作为平台也开发了 streaming 处理框架 spark streaming, SQL 处理框
架 Dataframe, 机器学习库 MLlib, 和图处理库 GraphX. 如此强大，如此开放，基
于 Spark 的操作，应有尽有。
Hadoop 的 MapReduce 为什么不使用内存存储？
是历史原因。当初 MapReduce 选择磁盘，除了要保证数据存储安全以外，更重要的是当时
企业级数据中心购买大容量内存的成本非常高，选择基于内存的架构并不现实；现在 Spark
真的赶上了好时候，企业可以轻松部署多台大内存机器，内存大到可以装载所有要处理的数
据。
Spark单机模式安装
实现步骤：
1）安装和配置好JDK
2）上传和解压Spark安装包
3）进入Spark安装目录下的conf目录
复制conf spark-env.sh.template 文件为 spark-env.sh
在其中修改，增加如下内容：
SPARK_LOCAL_IP=服务器IP地址
Spark单机模式启动
在bin目录下执行：sh spark-shell --master=local
启动后 发现打印消息
Spark context Web UI available at http://192.168.242.101:4040//Spark的浏览器界面
Spark context available as ‘sc’ (master = local, app id = local-1490336686508).//Spark
提供了环境对象 sc
Spark session available as ‘spark’.//Spark提供了会话独享spark
RDD介绍
概述
Resilient Distributed Datasets (RDDs)
Spark revolves around the concept of a resilient distributed
dataset (RDD), which is a fault- -n tolerant collection of elements
that can be operated on in parallel. There are two ways to
create RDDs: parallelizing an existing collection in your driver
program, or referencing a dataset in an external storage system,
such as a shared filesystem, HDFS, HBase, or any data source
offering a Hadoop InputFormat.
RDD就是带有分区的集合类型
弹性分布式数据集（RDD），特点是可以并行操作，并且是容错的。有两
种方法可以创建RDD：
1）执行Transform操作（变换操作），
2）读取外部存储系统的数据集，如HDFS，HBase，或任何与Hadoop有关
的数据源。
RDD入门示例
案例一：
Parallelized collections are created by
calling SparkContext’s parallelize method on an existing
collection in your driver program (a Scala Seq). The elements of
the collection are copied to form a distributed dataset that can
be operated on in parallel. For example, here is how to create a
parallelized collection holding the numbers 1 to 5:
val data = Array(1, 2, 3, 4, 5)
val r1 = sc.parallelize(data)
l val r2 = sc.parallelize(data,2)
你可以这样理解RDD：它是spark提供的一个特殊集合类。诸如普通的集
合类型，如传统的Array：（1,2,3,4,5）是一个整体，但转换成RDD后，
我们可以对数据进行Partition（分区）处理，这样做的目的就是为了分布
式。
你可以让这个RDD有两个分区，那么有可能是这个形式：RDD(1,2)
(3,4)。
这样设计的目的在于：可以进行分布式运算。
注：创建RDD的方式有多种，比如案例一中是基于一个基本的集合类型
（Array）转换而来，像parallelize这样的方法还有很多，之后就会学
到。此外，我们也可以在读取数据集时就创建RDD。
案例二：
Spark can create distributed datasets from any storage source
supported by Hadoop, including your local file system, HDFS,
Cassandra, HBase, Amazon S3, etc. Spark supports text
files, SequenceFiles, and any other Hadoop InputFormat.
Text file RDDs can be created
using SparkContext’s textFile method. This method takes an URI
for the file (either a local path on the machine, or
a hdfs://, s3n://, etc URI) and reads it as a collection of
lines. Here is an example invocation:
val distFile = sc.textFile(“data.txt”)
查看RDD
scala>rdd.collect
收集rdd中的数据组成Array返回，此方法将会把分布式存储的rdd中的数据
集中到一台机器中组建Array。
在生产环境下一定要慎用这个方法，容易内存溢出。
查看RDD的分区数量：scala>rdd.partitions.size
查看RDD每个分区的元素：scala>rdd.glom.collect
此方法会将每个分区的元素以Array形式返回
分区概念
在上图中， 一个RDD有item1~item25个数据，共5个分区，分别在3台
机器上进行处理。
此外，spark并没有原生的提供rdd的分区查看工具 我们可以自己来写一个
示例代码：
import org.apache.spark.rdd.RDD
import scala.reflect.ClassTag
object su {
def debug[T: ClassTag](rdd: RDD[T]) = {
rdd.mapPartitionsWithIndex((i: Int, iter: Iterator[T]) => {
val m = scala.collection.mutable.MapInt, List[T]
var list = ListT
while (iter.hasNext) {
list = list :+ iter.next
}
m(i) = list
m.iterator
}).collect().foreach((x: Tuple2[Int, List[T]]) => {
val i = x.1
println(s"partition:[$i]")
x.2.foreach { println }
})
}
}
RDD操作
概述
针对RDD的操作，分两种，一种是Transformation（变换），一种是Actions（执行）。
Transformation（变换）操作属于懒操作（算子），不会真正触发RDD的处理计算。
Actions（执行）操作才会真正触发。
Transformations
Actions
案例：通过rdd实现统计文件中的单词数量
sc.textFile("/root/work/words.txt").flatMap(.split(" ")).map((,1)).reduceByKey(+).saveAsTextFile("/root/work/wcresult")
DAG概念
概述
Spark会根据用户提交的计算逻辑中的RDD的转换和动作来生成RDD之间的依赖关系，同时
这个计算链也就生成了逻辑上的DAG。接下来以“Word Count”为例，详细描述这个DAG
生成的实现过程。
Spark Scala版本的Word Count程序如下：
1： val file=sc.textFile(“hdfs://hadoop01:9000/hello1.txt”)
2： val counts = file.flatMap(line => line.split(" "))
3： .map(word => (word, 1))
4： .reduceByKey(_ + _)
5： counts.saveAsTextFile(“hdfs://…”)
file和counts都是RDD，其中file是从HDFS上读取文件并创建了RDD，而counts是在file的基
础上通过flatMap、map和reduceByKey这三个RDD转换生成的。最后，counts调用了动作
saveAsTextFile，用户的计算逻辑就从这里开始提交的集群进行计算。那么上面这5行代码的
具体实现是什么呢？
1）行1：sc是org.apache.spark.SparkContext的实例，它是用户程序和Spark的交互接口，
会负责连接到集群管理者，并根据用户设置或者系统默认设置来申请计算资源，完成RDD的
创建等。
sc.textFile（“hdfs：//…”）就完成了一个org.apache.spark.rdd.HadoopRDD的创建，并且
完成了一次RDD的转换：通过map转换到一个org.apache.spark.rdd.MapPartitions-RDD。
也就是说，file实际上是一个MapPartitionsRDD，它保存了文件的所有行的数据内容。
2）行2：将file中的所有行的内容，以空格分隔为单词的列表，然后将这个按照行构成的单词
列表合并为一个列表。最后，以每个单词为元素的列表被保存到MapPartitionsRDD。
3）行3：将第2步生成的MapPartittionsRDD再次经过map将每个单词word转为
（word，1）的元组。这些元组最终被放到一个MapPartitionsRDD中。
4）行4：首先会生成一个MapPartitionsRDD，起到map端combiner的作用；然后会生成一
个ShuffledRDD，它从上一个RDD的输出读取数据，作为reducer的开始；最后，还会生成一
个MapPartitionsRDD，起到reducer端reduce的作用。
5）行5：向HDFS输出RDD的数据内容。最后，调用
org.apache.spark.SparkContext#runJob向集群提交这个计算任务。
RDD之间的关系可以从两个维度来理解：一个是RDD是从哪些RDD转换而来，也就是RDD的
parent RDD（s）是什么；还有就是依赖于parent RDD（s）的哪些Partition（s）。这个关
系，就是RDD之间的依赖，org.apache.spark.Dependency。根据依赖于parent RDD（s）
的Partitions的不同情况，Spark将这种依赖分为两种，一种是宽依赖，一种是窄依赖。
RDD的依赖关系
RDD的依赖关系
RDD和它依赖的parent RDD（s）的关系有两种不同的类型，即窄依赖
（narrow dependency）和宽依赖（wide dependency）。
1）窄依赖指的是每一个parent RDD的Partition最多被子RDD的一个Partition使用，如下图
所示。
2）宽依赖指的是多个子RDD的Partition会依赖同一个parent RDD的Partition。
我们可以从不同类型的转换来进一步理解RDD的窄依赖和宽依赖的区别，如下图所示。
窄依赖
对于窄依赖操作，它们只是将Partition的数据根据转换的规则进行转化，并不涉及其他的处
理，可以简单地认为只是将数据从一个形式转换到另一个形式。
窄依赖底层的源码：
abstract class NarrowDependency[T](_rdd: RDD[T]) extends Dependency[T] {
//返回子RDD的partitionId依赖的所有的parent RDD的Partition(s)
def getParents(partitionId: Int): Seq[Int]
override def rdd: RDD[T] = _rdd
}
class OneToOneDependency[T](rdd: RDD[T]) extends NarrowDependencyT {
override def getParents(partitionId: Int) = List(partitionId)
}
所以对于窄依赖，并不会引入昂贵的Shuffle。所以执行效率非常高。如果整个DAG中存在多
个连续的窄依赖，则可以将这些连续的窄依赖整合到一起连续执行，中间不执行shuffle 从而
提高效率，这样的优化方式称之为流水线优化。
此外，针对窄依赖，如果子RDD某个分区数据丢失，只需要找到父RDD对应依赖的分区，恢
复即可。但如果是宽依赖，当分区丢失时，最糟糕的情况是要重算所有父RDD的所有分区。
宽依赖
对于groupByKey这样的操作，子RDD的所有Partition（s）会依赖于parent RDD的所有
Partition（s），子RDD的Partition是parent RDD的所有Partition Shuffle的结果。
宽依赖的源码：
class ShuffleDependency[K, V, C](
@transient rdd: RDD[ <: Product2[K, V]],
val partitioner: Partitioner,
val serializer: Option[Serializer] = None,
val keyOrdering: Option[Ordering[K]] = None,
val aggregator: Option[Aggregator[K, V, C]] = None,
val mapSideCombine: Boolean = false)
extends Dependency[Product2[K, V]] {
override def rdd = _rdd.asInstanceOf[RDD[Product2[K, V]]]
//获取新的shuffleId
val shuffleId: Int = _rdd.context.newShuffleId()
//向ShuffleManager注册Shuffle的信息
val shuffleHandle: ShuffleHandle =
_rdd.context.env.shuffleManager.registerShuffle(
shuffleId, _rdd.partitions.size, this)
rdd.sparkContext.cleaner.foreach(.registerShuffleForCleanup(this))
}
Shuffle概述
spark中一旦遇到宽依赖就需要进行shuffle的操作，所谓的shuffle的操作的本质就是将数据
汇总后重新分发的过程。
这个过程数据要汇总到一起，数据量可能很大所以不可避免的需要进行数据落磁盘的操作，会
降低程序的性能，所以spark并不是完全内存不读写磁盘，只能说它尽力避免这样的过程来提
高效率 。
spark中的shuffle，在早期的版本中，会产生多个临时文件，但是这种多临时文件的策略造成
大量文件的同时的读写，磁盘的性能被分摊给多个文件，每个文件读写效率都不高，影响
spark的执行效率。所以在后续的spark中(1.2.0之后的版本)的shuffle中，只会产生一个文
件，并且数据会经过排序再附加索引信息，减少了文件的数量并通过排序索引的方式提升了性
能。
DAG的生成与Stage的划分
DAG的生成
原始的RDD（s）通过一系列转换就形成了DAG。RDD之间的依赖关系，包含了RDD由哪些ParentRDD（s）转换而
来和它依赖parent RDD（s）的哪些Partitions，是DAG的重要属性。
借助这些依赖关系，DAG可以认为这些RDD之间形成了Lineage（血统，血缘关系）。借助Lineage，能保证一个
RDD被计算前，它所依赖的parent RDD都已经完成了计算；同时也实现了RDD的容错性，即如果一个RDD的部分或
者全部的计算结果丢失了，那么就需要重新计算这部分丢失的数据。
RDD是分布式的，弹性的，容错的数据结构
Spark的Stage（阶段)
Spark在执行任务（job）时，首先会根据依赖关系，将DAG划分为不同的阶段（Stage）。
处理流程是：
1）Spark在执行Transformation类型操作时都不会立即执行，而是懒执行（计算）
2）执行若干步的Transformation类型的操作后，一旦遇到Action类型操作时，
才会真正触发执行（计算）
3）执行时，从当前Action方法向前回溯，如果遇到的是窄依赖则应用流水线优化，
继续向前找，直到碰到某一个宽依赖
4）因为宽依赖必须要进行shuffle，无法实现优化，
所以将这一次段执行过程组装为一个stage
5）再从当前宽依赖开始继续向前找。重复刚才的步骤，从而将这个DAG还分为若干的stage
在stage内部可以执行流水线优化，而在stage之间没办法执行流水线优化，因为有shuffle。但是这种机制已经尽力的
去避免了shuffle。
Spark的Job和Task
原始的RDD经过一系列转换后（一个DAG），会在最后一个RDD上触发一个动作，这个动作会生成一个Job。
所以可以这样理解：一个DAG对应一个Spark的Job。
在Job被划分为一批计算任务（Task）后，这批Task会被提交到集群上的计算节点去计算
Spark的Task分为两种：
1）org.apache.spark.scheduler.ShuffleMapTask
2）org.apache.spark.scheduler.ResultTask
简单来说，DAG的最后一个阶段会为每个结果的Partition生成一个ResultTask，其余所有的阶段都会生成Shuff
可视化理解窄依赖和宽依赖
案例 单词统计
scala>val data=sc.textFile("/home/software/hello.txt",2)
scala> data.flatMap(.split(" ")).map((,1)).reduceByKey(+).collect
1）打开web页面控制台（ip:4040端口地址），刷新，会发现刚才的操作会出现在页面上
2）点击 Description下的 collect at…… 进入job的详细页面
3）点击 DAG Visualization 会出现如下图形
Spark框架核心概念
1.RDD。弹性分布式数据集，是Spark最核心的数据结构。有分区机制，所以可以分布式进行
处理。有容错机制，通过RDD之间的依赖关系来恢复数据。
2.依赖关系。RDD的依赖关系是通过各种Transformation（变换）来得到的。父RDD和子
RDD之间的依赖关系分两种：①窄依赖 ②宽依赖
①针对窄依赖：父RDD的分区和子RDD的分区关系是：一对一
窄依赖不会发生Shuffle，执行效率高，spark框架底层会针对多个连续的窄依赖执行流水线优
化，从而提高性能。例如 map flatMap等方法都是窄依赖方法
②针对宽依赖：父RDD的分区和子RDD的分区关系是：一对多
宽依赖会产生shuffle，会产生磁盘读写，无法优化。
3.DAG。有向无环图，当一整条RDD的依赖关系形成之后，就形成了一个DAG。一般来说，
一个DAG，最后都至少会触发一个Action操作，触发执行。一个Action对应一个Job任务。
4.Stage。一个DAG会根据RDD之间的依赖关系进行Stage划分，流程是：以Action为基准，
向前回溯，遇到宽依赖，就形成一个Stage。遇到窄依赖，则执行流水线优化（将多个连续的
窄依赖放到一起执行）
5.task。任务。一个分区对应一个task。可以这样理解：一个Stage是一组Task的集合
6.RDD的Transformation（变换）操作：懒执行，并不会立即执行
7.RDD的Action(执行）操作：触发真正的执行
Spark集群模式安装
实现步骤：
1）上传解压spark安装包
2）进入spark安装目录的conf目录
3）配置spark-env.sh文件
配置示例：
#本机ip地址
SPARK_LOCAL_IP=hadoop01
#spark的shuffle中间过程会产生一些临时文件，此项指定的是其存放目录，不配置默认是在
/tmp目录下
SPARK_LOCAL_DIRS=/home/software/spark/tmp
export JAVA_HOME=/home/software/jdk1.8
4）在conf目录下，编辑slaves文件
配置示例：
hadoop01
hadoop02
hadoop03
5）配置完后，将spark目录发送至其他节点，并更改对应的 SPARK_LOCAL_IP配置
启动集群
1）如果你想让01 虚拟机变为master节点，则进入01 的spark安装目录的sbin目录
执行： sh start-all.sh
2）通过jps查看各机器进程，
01：Master +Worker
02：Worker
03：Worker
3）通过浏览器访问管理界面
http://192.168.234.11:8080
4）通过spark shell 连接spark集群
进入spark的bin目录
执行：sh spark-shell.sh --master spark://192.168.234.11:7077
6）在集群中读取文件：
sc.textFile("/root/work/words.txt")
默认读取本机数据 这种方式需要在集群的每台机器上的对应位置上都一份该文件 浪费磁盘
7）所以应该通过hdfs存储数据
sc.textFile(“hdfs://hadoop01:9000/mydata/words.txt”);
注：可以在spark-env.sh 中配置选项 HADOOP_CONF_DIR 配置为hadoop的etc/hadoop的地址 使默认
访问的是hdfs的路径
注：如果修改默认地址是hdfs地址 则如果想要访问文件系统中的文件 需要指明协议为file 例如
sc.text(“file:///xxx/xx”)