关于Spark的面试题，你应该知道这些！

时间 2021-08-14

标签 javascript java node 面试 sql express apache 编程 json 缓存栏目 Spark 繁體版

原文原文链接

以前分享过一篇博客，????不会这20个Spark热门技术点，你敢出去面试大数据吗?，那一篇确实是很是精华，提炼出了很是重要一样很是高频的Spark技术点，也算是收到了一些朋友们的好评。本篇博客，博主打算再出个番外篇，也就是再为你们分享一些Spark面试题，敢问各位准备好了么~javascript

文章目录

一、Spark Application在没有得到足够的资源，job就开始执行了，可能会致使什么问题发生?

执行该job时候集群资源不足，致使执行job结束也没有分配足够的资源，分配了部分Executor，该job就开始执行task，应该是task的调度线程和Executor资源申请是异步的；若是想等待申请完全部的资源再执行job的：须要将spark.scheduler.maxRegisteredResourcesWaitingTime设置的很大；spark.scheduler.minRegisteredResourcesRatio 设置为1，可是应该结合实际考虑，不然很容易出现长时间分配不到资源，job一直不能运行的状况。java

二、driver的功能是什么？

一个Spark做业运行时包括一个Driver进程，也是做业的主进程，具备main函数，而且有SparkContext的实例，是程序的人口点；
功能：负责向集群申请资源，向master注册信息，负责了做业的调度，负责做业的解析、生成Stage并调度Task到Executor上。包括DAGScheduler，TaskScheduler

三、Spark中Work的主要工做是什么？

主要功能：管理当前节点内存，CPU的使用情况，接收master分配过来的资源指令，经过ExecutorRunner启动程序分配任务。node

worker就相似于包工头，管理分配新进程，作计算的服务，至关于process服务。面试

须要注意的是：sql

1）worker会不会汇报当前信息给master？worker心跳给master主要只有workid，它不会发送资源信息以心跳的方式给master，master分配的时候就知道work，只有出现故障的时候才会发送资源。express

2）worker不会运行代码，具体运行的是Executor是能够运行具体appliaction写的业务逻辑代码，操做代码的节点，它不会运行程序的代码的。apache

四、Spark为何比mapreduce快？

spark是基于内存进行数据处理的，MapReduce是基于磁盘进行数据处理的
spark中具备DAG有向无环图，DAG有向无环图在此过程当中减小了shuffle以及落地磁盘的次数
spark是粗粒度资源申请，也就是当提交spark application的时候，application会将全部的资源申请完毕，若是申请不到资源就等待，若是申请到资源才执行application，task在执行的时候就不须要本身去申请资源，task执行快，当最后一个task执行完以后task才会被释放。而MapReduce是细粒度资源申请，当提交application的时候，task执行时，本身申请资源，本身释放资源，task执行完毕以后，资源当即会被释放，task执行的慢，application执行的相对比较慢。

五、Mapreduce和Spark的都是并行计算，那么他们有什么相同和区别？

hadoop的一个做业称为job，job里面分为map task和reduce task，每一个task都是在本身的进程中运行的，当task结束时，进程也会结束。
spark用户提交的任务成为application，一个application对应一个sparkcontext，app中存在多个job，每触发一次action操做就会产生一个job。这些job能够并行或串行执行，每一个job中有多个stage，stage是shuffle过程当中DAGSchaduler经过RDD之间的依赖关系划分job而来的，每一个stage里面有多个task，组成taskset有TaskSchaduler分发到各个executor中执行，executor的生命周期是和app同样的，即便没有job运行也是存在的，因此task能够快速启动读取内存进行计算。
hadoop的job只有map和reduce操做，表达能力比较欠缺并且在mr过程当中会重复的读写hdfs，形成大量的io操做，多个job须要本身管理关系。而spark的迭代计算都是在内存中进行的，API中提供了大量的RDD操做如join，groupby等，并且经过DAG图能够实现良好的容错。

六、Spark应用程序的执行过程是什么？

构建Spark Application的运行环境（启动SparkContext），SparkContext向资源管理器（能够是Standalone、Mesos或YARN）注册并申请运行Executor资源；
资源管理器分配Executor资源并启动StandaloneExecutorBackend，Executor运行状况将随着心跳发送到资源管理器上；
SparkContext构建成DAG图，将DAG图分解成Stage，并把Taskset发送给Task Scheduler。Executor向SparkContext申请Task，Task Scheduler将Task发放给Executor运行同时SparkContext将应用程序代码发放给Executor。
Task在Executor上运行，运行完毕释放全部资源。

七、spark on yarn Cluster 模式下，ApplicationMaster和driver是在同一个进程么？

是,driver 位于ApplicationMaster进程中。该进程负责申请资源，还负责监控程序、资源的动态状况。编程

八、Spark on Yarn 模式有哪些优势？

与其余计算框架共享集群资源（eg.Spark框架与MapReduce框架同时运行，若是不用Yarn进行资源分配，MapReduce分到的内存资源会不多，效率低下）；资源按需分配，进而提升集群资源利用等。
相较于Spark自带的Standalone模式，Yarn的资源分配更加细致
Application部署简化，例如Spark，Storm等多种框架的应用由客户端提交后，由Yarn负责资源的管理和调度，利用Container做为资源隔离的单位，以它为单位去使用内存,cpu等。
Yarn经过队列的方式，管理同时运行在Yarn集群中的多个服务，可根据不一样类型的应用程序负载状况，调整对应的资源使用量，实现资源弹性管理。

九、spark中的RDD是什么，有哪些特性？

RDD（Resilient Distributed Dataset）叫作分布式数据集，是spark中最基本的数据抽象，它表明一个不可变，可分区，里面的元素能够并行计算的集合。json

五大特性：缓存

A list of partitions：一个分区列表，RDD中的数据都存储在一个分区列表中
A function for computing each split：做用在每个分区中的函数
A list of dependencies on other RDDs：一个RDD依赖于其余多个RDD，这个点很重要，RDD的容错机制就是依据这个特性而来的
Optionally,a Partitioner for key-value RDDs(eg:to say that the RDD is hash-partitioned)：可选的，针对于kv类型的RDD才有这个特性，做用是决定了数据的来源以及数据处理后的去向
可选项，数据本地性，数据位置最优

十、spark如何防止内存溢出？

driver端的内存溢出：

能够增大driver的内存参数：spark.driver.memory (default 1g)

map过程产生大量对象致使内存溢出：

具体作法能够在会产生大量对象的map操做以前调用repartition方法，分区成更小的块传入map。

数据不平衡致使内存溢出：

数据不平衡除了有可能致使内存溢出外，也有可能致使性能的问题，解决方法和上面说的相似，就是调用repartition从新分区。

shuffle后内存溢出：

shuffle内存溢出的状况能够说都是shuffle后，单个文件过大致使的。在Spark中，join，reduceByKey这一类型的过程，都会有shuffle的过程，在shuffle的使用，须要传入一个partitioner，大部分Spark中的shuffle操做，默认的partitioner都是HashPatitioner，默认值是父RDD中最大的分区数,这个参数经过spark.default.parallelism控制(在spark-sql中用spark.sql.shuffle.partitions) ， spark.default.parallelism参数只对HashPartitioner有效，因此若是是别的Partitioner或者本身实现的Partitioner就不能使用spark.default.parallelism这个参数来控制shuffle的并发量了。若是是别的partitioner致使的shuffle内存溢出，就须要从partitioner的代码增长partitions的数量。

standalone模式下资源分配不均匀致使内存溢出：

这种状况的解决方法就是同时配置–executor-cores或者spark.executor.cores参数，确保Executor资源分配均匀。使用rdd.persist(StorageLevel.MEMORY_AND_DISK_SER)代替rdd.cache()。

rdd.cache()和rdd.persist(Storage.MEMORY_ONLY)是等价的，在内存不足的时候rdd.cache()的数据会丢失，再次使用的时候会重算，而rdd.persist(StorageLevel.MEMORY_AND_DISK_SER)在内存不足的时候会存储在磁盘，避免重算，只是消耗点IO时间

十一、spark中cache和persist的区别？

cache：缓存数据，默认是缓存在内存中，其本质仍是调用persist。

persist:缓存数据，有丰富的数据缓存策略。数据能够保存在内存也能够保存在磁盘中，使用的时候指定对应的缓存级别就能够了。

十二、Spark手写WordCount程序

这个常出如今笔试阶段，手写WordCount算是一项基本技能。

//建立SparkConf并设置App名称和master地址
val conf=new SparkConf().setAppName(“wc”).setMaster(“Local[*]”)
//建立SparkContext，该对象是提交Spark App的入口
val sc=new SparkContext(conf)
//使用sc建立RDD并执行相应的transformation和action
val result=sc.textFile(“输入文件的路径”)
Val rdd2=result.flatmap(x=>x.split(“ ”))
.map((_,1)).reduceBykey((_+_)).saveAsTextFile(“输出文件路径”)
//关闭连接
sc.stop()

1三、Spark中建立RDD的方式总结3种

一、从集合中建立RDD；

val rdd = sc.parallelize(Array(1,2,3,4,5,6,7,8))
val rdd = sc.makeRDD(Array(1,2,3,4,5,6,7,8))

二、从外部存储建立RDD；

val rdd= sc.textFile("hdfs://node01:8020/data/test")

三、从其余RDD建立。

val rdd1 = sc.parallelize(Array(1,2,3,4))
val rdd2 =rdd.map(x=>x.map(_*2))

1四、经常使用算子

这个涉及到的算子就比较多了，感兴趣的朋友能够去看看博主的这两篇博客:

Spark之【RDD编程】详细讲解(No2)——《Transformation转换算子》

Spark之【RDD编程】详细讲解(No3)——《Action行动算子》

绝对不会让你失望的~

1五、什么是宽窄依赖

窄依赖指的是每个父RDD的Partition最多被子RDD的一个Partition使用。
宽依赖指的是多个子RDD的Partition会依赖同一个父RDD的Partition，会引发shuffle。

1六、任务划分的几个重要角色

RDD任务切分中间分为：Application、Job、Stage和Task

1）Application：初始化一个SparkContext即生成一个Application；

2）Job：一个Action算子就会生成一个Job；

3）Stage：根据RDD之间的依赖关系的不一样将Job划分红不一样的Stage，遇到一个宽依赖则划分一个Stage；

4）Task：Stage是一个TaskSet，将Stage划分的结果发送到不一样的Executor执行即为一个Task

1七、SparkSQL中RDD、DataFrame、DataSet三者的区别与联系?

RDD

弹性分布式数据集；不可变、可分区、元素能够并行计算的集合。

优势：

RDD编译时类型安全：编译时能检查出类型错误；
面向对象的编程风格：直接经过类名点的方式操做数据。

缺点：

序列化和反序列化的性能开销很大，大量的网络传输；
构建对象占用了大量的heap堆内存，致使频繁的GC（程序进行GC时，全部任务都是暂停）

DataFrame

DataFrame以RDD为基础的分布式数据集。

优势：

DataFrame带有元数据schema，每一列都带有名称和类型。
DataFrame引入了off-heap，构建对象直接使用操做系统的内存，不会致使频繁GC。
DataFrame能够从不少数据源构建；
DataFrame把内部元素当作Row对象，表示一行行的数据
DataFrame=RDD+schema

缺点：

编译时类型不安全；
不具备面向对象编程的风格。

Dataset

DataSet包含了DataFrame的功能，Spark2.0中二者统一，DataFrame表示为DataSet[Row]，即DataSet的子集。

（1）DataSet能够在编译时检查类型；

（2）而且是面向对象的编程接口。

（DataSet 结合了 RDD 和 DataFrame 的优势，并带来的一个新的概念 Encoder。当序列化数据时，Encoder 产生字节码与 off-heap 进行交互，可以达到按需访问数据的效果，而不用反序列化整个对象。）。

三者之间的转换：

1八、自定义函数的过程

1）建立DataFrame

scala> val df = spark.read.json("/export/spark/examples/people.json")
df: org.apache.spark.sql.DataFrame = [age: bigint, name: string]

2）打印数据

scala> df.show()
+----+-------+
| age|   name|
+----+-------+
|null|Michael|
|  30|   Andy|
|  19| Justin|

3）注册UDF，功能为在数据前添加字符串

scala> spark.udf.register("addName", (x:String)=> "Name:"+x)
res5: org.apache.spark.sql.expressions.UserDefinedFunction = UserDefinedFunction(<function1>,StringType,Some(List(StringType)))

4）建立临时表

scala> df.createOrReplaceTempView("people")

5）应用UDF

scala> spark.sql("Select addName(name), age from people").show()
+-----------------+----+
|UDF:addName(name)| age|
+-----------------+----+
|     Name:Michael|null|
|        Name:Andy|  30|
|      Name:Justin|  19|

本篇博客就分享到这里，建议全部没看过开头提到的《不会这20个Spark热门技术点，你敢出去面试大数据吗?》这篇博客的朋友都去阅读一下，真的墙裂推荐!!!

若是以上过程当中出现了任何的纰漏错误，烦请大佬们指正????

受益的朋友或对大数据技术感兴趣的伙伴记得点赞关注支持一波????

但愿咱们都能在学习的道路上越走越远????