Spark核心技术解析-CSDN博客

共同点:jar包提交后，就是在向ResourceManager 请求在某个NodeManager上发起ApplicationMaster，AM向 RM申请资源，RM分配NodeManager，NodeManager启动Container，在与spark的结合中基本一个Container对应一个executor，用于计算，最后NM向RM反馈计算完成，向AM反馈计算结果。

区别点: yarn-client 与 yarn-cluster 的关键不同在于 yarn-client 的 driver 在提交任务的那个机子上，它的ApplicationMaster在被分配到的NodeManager里只是一个用来运行executor的容器;

yarn-cluster的driver在ApplicationMaster里

使用场景: 因为driver是用来调度Application的，所以在yarn-client模式里，本机会与集群产生IO，从而导致网卡流量激增。好处是，执行时可以在本地看到所有的log，便于调试。所以一般用于测试环境。在yarn-cluster环境里，driver运行在集群的NodeManager里，没有IO相关问题，就是看日志的话不能在本地看，可以通过命令 yarn application-logs application id

详见链接 https://blog.csdn.net/zxr717110454/article/details/80636569#commentBox

SPARK部署方式

local，standalone，Yarn，Mesos

local：本地，用于测试

standalone：spark本身的调度系统，Mster+Slaves

Yarn：spark客户端直接连接yarn，不需额外构建spark集群

Mesos：不知道。

SPARK的基本组件

client，master，worker，driver，executor， sparkContext（sparkSession）

client : 提交作业

master：接收作业，分配worker资源

worker：启动 driver 和 executor

driver：实例化SparkContext(SparkSession)，运行 main函数，驱动作业运行

executor：就是个进程，到时候里面用线程池来运行 tasks，执行计算

SparkContext：程序的入口处

SPARK算子分类及优化

Transformation算子惰性地将已有数据集转换成一个新的数据集，延迟执行
Action算子触发Spark提交作业，并将数据输出到Spark系统中

Transformations map，filter，flatmap，mapPartitions，mapPartitionsWithIndex，sample，union，intersection，distinct，groupByKey

Action算子 reduce，collect，first，count，take，takeordered，taksSample，saveAsTextFile，countByKey

collect()操作慎用，会将分布式的在远程集群里面的数据拉取到driver端！！！！！这种方式在数据量大的情况下会走大量的网络传输，甚至可能出席那OOM内存溢出

优化：1.当数据量不大时，可用 mapPartitions 替代 map。mapPartitions是对一个partition的所有数据做map操作,map是对一个partition的每一条数据作操作

2.设置parallelize 并行度=RDD内并行的partition数量 And 资源并行的线程数(如local[4])

                  Sparkconf conf = new SparkConf().setAppName("xx").setMaster("local[4]");
                  conf.set("spark.default.parallelism","3") / JavaRDD<String> nameRDD = sc.parallelize(names,3) (parallelize并行集合)
                  提高资源并行度时要考虑对于partition并行度是否过多;提高partition并行度要考虑对应资源并行度是否足够

3.filter + coaleasce

filter后容易产生数据倾斜，coaleasce指定重新分区数，让数据均匀。

4.增大partition数目就用 repartition ，减少partition数目就用 coaleasce

SPARK的JOB,STAGE,TASK的认知和关系

spark的血缘关系依靠宽依赖和窄依赖来组成。

宽依赖就是一个父RDD对应多个RDD ， groupby ,join

窄依赖就是一个父RDD对应一个RDD , map，union，

宽依赖基本就需要shuffle。

(宽窄依赖的概念和 Transformation算子/Action算子的概念是不一样的，groupbykey的操作属于宽依赖，是Transformation算子，count是 Action算子)

JOB：spark的job与mr的job不一样，mr的job是 map和reduce.spark的job就是遇到action算子了，就划分为一个job开始立即执行

Stage:宽依赖和窄依赖的划分就是stage。意思是：遇到宽依赖，就可以划条竖线，把前面的包起来，前面的就是一个stage了。

所谓DAG有向无环图，就是 stage的划分 -----------------> 遇到 宽依赖才划分stage，遇到窄依赖不划分stage。因为有血缘关系所以有方向，但是是stage划分是一直前进的，所以没有环。

Task：stage里面一条管道链 pipeline ，算一个task。一个partition对应一个task，在最初始时，一个文件或者hadoop上的一个block块(128M)对应一个partition，在hql查询时，一个数据块对应一个partition。

SPARK任务的调度流程

提交作业后，driver启动后，driver实例化了SparkContext后

driver向 resourcemanager 注册并申请资源，

resourcemanger就去找分配worker的资源并创建 executor s ，

driver那边拿到数据，构建了RDD OBJECT，然后调用 runJob()，进入 DAG schedual里。

在DAG Schedual里进行了 JOB STAGE TASK的划分，

然后输送TaskSeT给 TASK Schedual，

worker端的executor创建好后就去找 TaskSchedual 要 task 来运行 ----(叫做 executor的反向注册)，

运行完了 driver就去告诉 resourcemanager 注销自己。

Spark 资源并行度和数据并行度设置

数据的并行度涉及到：hql的话就涉及到 hadoop上的数据块总数，就算做初始partition数目;

有输入文件的话就涉及到输入文件的数目，为初始partition数目；

代码里设置的 sc.parallelize(18) 参数，为接下来的partition数目；

repartition算子/coaleasce算子设置的参数，为接下来的partition数目；

资源并行度涉及到：代码里的 local[4] ，

executor-cores参数 * num-executors参数，

一般来讲，数据并行度 = 资源并行度的 2-3 倍

SPARK运行的常见参数:

--master yarn
--deploy-mode cluster
--conf spark.driver.memory=2G
--executor-memory 20g
--num-executors 20
--executor-cores 4
--conf spark.network.timeout=1400s
--conf spark.dynamicAllocation.executorIdleTimeout=1400s
--class com.iwc.Tower.RunMain

Spark的缓存策略

spark的缓存主要有cache() 和 persist()。

最底层的是persist()，因为即使是cache()，也会调用 persist()，只是在cache()中调用的话，RDD调用时默认持久化策略只有一个 MEMORY_ONLY，DataFrame的cache默认采用 MEMORY_AND_DISK 。单独 persist() 方法的话就可以选择策略，MEMORY_ONLY ，MEMORY_SER，MEMORY_ON_DISK 。

MEMORY_ONLY就是把数据一批一批的拉到内存中，拉不下就下一批再拉再计算。

MEMORY_SER就是把数据压缩一下再拉到内存来计算，一批一批。

MEMORY_ON_DISK 就是把数据全部拉到内存，放不下的就放到disk，内存里的和disk上的一起计算。

Spark的容错机制

1.设置检查点 checkpoint()

2.Lineage 血缘

Spark为什么比MR快

1.基于内存

2.Lineage 血缘

3.DAG有向无环图，遇到宽依赖划分stage，遇到窄依赖不划分stage

Spark面试常见问题：

1.请列举Spark的transformation算子（不少于8个），并简述功能（重点）

filter，flatmap，map，mapvalues，flatmapvalues，mappartitions，repartition，partition

reducebykey，groupbykey，sortbykey，

union，leftoutjoin，rightoutjoin，fullOuterJoin，join

2.请列举Spark的action算子（不少于6个），并简述功能（重点）

reduce，count，countbykey，collect，coaleasce

take，first，takesample，takeordered，saveAsTextfile

foreach，foreachpartition

2. repartition和coaleasce的关系和区别

repartition内部其实还是调用的coaleasce，只是加了参数 shuffle=true。

coaleasce根据参数的值来决定需不需要走shuffle。

增大分区数，用repartitiion；减小分区数，用 coaleasce

3.分别简述Spark中的缓存机制（cache和persist）与checkpoint机制，并指出两者的区别与联系

cache底层是persist。persist有 MEMORY_NOLY,MEMORY_SER,MEMORY_DISK三种策略。cache默认MEMORY_ONLY策略，不可修改。

无论是cache()还是persist()，都是依托于血缘关系的。checkpoint是物理上的，斩断血缘关系的。

4.简述SparkSQL中RDD、DataFrame、DataSet三者的区别与联系? （笔试重点）

RDD -------- > DataFrame RDD.toDF()

RDD -------- > DataSet RDD.toDS()

RDD:不说了

DataFrame:数据加数据结构 (schema)

DataSet 不太懂

该题暂未理解

参见 https://www.jianshu.com/p/c0181667daa0

5.coalesce和repartition的区别

1）关系：
两者都是用来改变RDD的partition数量的，repartition底层调用的就是coalesce方法：coalesce(numPartitions, shuffle = true)
2）区别：
repartition一定会发生shuffle，coalesce根据传入的参数来判断是否发生shuffle
一般情况下增大rdd的partition数量使用repartition，减少partition数量时使用coalesce

6. cache缓存级别

DataFrame的cache默认采用 MEMORY_AND_DISK 这和RDD 的默认方式不一样RDD cache 默认采用MEMORY_ONLY

7.释放缓存和缓存

缓存：(1)dataFrame.cache (2)sparkSession.catalog.cacheTable(“tableName”)
释放缓存：(1)dataFrame.unpersist (2)sparkSession.catalog.uncacheTable(“tableName”)

8.Spark Shuffle默认并行度

参数spark.sql.shuffle.partitions 决定默认并行度200

9.简述Spark的两种核心Shuffle（HashShuffle与SortShuffle）的工作流程（包括未优化的HashShuffle、优化的HashShuffle、普通的SortShuffle与bypass的SortShuffle）（重点）

10.Spark常用算子reduceByKey与groupByKey的区别，哪一种更具优势？（重点）

reduceByKey：按照key进行聚合，在shuffle之前有combine（预聚合）操作，返回结果是RDD[k,v]。
groupByKey：按照key进行分组，直接进行shuffle。
开发指导：reduceByKey比groupByKey，建议使用。但是需要注意是否会影响业务逻辑。

11.简述Spark中共享变量（广播变量和累加器）的基本原理与用途。（重点）

累加器（accumulator）是Spark中提供的一种分布式的变量机制，其原理类似于mapreduce，即分布式的改变，然后聚合这些改变。累加器的一个常见用途是在调试时对作业执行过程中的事件进行计数。而广播变量用来高效分发较大的对象。
共享变量出现的原因：
通常在向Spark 传递函数时，比如使用 map() 函数或者用 filter()传条件时，可以使用驱动器程序中定义的变量，但是集群中运行的每个任务都会得到这些变量的一份新的副本，更新这些副本的值也不会影响驱动器中的对应变量。
Spark的两个共享变量，累加器与广播变量，分别为结果聚合与广播这两种常见的通信模式突破了这一限制。

12.当Spark涉及到数据库的操作时，如何减少Spark运行中的数据库连接数？

使用foreachPartition代替foreach，在foreachPartition内获取数据库的连接。

13.如何使用Spark实现TopN的获取（描述思路或使用伪代码）（重点）

方法1：
（1）按照key对数据进行聚合（groupByKey）
（2）将value转换为数组，利用scala的sortBy或者sortWith进行排序（mapValues）数据量太大，会OOM。
方法2：
（1）取出所有的key
（2）对key进行迭代，每次取出一个key利用spark的排序算子进行排序
方法3：
（1）自定义分区器，按照key进行分区，使不同的key进到不同的分区
（2）对每个分区运用spark的排序算子进行排序

14.简述SparkSQL中RDD、DataFrame、DataSet三者的区别与联系? （笔试重点）

1）RDD
优点:
编译时类型安全?
编译时就能检查出类型错误
面向对象的编程风格?
直接通过类名点的方式来操作数据
缺点:
序列化和反序列化的性能开销?
无论是集群间的通信, 还是IO操作都需要对对象的结构和数据进行序列化和反序列化。
GC的性能开销，频繁的创建和销毁对象, 势必会增加GC
2）DataFrame
DataFrame引入了schema和off-heap
schema : RDD每一行的数据, 结构都是一样的，这个结构就存储在schema中。?Spark通过schema就能够读懂数据, 因此在通信和IO时就只需要序列化和反序列化数据, 而结构的部分就可以省略了。
3）DataSet
DataSet结合了RDD和DataFrame的优点，并带来的一个新的概念Encoder。
当序列化数据时，Encoder产生字节码与off-heap进行交互，能够达到按需访问数据的效果，而不用反序列化整个对象。Spark还没有提供自定义Encoder的API，但是未来会加入。
三者之间的转换：