子乌笔记Spark面试大全【持续更新】

ziwu1226

已于 2023-11-27 10:22:08 修改

阅读量172

点赞数

文章标签：大数据 spark 面试

于 2023-11-23 09:15:33 首次发布

本文链接：https://blog.csdn.net/ziwu1226/article/details/134568761

版权

Spark Base

Spark是解决什么问题的？

Apache Spark™ is a fast and general engine for large-scale dataprocessing.
spark专为大规模数据处理而设计的快速通用的计算引擎 （相对于MapReduce）

Spark历史

是来自UCB，加州大学伯克利分校的，13年捐赠给Apache，14年成为顶级项目，19年发布3.0，而我经常使用的时3.1.2

Spark 为什么有自己的调度器

yarn调度器出现的晚

Spark 常用的端口号

4040：Spark 查看当前Spark-shell运行任务情况
7077：Spark Master 内部通信端口号
8080：Spark Master Web端口号（类似于Hadoop 的NameNode）
18080：Spark 历史服务器端口号
8088：YARN 任务运行情况查看端口号

手写wordcount（Flink wordcount）

Spark的四大特点

1、快速(fast)
Map端输出的结果要落地到磁盘，reduce端从磁盘读取，输出结果还要落地到磁盘 map再进行读取（中间要经过shuffle过程）

Spark函数（类似于MapReduce）运行的时候，绝大多数的函数是可以在内存里面去迭代的。只有少部分的函数需要落地到磁盘
2、易用性(easy)
开发语言可以有多种，scala、Java、Python，R

Java开发好处：对于大数据的大型项目来说，设计到Hbase，hive，flumn，ssh等需要整合采用Java这个更成熟广泛的语言，更好。

Java开发坏处：代码不优雅，运行效率不如scala，但是发不了jdk1.8后，有了lambda表达式，代码好看了一点。

Scala开发好处：spark本身就是scala语言开发的，运行效率好，而且是函数式编程，代码优雅。

Spark里面有超过80个算子（类似于map reduce）等操作，spark开发起来更灵活，更简单。

3、通用性(unified)
Spark没有出现时，需要进行计算就需要安装MapReduce，批处理就需要安装hive，pig,实时分析就需要安装storm，机器学习就需要安装mahout或者mllib，需要进行查询就需要安装Hbase。

（大数据改变了这个世界，spark改变了大数据）

Spark出现后，计算时用sparkcore（里面有很多类似于（MapReduce）算子，有很多sql语句解决不了的问题，就使用类似于MapReduce的工具），如果想要进行sql操作，spark就有sparksql（进行批处理）来代替类似MapReduce的操作，想要实时分析，就有sparkStreaming，因为spark是大多数在内存里面进行迭代，效率高，所以有mahout 适合机器学习，还有图计算，大数据开发会涉及到sparksql（hive，pig），sparkStreaming（storm），spark core（MapReduce）

4、任何平台都唔那个运行(Scalable)
在Yarn，Mesos（是一个类似于yarn的资源管理器），standalone或者cloud（云端）上。

国内：选择yarn 上运行，因为我们之前的大数据平台就是hadoop搭建的

国外：选择Mesos，因为spark和MASOS是同一个团队编写的

Standalone不需要Mesos也不需要yarn，spark自己管理资源，有Master和Worker 相当于ResourceManager和Nodemanager

Access data in HDFS, Cassandra, HBase, Hive, Tachyon, and any Hadoopdata source.

Spark执行速度快的原因

1、基于内存迭代处理，而MR是基于磁盘迭代处理

2、是基于线程

3、Spark有丰富的API算子

4、Spark中具有DAG有向无环图，在此过程中减少了shuffle以及落地磁盘的次数

5、Spark是粗粒度申请，在我们提交 spark application会将所有资源都申请完毕，如果申请不到资源就等待，申请到资源才执行application，因此在task执行使不需要去申请资源，task执行块，但最后一个task执行完后，task才会被释放（优点是块，缺点是资源不能充分利用）；
而Mapreduce是细粒度申请，提交application时，时task去申请资源，自己释放资源，task执行完毕之后，资源立即会被释放，task执行的慢，application执行的相对比较慢（优点是集群资源得到充分利用，缺点是application执行的相对比较慢。）

spark有几种部署方式（运行模式），请简要叙述

Spark有多种部署方式，主要包括以下几种：

Local模式（本地单机模式）：（本地调试）在这种模式下，Spark运行在一台机器上，通常用于开发和测试。此时，Spark不依赖于其他资源管理系统，可以在本地启动多个线程来执行任务。
Standalone模式（集群单机模式）：（性能比较高的场景，国外使用比较多）在这种模式下，Spark构建一个基于Master-Slave的资源调度集群。Master节点负责调度任务，Slave节点负责运行任务。整个集群可以独立部署，无需依赖其他资源管理系统。
YARN模式（集群分布式模式）：（国内大量使用）在这种模式下，Spark客户端直接连接YARN（Yet Another Resource Negotiator），实现与集群资源的交互。YARN是Hadoop的一个重要组件，负责集群资源的调度和管理。YARN模式有YARN-client和YARN-cluster两种模式，主要区别在于资源管理的方式。
Mesos模式（集群分布式模式）：在这种模式下，Spark客户端直接连接Mesos（一种分布式系统框架），实现与集群资源的交互。Mesos框架类似于YARN，也可以实现集群资源的调度和管理。
k8s模式：（在java领域多，大数据场景下问题非常多）：docker容器集群、运维

每种部署方式都有其特点和适用场景，根据实际需求和集群资源情况选择合适的部署方式，可以提高Spark应用程序的性能。

为什么用Yarn on Spark，而不是用standlone？

首先是，我们在实际数据开发中集群不止是由spark这样一个组件，而是由很多大数据相关的组件（Hadoop、Hue、Flink、Hbase等），我们standlone的资源调度系统是专门为我们spark去服务的。不适合使用在我们实际大数据开发中。
我们来对比 Spark 集群模式 Standalone 和 Spark on Yarn 在资源调度能力上的区别：Spark 的 Standalone 模式只支持 FIFO 调度器，单用户串行，默认所有节点的所有资源对应用都是可用的；而 Yarn 不止支持 FIFO 的资源调度，还提供了弹性和公平的资源分配方式。

Spark client 和Spark cluster的区别？

Spark应用执行流程（请简述Spark on Yarn的cluter模式执行流程）

![[1648111504430.png]]

1、在客户端提交application 给Resoure Manager，在RM 收到请求后会随机Node Manager的Container启动Application Master，并且启动 driver
2、AM向RM申请资源用于启动 Executor，RM 会返回可用的 NM列表
3、接收到后，会去链接这些NM，在Container中启动Executor，这个Executor 会反向注册给 Driver，Driver发送task到 Executor，监控task执行,Driver 回收结果

Spark的DAG图是什么?

DAG：就是有向无环图，其实就是RDD的执行流程
1、一个Spark应用里面可以有多个DAG，有几个DAG是取决于触发了多少次Action
2、一个DAG中会有不同的阶段也就是Stage，划分Stage的依据是宽依赖
3、一个Stage中有1个Taskset，一个分区对应一个Task

请描述交互流程中 on spark集群和on yarn集群有什么区别

缓存和检查点的区别

存储内容：
存储位置：
可靠性：

产生shuffle的算子

repartition、bykey、join

你对spark的优化有了解吗

广播变量
缓存

Spark core

RDD是什么

弹性分布式数据集：
弹性：数据可以存储在内存、磁盘
分布式：本质是一个分布式列表
数据集：不存储数据，存储计算逻辑

RDD 的五大特性是什么

1、RDD都是有一些列分区构成的
2、RDD算子作用在分区上
3、RDD之间存在血缘关系
4、分区器作用在k,v格式的RDD上
5、partiton提供最佳的计算位置

RDD中的数据在哪

RDD不存数据，存计算逻辑，RDD中的数据在数据源，RDD只是一个抽象的数据集，我们通过对RDD的操作就相当于对数据进行操作

如果对RDD进行cache操作后，数据在哪

数据在第一执行cache算子时会被加载到各个Executor进程内存中，第二次就直接从内存读取而不会去磁盘（很耗内存、以空间换时间）

job、stage、task之间的关联

job 遇到 action，逆运算，shuffle切stage，

算子

宽窄依赖关系

shuffle的理解

重分区

spark的数据倾斜问题

转换算子

对RDD的数据进行转换。
转换类算子，返回值一定是RDD，懒惰性

单Value

map()：通过对RDD的每个元素应用一个函数返回一个新的RDD，我们通常也会在其中写内置函数进行分类抽样。

"""
Return a new RDD by applying a function to each element of this RDD.  
"""
Examples  
--------  
>>> rdd = sc.parallelize(["b", "a", "c"])  
>>> sorted(rdd.map(lambda x: (x, 1)).collect())  
[('a', 1), ('b', 1), ('c', 1)]

mapPartitions()：通过对RDD每个分区中的元素使用一个函数，返回一个新的rdd

"""  
Return a new RDD by applying a function to each partition of this RDD.  
""" 
Examples  
--------  
>>> rdd = sc.parallelize([1, 2, 3, 4], 2)  
>>> def f(iterator): yield sum(iterator)  
>>> rdd.mapPartitions(f).collect()  
[3, 7]

mapPartitionsWithIndex():通过对分区使用一个函数，返回一个新的rdd，并追溯原来分区的索引

"""  
Return a new RDD by applying a function to each partition of this RDD,  
while tracking the index of the original partition.  
""" 
Examples  
--------  
>>> rdd = sc.parallelize([/, 2, 3, 4], 4)  
>>> def f(splitIndex, iterator): yield splitIndex  
>>> rdd.mapPartitionsWithIndex(f).sum()  
6

flatmap():与map一致，结果会扁平化处理

"""
Return a new RDD by first applying a function to all elements of this  
RDD, and then flattening the results.  
""" 
Examples  
--------  
>>> rdd = sc.parallelize([2, 3, 4])  
>>> sorted(rdd.flatMap(lambda x: range(1, x)).collect())  
[1, 1, 1, 2, 2, 3]  
>>> sorted(rdd.flatMap(lambda x: [(x, x), (x, x)]).collect())  
[(2, 2), (2, 2), (3, 3), (3, 3), (4, 4), (4, 4)]

filiter():通过对RDD应用一个函数，满足返回为True的元素，返回一个新的RDD

"""  
Return a new RDD containing only the elements that satisfy a predicate.  
"""  
Examples  
--------  
>>> rdd = sc.parallelize([1, 2, 3, 4, 5])  
>>> rdd.filter(lambda x: x % 2 == 0).collect()  
[2, 4]

重写分区
coalesce：返回一个被指定分区数的RDD

"""  
Return a new RDD that is reduced into `numPartitions` partitions.  
"""  
Examples  
--------  
>>> sc.parallelize([1, 2, 3, 4, 5], 3).glom().collect()  
[[1], [2, 3], [4, 5]]  
>>> sc.parallelize([1, 2, 3, 4, 5], 3).coalesce(1).glom().collect()  
[[1, 2, 3, 4, 5]]

repartition():实际上就是调用了coalesce函数，并默认值设定为True

Map和 mapPartition的区别

1）Map：通过对RDD的每个元素应用一个函数返回一个新的RDDRDD
2）mapPartiton：通过对RDD每个分区中的元素使用一个函数，返回一个新的RDD

Repartitions 和 Coalesce区别

首先他们都是更改 RDD 的 Partition 数量，Repartition本质其实是调用了Coalesce 方法：
Repartition：Repartition一定会发生 shuffle ，Coalesce 根据闯入的参数决定是否发生 shuffle。一般情况，我们进行 rdd 的 parititon 增大数量使用 repartition，反之则使用 colesce。

双Value

交并差、拉链

keyValue

partitionby

groupByKey
reduceByKey

reduceByKey:没有初始值，分区内和分区间逻辑相同
foldByKey
aggreeByKey
combineByKey
![[Pasted image 20231122143420.png]]

行动算子

reduce
first
take
foreach
foreachp

序列化

KRYO序列化

血缘

宽依赖：有shuffle（有聚合操作）
窄依赖：无shuffle

cache、checkpoint

相同点：都是做RDD持久化
比较：
1、cache：出发 action 之后，把数据写入内存或磁盘，不会斩断血缘关系（设置缓存级别为，Memory_only：内存不足，只会部分缓存或是没有缓存，缓存会丢失，memory_and_disk:内存不足，会使用磁盘）
2、

任务是怎么切分的

app：由sparkcontext
job：行动算子个数
stage：宽依赖个数（shuffle）+1
task：每个阶段最后一个算子对应的分区数

广播变量和累加器

Spark sql

1、rdd、df、ds三者之间的转换
2、元数据、执行引擎、语法
hive on sparkS
spark on hive

Structured Streaming

总体

描述一下RDD、DataFrame、DataSet的区别？

RDD的优点
RDD是spark最基本的数据结构，既有很高的灵活性和拓展性。由于他是不可变的，可以实现容错性。另外RDD可以在不同计算节点上并行处理，可以加速数据分析和处理
RDD的缺点
RDD没有内置的优化器，并且需要去编写大量代码，因此可能无法有效的处理大型数据集。

DataFrame的优点
DataFram提供了一种更方便查询结构化数据的方式。因为DataFram内部由优化器，查询的性能比RDD高。此外DataFrame还提供了很多的内置函数和操作，以便用户进行数据清理、处理和转换。
DataFrame的缺点
DataFrame的类型安全性不如DataSet高，因为它使用了动态类型，此外DataFrame只能单一的处理结构化数据，对于半结构化和非结构化数据无法处理

DataSet的优点
DataSet是Spark比较新的数据结构，他结合了RDD和DataFrame的优点，相比DataFrame他的安全性更高，可以避免在运行时储蓄爱你错误，与RDD相比，它可以使用内置的优化器，性能也更高
DataSet的缺点
DataSet是Spark比较新的数据结构，因此缺乏广泛的社区支持以及文档。学习曲线比较陡峭，需要更多的编程技能。