Spark学习01（Spark概念+RDD概念）

一、Spark是什么

Spark是一种快速、通用、可扩展的大数据分析引擎。Spark生态系统已经发展成为一个包含多个子项目的集合，其中包含SparkSQL、Spark Streaming、GraphX、MLib、SparkR等子项目，Spark是基于内存计算的大数据并行计算框架。除了扩展了广泛使用的 MapReduce 计算模型，而且高效地支持更多计算模式，包括交互式查询和流处理。

二、Spark的运行模式

Local：用在本地测试。
Standalone：Spark自带的资源调度框架，支持完全分布式。
Spark On Yarn：Spark也是可以基于Yarn来计算的（如果Yarn集群内存够，那么Spark项目一般在Yarn运行）。
Mesos：资源调度框架。

三、在集群提交jar包

./bin/spark-submit \
--class day06.SparkWC \
--master spark://node1:7077 \
--executor-memory 512m \
--total-executor-cores 2 \
original-sz1901-1.0-SNAPSHOT.jar 

--class 应用程序包的要运行的class
--master 提交任务到哪里执行的地址
--executor-memory 每个executor的运行内存
--total-executor-cores 所有executor总的核

四、名词解释&Spark任务提交流程

Client：客户端，负责提交作业到集群

Driver：Spark启动的主进程，负责任务的提交，同时和Master、Worker进行交互，更重要一点负责保存元数据信息（内存里用完就丢）

SparkContext：整个任务的执行入口（相当于任务触发位置）

SchedulerBackend：SparkContext 使用 SchedulerBackend 来与不同资源管理系统对接，并维护着 Executor 的信息，TaskScheduler 向 Executor 提交任务也是通过 SchedulerBackend 来完成的。

DagScheduler：主要负责 遇到Actoin算子就触发Job，任务Stage划分（shuffle），根据Partition的数量确定Task数量，然后提交所有Task到TaskSet中

Task：一个Stage中包含多个Task，Task数量=Partition数量，一个Task就是用一个任务

TaskSet：是Task的容器，包含多个Task

TaskScheduler：负责和Executor进行交互，然后将所有TaskSet内的Task提交至注册好的Executor运行

Master：代表集群的主节点，负责接收Client提交的作业，管理资源调度，启动对应worker的Executor;

Worker：代表集群中的守护进程，负责创建任务进程，定时向Master汇报，起到与Driver交互的作用

Executor：执行作业的容器，集群可以有多个Executor，每个Executor都是独立的和Driver进行交互，里面主要是封装资源和Task

Stage：根据有没有Shuffle阶段，Spark的任务会包含多个阶段

Job：一个程序的任务（在Spark中，一个Action算子触发一个Job）

RDD (Resilient Distributed Dataset)

---

叫做弹性分布式数据集，是Spark中数据抽象，它代表一个不可变，可分区，元素可并行计算的数据集合。
RDD弹性：

1) 自动进行内存和磁盘数据存储的切换

​ Spark优先把数据放到内存中，如果内存放不下，就会放到磁盘里面，程序进行自动的存储切换

2) 基于血统的高效容错机制

​ 在RDD进行转换和动作的时候，会形成RDD的Lineage依赖链，当某一个RDD失效的时候，可以通过重新计算上游的RDD来重新生成丢失的RDD数据。

3) Task如果失败会自动进行特定次数的重试

​ RDD的计算任务如果运行失败，会自动进行任务的重新计算，默认次数是4次。

4) Stage如果失败会自动进行特定次数的重试

​ 如果Job的某个Stage阶段计算失败，框架也会自动进行任务的重新计算，默认次数也是4次。

5) Checkpoint和Persist可主动或被动触发

​ RDD可以通过Persist持久化将RDD缓存到内存或者磁盘，当再次用到该RDD时直接读取就行。也可以将RDD进行检查点，检查点会将数据存储在HDFS中，该RDD的所有父RDD依赖都会被移除。

6) 数据调度弹性

​ Spark把这个JOB执行模型抽象为通用的有向无环图DAG，可以将多Stage的任务串联或并行执行，调度引擎自动处理Stage的失败以及Task的失败。

7) 数据分片的高度弹性

​ 可以根据业务的特征，动态调整数据分片的个数，提升整体的应用执行效率。

总结:

RDD是一个逻辑概念，一个RDD中有多个分区，一个分区在Executor节点上执行的时候，就是一个迭代器。

一个RDD有多个分区，一个分区肯定在一台机器上，但是一台机器可以有多个分区，我们要操作的是分布在多台机器上的数据，而RDD相当于数据的一个代理，对RDD操作其实就是对每个分区进行操作，就是对每台机器上的迭代器进行操作，因为迭代器引用着我们要操作的数据

5、RDD的特性

1、一系列分区是个数据集合

2、每个分区都作业着一个函数

3、RDD之间有依赖关系

4、 如果RDD里的数据是K-V形式的，那么会作用着HashPartitioner分区器

5、如果是读取HDFS文件，那么会有一个最优位置

使用Spark进行WordCount

object ScalaWC {
  def main(args: Array[String]): Unit = {
    //读取本地文件
    val lines = Source.fromFile("盗墓笔记.txt").getLines().toList //用.mkString时，为char,map()里面不能split
    val iterator = lines.iterator
    while (iterator.hasNext) println(iterator.next())
    //切分数据
    val arr = lines.map(_.split(" "))
    //过滤空格
    val filtered = arr.filter(_ != " ")
    //压平
    val flat = filtered.flatten
    //flat.foreach(x=>print(x+" "))  //结果 hello Alex hello Mark hello Mark hello Alice hello Alex Mark Alex
    println()
    //聚合操作
    val tuples = flat.map((_, 1))
    // tuples.foreach(y=>print(y))  //结果为(hello,1)(Alex,1)(hello,1)(Mark,1)(hello,1)(Mark,1)(hello,1)(Alice,1)(hello,1)(Alex,1)(Mark,1)(Alex,1)Map()
    //分组
    val group: Map[String, List[(String, Int)]] = tuples.groupBy(_._1) //转成List  再分组
    /*
    /输出结果 (Alex,List((Alex,1), (Alex,1), (Alex,1)))(Mark,List((Mark,1), (Mark,1), (Mark,1)))(Alice,List((Alice,1)))(hello,List((hello,1), (hello,1), (hello,1), (hello,1), (hello,1)))Map(Alex -> 3, Mark -> 3, Alice -> 1, hello -> 5)
    //List((hello,5), (Mark,3), (Alex,3), (Alice,1))
     */
    // group.foreach(x=>print(x))
    //求值
    // val sum = group.map(x=>(x._1,x._2.size))
    //输出:直接将value找到，聚合value   直接拿到List[(String,Int)
    val sum = group.mapValues(_.size)
    //排序(倒序.reverse)
    val sum2 = sum.toList.sortBy(_._2).reverse
    println(sum) //结果为：Map(Alex -> 3, Mark -> 3, Alice -> 1, hello -> 5)
    println(sum2) //结果为：List((hello,5), (Mark,3), (Alex,3), (Alice,1))   按value倒序输出
  }
}

Spark在进行任务调度的时候，会尽可能的将计算任务分配到所要处理数据的存储位置