Spark面试题

Posted 2021-04-03 Java与大数据进阶

以下面试题主要 整理自尚硅谷相关文档

1. Spark的三种部署模式

1. Local模式：单机调试

local：只启动一个线程

local[k]：启动k个线程

local[*]：启动cpu数目的线程

2. 分布式

（1）standalone模式：

       在架构上和MapReduce1具有一致性，资源抽象为粗粒度的slot，slot决定task。

（2）Spark on yarn模式（☆）

       Spark客户端直接连接Yarn，不需要额外构建Spark集群。有yarn-client和yarn-cluster两种模式，主要区别在于：Driver程序的运行节点。

yarn-client：Driver程序运行在客户端，适用于交互、调试，希望立即看到app的输出

yarn-cluster：Driver程序运行在由RM（ResourceManager）启动的AP（APPMaster）适用于生产环境。

（3）Spark On Mesos模式。

       Mesos也是统一资源管理与调度系统。支持两个模式，即粗粒度模式和细粒度模式，粗粒度节省资源调度时间，细粒度节省资源。

2. RDD的理解（☆）

RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是Spark中最基本的数据（计算）抽象。代码中是一个抽象类，它代表一个不可变、可分区（如kafka,hbase）、里面的元素可并行计算的集合。特点：分区，只读，依赖，缓存，CheckPoint。

依赖分为宽依赖和窄依赖，宽依赖是一父RDD对应多个子RDD，窄依赖是一父RDD对应至多一个子RDD。宽依赖用来划分stage。

 

3. Spark作业调度流程（☆）

参考：《Spark大数据处理技术》4.4

1. 调度阶段的拆分：当一个RDD 操作触发计算，向DAGScheduler 提交作业时，DAGScheduler 需要从RDD 依赖链末端的RDD 触发，遍历整个RDD 依赖链，划分调度阶段，并决定各个调度阶段之间的依赖关系。调度阶段的划分是以ShuffleDependency 为依据的。

2. 调度阶段的提交：在划分调度阶段的步骤中会得到一个或多个有依赖关系的调度阶段，其中直接触发作业的RDD 关联的调度阶段称为FinalStage ，DAGScheduler 进一步从这个FinalStage 生成一个作业实例，这两者的关系进一步存储在映射表中，用于在该调度阶段全部完成时做一些后续处理。

具体提交一个调度阶段时，首先判断该调度阶段所依赖的父调度阶段的结果是否可用，如果所有父调度阶段的结果都可用，则提交该调度阶段。如果有任何一个父调度阶段的结果不可用，则尝试迭代提交当前不可用的父调度阶段。所有在迭代过程中由于所依赖调度阶段的结果不可用而没有提交成功的调度阶段，都被放到等待队列中，等待将来被提交。

3. 任务集的提交：调度阶段的提交，最终会被转换成一个任务集的提交，如程序4-7 所示。DAGScheduler 通过TaskScheduler 接口提交任务集，这个任务集最终会触发TaskScheduler 构建一个TaskSetManager 的实例来管理这个任务集的生命周期，对于DAGScheduler 来说，提交调度阶段的工作到此就完成了。而TaskScheduler 的具体实现则会在得到计算资源的时候，进一步通过TaskSetManager 调度具体的任务到对应的Executor 节点上进行运算。

4. 完成状态的监控：要保证相互依赖的作业调度阶段能够得到顺利的调度执行，DAGScheduler 必然需要监控当前作业调度阶段乃至任务的完成情况。这是通过对外（主要是对TaskScheduler ）暴露一系列的回调函数来实现的，对于TaskScheduler 来说，这些回调函数最主要包括任务的开始结束失败、任务集的失败，DAGScheduler 根据这些任务的生命周期信息进一步维护作业和调度阶段的状态信息。

5. 任务结果的获取：一个具体的任务在Executor 中执行完毕后，以某种形式返回给DAGScheduler 。根据任务类型的不同，返回方式也不同。

对于FinalStage 对应的任务（对应的类为ResultTASK ），返回运算结果本身。对于中间调度阶段对应的任务ShuffleMapTask ，返回的是一个MapStatus 对象，MapStatus 管理了ShuffleMapTask 的运算输出结果在BlockManager 里的相关存储信息，而非结果本身，这些存储位置信息将作为下一个调度阶段的任务获取输入数据的依据。

 

作业调度流程

作业调度逻辑交互关系

 

4. RDD的容错机制（☆）

（1）Lineage机制

依赖关系的特性

第一，窄依赖可以在某个计算节点上直接通过计算父RDD的某块数据计算得到子RDD对应的某块数据；宽依赖则要等到父RDD所有数据都计算完成之后，并且父RDD的计算结果进行hash并传到对应节点上之后才能计算子RDD。

第二，数据丢失时，对于窄依赖只需要重新计算丢失的那一块数据来恢复；对于宽依赖则要将祖先RDD中的所有数据块全部重新计算来恢复。所以在长“血统”链特别是有宽依赖的时候，需要在适当的时机设置数据检查点。也是这两个特性要求对于不同依赖关系要采取不同的任务调度机制和容错恢复机制。

容错原理

在容错机制中，如果一个节点死机了，而且运算窄依赖，则只要把丢失的父RDD分区重算即可，不依赖于其他节点。而宽依赖需要父RDD的所有分区都存在，重算就很昂贵了。可以这样理解开销的经济与否：在窄依赖中，在子RDD的分区丢失、重算父RDD分区时，父RDD相应分区的所有数据都是子RDD分区的数据，并不存在冗余计算。在宽依赖情况下，丢失一个子RDD分区重算的每个父RDD的每个分区的所有数据并不是都给丢失的子RDD分区用的，会有一部分数据相当于对应的是未丢失的子RDD分区中需要的数据，这样就会产生冗余计算开销，这也是宽依赖开销更大的原因。因此如果使用Checkpoint算子来做检查点，不仅要考虑Lineage是否足够长，也要考虑是否有宽依赖，对宽依赖加Checkpoint是最物有所值的。

（2）Checkpoint机制

检查点（本质是通过将RDD写入Disk做检查点）是为了通过lineage做容错的辅助，lineage过长会造成容错成本过高，这样就不如在中间阶段做检查点容错，如果之后有节点出现问题而丢失分区，从做检查点的RDD开始重做Lineage，就会减少开销。

 

5. Spark的三种算子

1. Transformation（转换）

Transformation属于延迟计算，当一个RDD转换成另一个RDD时并没有立即进行转换，仅仅是记住了数据集的逻辑操作。当有Action算子出现时，他才会真正的执行

2. Action（执行）

触发Spark作业的运行，真正触发转换算子的计算。

3. 控制

Spark中控制算子也是懒执行的，需要Action算子触发才能执行，主要是为了对数据进行缓存。当有Action算子出现时，他才会真正的执行。

 

6. Spark shuffle（☆）

这个问题网上讲的比较混乱，这里整理其中一种说法。

在划分stage时，最后一个stage称为finalStage，它本质上是一个ResultStage对象，前面的所有stage被称为ShuffleMapStage。

ShuffleMapStage的结束伴随着shuffle文件的写磁盘。ResultStage基本上对应代码中的action算子，即将一个函数应用在RDD的各个partition的数据集上，意味着一个job的运行结束。

Spark 2.0去掉了Hash Shuffle。目前Spark 2.1，分为BypassMergeSortShuffleWriter，SortShuffleWriter和UnsafeShuffleWriter。

（1）HashShuffle

原始的 HashShuffle 机制

基于 Mapper 和 Reducer 理解的基础上，当 Reducer 去抓取数据时，它的 Key 到底是怎么分配的，核心思考点是：作为上游数据是怎么去分配给下游数据的。在这张图中你可以看到有4个 Task 在2个 Executors 上面，它们是并行运行的，Hash 本身有一套 Hash算法，可以把数据的 Key 进行重新分类，每个 Task 对数据进行分类然后把它们不同类别的数据先写到本地磁盘，然后再经过网络传输 Shuffle，把数据传到下一个 Stage 进行汇聚。

下图有3个 Reducer，从 Task 开始那边各自把自己进行 Hash 计算，分类出3个不同的类别，每个 Task 都分成3种类别的数据，刚刚提过因为分布式的关系，我们想把不同的数据汇聚然后计算出最终的结果，所以下游的 Reducer 会在每个 Task 中把属于自己类别的数据收集过来，汇聚成一个同类别的大集合，抓过来的时候会首先放在内存中，但内存可能放不下，也有可能放在本地 (这也是一个调优点。可以参考上一章讲过的一些调优参数)，每1个 Task 输出3份本地文件，这里有4个 Mapper Tasks，所以总共输出了4个 Tasks x 3个分类文件 = 12个本地小文件。

[下图是 Spark 最原始的 Hash-Based Shuffle 概念图]

 

HashShuffle 也有它的弱点：

Shuffle前在磁盘上会产生海量的小文件，此时会产生大量耗时低效的 IO 操作 (因為产生过多的小文件）

内存不够用，由于内存中需要保存海量文件操作句柄和临时信息，如果数据处理的规模比较庞大的话，内存不可承受，会出现 OOM 等问题。

优化后的 HashShuffle 机制

在刚才 HashShuffle 的基础上思考该如何进行优化，这是优化后的实现：

[下图是 Spark Consolidated Hash-Based Shuffle 概念图]

这里还是有4个Tasks，数据类别还是分成3种类型，因为Hash算法会根据你的 Key 进行分类，在同一个进程中，无论是有多少过Task，都会把同样的Key放在同一个Buffer里，然后把Buffer中的数据写入以Core数量为单位的本地文件中，(一个Core只有一种类型的Key的数据)，每1个Task所在的进程中，分别写入共同进程中的3份本地文件，这里有4个Mapper Tasks，所以总共输出是 2个Cores x 3个分类文件 = 6个本地小文件。Consoldiated Hash-Shuffle的优化有一个很大的好处就是假设现在有200个Mapper Tasks在同一个进程中，也只会产生3个本地小文件；如果用原始的 Hash-Based Shuffle 的话，200个Mapper Tasks 会各自产生3个本地小文件，在一个进程已经产生了600个本地小文件。3个对比600已经是一个很大的差异了。

Consolidated HashShuffle 也有它的弱点：如果 Reducer 端的并行任务或者是数据分片过多的话则Core * Reducer Task 依旧过大，也会产生很多小文件。

（2）SortShuffle

SortShuffleManager的运行机制主要分成两种，一种是普通运行机制，另一种是bypass运行机制。当shuffle read task的数量小于等于spark.shuffle.sort.bypassMergeThreshold参数的值时（默认为200），就会启用bypass机制。

在该模式下，数据会先写入一个内存数据结构中，此时根据不同的shuffle算子，可能选用不同的数据结构。如果是reduceByKey这种聚合类的shuffle算子，那么会选用Map数据结构，一边通过Map进行聚合，一边写入内存；如果是join这种普通的shuffle算子，那么会选用Array数据结构，直接写入内存。接着，每写一条数据进入内存数据结构之后，就会判断一下，是否达到了某个临界阈值。如果达到临界阈值的话，那么就会尝试将内存数据结构中的数据溢写到磁盘，然后清空内存数据结构。

在溢写到磁盘文件之前，会先根据key对内存数据结构中已有的数据进行排序。排序过后，会分批将数据写入磁盘文件。默认的batch数量是10000条，也就是说，排序好的数据，会以每批1万条数据的形式分批写入磁盘文件。写入磁盘文件是通过Java的BufferedOutputStream实现的。BufferedOutputStream是Java的缓冲输出流，首先会将数据缓冲在内存中，当内存缓冲满溢之后再一次写入磁盘文件中，这样可以减少磁盘IO次数，提升性能。

一个task将所有数据写入内存数据结构的过程中，会发生多次磁盘溢写操作，也就会产生多个临时文件。最后会将之前所有的临时磁盘文件都进行合并，这就是merge过程，此时会将之前所有临时磁盘文件中的数据读取出来，然后依次写入最终的磁盘文件之中。此外，由于一个task就只对应一个磁盘文件，也就意味着该task为下游stage的task准备的数据都在这一个文件中，因此还会单独写一份索引文件，其中标识了下游各个task的数据在文件中的start offset与end offset。

SortShuffleManager由于有一个磁盘文件merge的过程，因此大大减少了文件数量。比如第一个stage有50个task，总共有10个Executor，每个Executor执行5个task，而第二个stage有100个task。由于每个task最终只有一个磁盘文件，因此此时每个Executor上只有5个磁盘文件，所有Executor只有50个磁盘文件。

普通运行机制的SortShuffleManager工作原理如图1-9所示：

图1-9 普通运行机制的SortShuffleManager工作原理

（3）bypass shuffle

bypass运行机制的触发条件如下：

• shuffle map task数量小于spark.shuffle.sort.bypassMergeThreshold参数的值。

• 不是聚合类的shuffle算子。

此时，每个task会为每个下游task都创建一个临时磁盘文件，并将数据按key进行hash然后根据key的hash值，将key写入对应的磁盘文件之中。当然，写入磁盘文件时也是先写入内存缓冲，缓冲写满之后再溢写到磁盘文件的。最后，同样会将所有临时磁盘文件都合并成一个磁盘文件，并创建一个单独的索引文件。

该过程的磁盘写机制其实跟未经优化的HashShuffleManager是一模一样的，因为都要创建数量惊人的磁盘文件，只是在最后会做一个磁盘文件的合并而已。因此少量的最终磁盘文件，也让该机制相对未经优化的HashShuffleManager来说，shuffle read的性能会更好。

而该机制与普通SortShuffleManager运行机制的不同在于：第一，磁盘写机制不同；第二，不会进行排序。也就是说，启用该机制的最大好处在于，shuffle write过程中，不需要进行数据的排序操作，也就节省掉了这部分的性能开销。

bypass运行机制的SortShuffleManager工作原理如图1-10所示：

图1-10 bypass运行机制的SortShuffleManager工作原理

而该机制与普通SortShuffleManager运行机制的不同在于：第一，磁盘写机制不同；第二，不会进行排序。也就是说，启用该机制的最大好处在于，shuffle write过程中，不需要进行数据的排序操作，也就节省掉了这部分的性能开销。

（4）UnsafeShuffle

优化部分是在shuffle write进行序列化写入过程中，直接对二进制进行排序，减少内存消耗，最终只是partition级别的排序。但是使用Unsafe Shuffle有几个限制，shuffle阶段不能有aggregate操作，分区数不能超过一定大小(2²⁴−1，这是可编码的最大parition id)，所以像reduceByKey这类有aggregate操作的算子是不能使用Unsafe Shuffle，它会退化采用Sort Shuffle。

 

7. Spark数据倾斜（☆）

https://blog.csdn.net/meihao5/article/details/81084876

Spark中的数据倾斜问题主要指shuffle过程中出现的数据倾斜问题，是由于不同的key对应的数据量不同导致的不同task所处理的数据量不同的问题。

例如，reduce点一共要处理100万条数据，第一个和第二个task分别被分配到了1万条数据，计算5分钟内完成，第三个task分配到了98万数据，此时第三个task可能需要10个小时完成，这使得整个Spark作业需要10个小时才能运行完成，这就是数据倾斜所带来的后果。

1. 解决方案一：使用Hive ETL预处理数据

方案适用场景：导致数据倾斜的是Hive 表。如果该Hive 表中的数据本身很不均匀（比如某个key 对应了100 万数据，其他key 才对应了10 条数据），而且业务场景需要频繁使用Spark 对Hive 表执行某个分析操作，那么比较适合使用这种技术方案。

 

方案实现思路：此时可以评估一下，是否可以通过Hive 来进行数据预处理（即通过Hive ETL 预先对数据按照key 进行聚合，或者是预先和其他表进行join ），然后在Spark 作业中针对的数据源就不是原来的Hive 表了，而是预处理后的Hive 表。此时由于数据已经预先进行过聚合或join 操作了，那么在Spark 作业中也就不需要使用原先的shuffle 类算子执行这类操作了。

 

方案实现原理：这种方案从根源上解决了数据倾斜，因为彻底避免了在Spark 中执行shuffle 类算子，那么肯定就不会有数据倾斜的问题了。但是这里也要提醒一下大家，这种方式属于治标不治本。因为毕竟数据本身就存在分布不均匀的问题，所以Hive ETL 中进行group by 或者join 等shuffle 操作时，还是会出现数据倾斜，导致Hive ETL 的速度很慢。我们只是把数据倾斜的发生提前到了Hive ETL 中，避免Spark 程序发生数据倾斜而已。

 

方案优点：实现起来简单便捷，效果还非常好，完全规避掉了数据倾斜，Spark 作业的性能会大幅度提升。

 

方案缺点：治标不治本，Hive ETL 中还是会发生数据倾斜。

 

方案实践经验：在一些Java 系统与Spark 结合使用的项目中，会出现Java 代码频繁调用Spark 作业的场景，而且对Spark 作业的执行性能要求很高，就比较适合使用这种方案。将数据倾斜提前到上游的Hive ETL ，每天仅执行一次，只有那一次是比较慢的，而之后每次Java 调用Spark 作业时，执行速度都会很快，能够提供更好的用户体验。

 

项目实践经验：在美团·点评的交互式用户行为分析系统中使用了这种方案，该系统主要是允许用户通过Java Web 系统提交数据分析统计任务，后端通过Java 提交Spark 作业进行数据分析统计。要求Spark 作业速度必须要快，尽量在10 分钟以内，否则速度太慢，用户体验会很差。所以我们将有些Spark 作业的shuffle 操作提前到了Hive ETL 中，从而让Spark 直接使用预处理的Hive 中间表，尽可能地减少Spark 的shuffle 操作，大幅度提升了性能，将部分作业的性能提升了6 倍以上。

 

2. 解决方案二：过滤少数导致倾斜的key

方案适用场景：如果发现导致倾斜的key 就少数几个，而且对计算本身的影响并不大的话，那么很适合使用这种方案。比如99% 的key 就对应10 条数据，但是只有一个key 对应了100 万数据，从而导致了数据倾斜。

 

方案实现思路：如果我们判断那少数几个数据量特别多的key ，对作业的执行和计算结果不是特别重要的话，那么干脆就直接过滤掉那少数几个key 。比如，在Spark SQL 中可以使用where 子句过滤掉这些key 或者在Spark Core 中对RDD 执行filter 算子过滤掉这些key 。如果需要每次作业执行时，动态判定哪些key 的数据量最多然后再进行过滤，那么可以使用sample 算子对RDD 进行采样，然后计算出每个key 的数量，取数据量最多的key 过滤掉即可。

 

方案实现原理：将导致数据倾斜的key 给过滤掉之后，这些key 就不会参与计算了，自然不可能产生数据倾斜。

 

方案优点：实现简单，而且效果也很好，可以完全规避掉数据倾斜。

 

方案缺点：适用场景不多，大多数情况下，导致倾斜的key 还是很多的，并不是只有少数几个。

 

方案实践经验：在项目中我们也采用过这种方案解决数据倾斜。有一次发现某一天Spark 作业在运行的时候突然OOM 了，追查之后发现，是Hive 表中的某一个key 在那天数据异常，导致数据量暴增。因此就采取每次执行前先进行采样，计算出样本中数据量最大的几个key 之后，直接在程序中将那些key 给过滤掉。

 

3. 解决方案三：提高shuffle操作的并行度

方案适用场景：如果我们必须要对数据倾斜迎难而上，那么建议优先使用这种方案，因为这是处理数据倾斜最简单的一种方案。

 

方案实现思路：在对RDD 执行shuffle 算子时，给shuffle 算子传入一个参数，比如reduceByKey(1000) ，该参数就设置了这个shuffle 算子执行时shuffle read task 的数量。对于Spark SQL 中的shuffle 类语句，比如group by 、join 等，需要设置一个参数，即spark.sql.shuffle.partitions ，该参数代表了shuffle read task 的并行度，该值默认是200 ，对于很多场景来说都有点过小。

 

方案实现原理：增加shuffle read task 的数量，可以让原本分配给一个task 的多个key 分配给多个task ，从而让每个task 处理比原来更少的数据。举例来说，如果原本有5 个key ，每个key 对应10 条数据，这5 个key 都是分配给一个task 的，那么这个task 就要处理50 条数据。而增加了shuffle read task 以后，每个task 就分配到一个key ，即每个task 就处理10 条数据，那么自然每个task 的执行时间都会变短了。具体原理如下图所示。

 

方案优点：实现起来比较简单，可以有效缓解和减轻数据倾斜的影响。

 

方案缺点：只是缓解了数据倾斜而已，没有彻底根除问题，根据实践经验来看，其效果有限。

 

方案实践经验：该方案通常无法彻底解决数据倾斜，因为如果出现一些极端情况，比如某个key 对应的数据量有100 万，那么无论你的task 数量增加到多少，这个对应着100 万数据的key 肯定还是会分配到一个task 中去处理，因此注定还是会发生数据倾斜的。所以这种方案只能说是在发现数据倾斜时尝试使用的第一种手段，尝试去用嘴简单的方法缓解数据倾斜而已，或者是和其他方案结合起来使用。

 

4. 解决方案四：两阶段聚合（局部聚合+全局聚合）

方案适用场景：对RDD 执行reduceByKey 等聚合类shuffle 算子或者在Spark SQL 中使用group by 语句进行分组聚合时，比较适用这种方案。

 

方案实现思路：这个方案的核心实现思路就是进行两阶段聚合。第一次是局部聚合，先给每个key 都打上一个随机数，比如10 以内的随机数，此时原先一样的key 就变成不一样的了，比如(hello, 1) (hello, 1) (hello, 1) (hello, 1) ，就会变成(1_hello, 1)(1_hello, 1) (2_hello, 1) (2_hello, 1) 。接着对打上随机数后的数据，执行reduceByKey 等聚合操作，进行局部聚合，那么局部聚合结果，就会变成了(1_hello, 2) (2_hello, 2) 。然后将各个key 的前缀给去掉，就会变成(hello,2)(hello,2) ，再次进行全局聚合操作，就可以得到最终结果了，比如(hello, 4) 。

 

方案实现原理：将原本相同的key 通过附加随机前缀的方式，变成多个不同的key ，就可以让原本被一个task 处理的数据分散到多个task 上去做局部聚合，进而解决单个task 处理数据量过多的问题。接着去除掉随机前缀，再次进行全局聚合，就可以得到最终的结果。具体原理见下图。

 

方案优点：对于聚合类的shuffle 操作导致的数据倾斜，效果是非常不错的。通常都可以解决掉数据倾斜，或者至少是大幅度缓解数据倾斜，将Spark 作业的性能提升数倍以上。

 

方案缺点：仅仅适用于聚合类的shuffle 操作，适用范围相对较窄。如果是join 类的shuffle 操作，还得用其他的解决方案。

 

5. 解决方案五：将reduce join转为map join

方案适用场景：在对RDD 使用join 类操作，或者是在Spark SQL 中使用join 语句时，而且join 操作中的一个RDD 或表的数据量比较小（比如几百M 或者一两G ），比较适用此方案。

 

方案实现思路：不使用join 算子进行连接操作，而使用Broadcast 变量与map 类算子实现join 操作，进而完全规避掉shuffle 类的操作，彻底避免数据倾斜的发生和出现。将较小RDD 中的数据直接通过collect 算子拉取到Driver 端的内存中来，然后对其创建一个Broadcast 变量；接着对另外一个RDD 执行map 类算子，在算子函数内，从Broadcast 变量中获取较小RDD 的全量数据，与当前RDD 的每一条数据按照连接key 进行比对，如果连接key 相同的话，那么就将两个RDD 的数据用你需要的方式连接起来。

 

方案实现原理：普通的join 是会走shuffle 过程的，而一旦shuffle ，就相当于会将相同key 的数据拉取到一个shuffle read task 中再进行join ，此时就是reduce join 。但是如果一个RDD 是比较小的，则可以采用广播小RDD 全量数据+map 算子来实现与join 同样的效果，也就是map join ，此时就不会发生shuffle 操作，也就不会发生数据倾斜。具体原理如下图所示。

 

方案优点：对join 操作导致的数据倾斜，效果非常好，因为根本就不会发生shuffle ，也就根本不会发生数据倾斜。

 

方案缺点：适用场景较少，因为这个方案只适用于一个大表和一个小表的情况。毕竟我们需要将小表进行广播，此时会比较消耗内存资源，driver 和每个Executor 内存中都会驻留一份小RDD 的全量数据。如果我们广播出去的RDD 数据比较大，比如10G 以上，那么就可能发生内存溢出了。因此并不适合两个都是大表的情况。

 

6. 解决方案六：采样倾斜key并分拆join操作

方案适用场景：两个RDD/Hive 表进行join 的时候，如果数据量都比较大，无法采用“ 解决方案五” ，那么此时可以看一下两个RDD/Hive 表中的key 分布情况。如果出现数据倾斜，是因为其中某一个RDD/Hive 表中的少数几个key 的数据量过大，而另一个RDD/Hive 表中的所有key 都分布比较均匀，那么采用这个解决方案是比较合适的。

 

方案实现思路：

 

对包含少数几个数据量过大的key 的那个RDD ，通过sample 算子采样出一份样本来，然后统计一下每个key 的数量，计算出来数据量最大的是哪几个key 。

然后将这几个key 对应的数据从原来的RDD 中拆分出来，形成一个单独的RDD ，并给每个key 都打上n 以内的随机数作为前缀，而不会导致倾斜的大部分key 形成另外一个RDD 。

接着将需要join 的另一个RDD ，也过滤出来那几个倾斜key 对应的数据并形成一个单独的RDD ，将每条数据膨胀成n 条数据，这n 条数据都按顺序附加一个0~n 的前缀，不会导致倾斜的大部分key 也形成另外一个RDD 。

再将附加了随机前缀的独立RDD 与另一个膨胀n 倍的独立RDD 进行join ，此时就可以将原先相同的key 打散成n 份，分散到多个task 中去进行join 了。

而另外两个普通的RDD 就照常join 即可。

最后将两次join 的结果使用union 算子合并起来即可，就是最终的join 结果。

方案实现原理：对于join 导致的数据倾斜，如果只是某几个key 导致了倾斜，可以将少数几个key 分拆成独立RDD ，并附加随机前缀打散成n 份去进行join ，此时这几个key 对应的数据就不会集中在少数几个task 上，而是分散到多个task 进行join 了。具体原理见下图。

 

方案优点：对于join 导致的数据倾斜，如果只是某几个key 导致了倾斜，采用该方式可以用最有效的方式打散key 进行join 。而且只需要针对少数倾斜key 对应的数据进行扩容n 倍，不需要对全量数据进行扩容。避免了占用过多内存。

 

方案缺点：如果导致倾斜的key 特别多的话，比如成千上万个key 都导致数据倾斜，那么这种方式也不适合。

 

7. 解决方案七：使用随机前缀和扩容RDD进行join

方案适用场景：如果在进行join 操作时，RDD 中有大量的key 导致数据倾斜，那么进行分拆key 也没什么意义，此时就只能使用最后一种方案来解决问题了。

 

方案实现思路：

该方案的实现思路基本和“解决方案六”类似，首先查看RDD/Hive 表中的数据分布情况，找到那个造成数据倾斜的RDD/Hive 表，比如有多个key 都对应了超过1 万条数据。

然后将该RDD 的每条数据都打上一个n 以内的随机前缀。

同时对另外一个正常的RDD 进行扩容，将每条数据都扩容成n 条数据，扩容出来的每条数据都依次打上一个0~n 的前缀。

最后将两个处理后的RDD 进行join 即可。

方案实现原理：将原先一样的key 通过附加随机前缀变成不一样的key ，然后就可以将这些处理后的“ 不同key” 分散到多个task 中去处理，而不是让一个task 处理大量的相同key 。该方案与“ 解决方案六” 的不同之处就在于，上一种方案是尽量只对少数倾斜key 对应的数据进行特殊处理，由于处理过程需要扩容RDD ，因此上一种方案扩容RDD 后对内存的占用并不大；而这一种方案是针对有大量倾斜key 的情况，没法将部分key 拆分出来进行单独处理，因此只能对整个RDD 进行数据扩容，对内存资源要求很高。

 

方案优点：对join 类型的数据倾斜基本都可以处理，而且效果也相对比较显著，性能提升效果非常不错。

 

方案缺点：该方案更多的是缓解数据倾斜，而不是彻底避免数据倾斜。而且需要对整个RDD 进行扩容，对内存资源要求很高。

 

方案实践经验：曾经开发一个数据需求的时候，发现一个join 导致了数据倾斜。优化之前，作业的执行时间大约是60 分钟左右；使用该方案优化之后，执行时间缩短到10 分钟左右，性能提升了6 倍。

 

解决方案八：多种方案组合使用

在实践中发现，很多情况下，如果只是处理较为简单的数据倾斜场景，那么使用上述方案中的某一种基本就可以解决。但是如果要处理一个较为复杂的数据倾斜场景，那么可能需要将多种方案组合起来使用。比如说，我们针对出现了多个数据倾斜环节的Spark 作业，可以先运用解决方案一和二，预处理一部分数据，并过滤一部分数据来缓解；其次可以对某些shuffle 操作提升并行度，优化其性能；最后还可以针对不同的聚合或join 操作，选择一种方案来优化其性能。大家需要对这些方案的思路和原理都透彻理解之后，在实践中根据各种不同的情况，灵活运用多种方案，来解决自己的数据倾斜问题。

 

8. spark streaming从kafka中获取数据（☆）

https://www.cnblogs.com/frankdeng/p/9308585.html

1. Receiver方式

    Receiver是使用Kafka高级Consumer API实现的。与所有接收器一样，从Kafka通过Receiver接收的数据存储在Spark Executor的内存中，然后由Spark Streaming启动的job来处理数据。然而默认配置下，这种方式可能会因为底层的失败而丢失数据（请参阅接收器可靠性）。如果要启用高可靠机制，确保零数据丢失，要启用Spark Streaming的预写日志机制（Write Ahead Log，（已引入）在Spark 1.2）。该机制会同步地将接收到的Kafka数据保存到分布式文件系统（比如HDFS）上的预写日志中，以便底层节点在发生故障时也可以使用预写日志中的数据进行恢复。

如下图：

2. Direct方式

在spark1.3之后，引入了Direct方式。不同于Receiver的方式，Direct方式没有receiver这一层，其会周期性的获取Kafka中每个topic的每个partition中的最新offsets，之后根据设定的maxRatePerPartition来处理每个batch。其形式如下图：

 

3. 这种方法相较于Receiver 方式的优势在于：

（1 ）简化的并行：在Receiver 的方式中我们提到创建多个Receiver 之后利用union 来合并成一个Dstream 的方式提高数据传输并行度。而在Direct 方式中，Kafka 中的partition 与RDD 中的partition 是一一对应的并行读取Kafka 数据，这种映射关系也更利于理解和优化。

（2 ）高效：在Receiver 的方式中，为了达到0 数据丢失需要将数据存入Write Ahead Log 中，这样在Kafka 和日志中就保存了两份数据，浪费！而第二种方式不存在这个问题，只要我们Kafka 的数据保留时间足够长，我们都能够从Kafka 进行数据恢复。

（3 ）精确一次：在Receiver 的方式中，使用的是Kafka 的高阶API 接口从Zookeeper 中获取offset 值，这也是传统的从Kafka 中读取数据的方式，但由于Spark Streaming 消费的数据和Zookeeper 中记录的offset 不同步，这种方式偶尔会造成数据重复消费。而第二种方式，直接使用了简单的低阶Kafka API ，Offsets 则利用Spark Streaming 的checkpoints 进行记录，消除了这种不一致性。

4. 调优问题：合理的批处理时间（batchDuration ），合理的Kafka 拉取量（maxRatePerPartition 重要），缓存反复使用的Dstream （RDD ），设置合理的GC ，设置合理的CPU 资源数，设置合理的parallelism ，使用高性能的算子，使用Kryo 优化序列化性能。

 

9. Spark共享变量（☆）

广播变量

广播变量允许编程者在每个Executor上保留外部数据的只读变量，而不是给每个任务发送一个副本。

每个task都会保存一份它所使用的外部变量的副本，当一个Executor上的多个task都使用一个大型外部变量时，对于Executor内存的消耗是非常大的，因此，我们可以将大型外部变量封装为广播变量，此时一个Executor保存一个变量副本，此Executor上的所有task共用此变量，不再是一个task单独保存一个副本，这在一定程度上降低了Spark任务的内存占用。

累加器

Accumulator是仅仅被相关操作累加的变量，因此可以在并行中被有效地支持。它们可用于实现计数器（如MapReduce）或总和计数。

Accumulator是存在于Driver端的，集群上运行的task进行Accumulator的累加，随后把值发到Driver端，在Driver端汇总（Spark UI在SparkContext创建时被创建，即在Driver端被创建，因此它可以读取Accumulator的数值），由于Accumulator存在于Driver端，从节点读取不到Accumulator的数值。

Spark提供的Accumulator主要用于多个节点对一个变量进行共享性的操作。Accumulator只提供了累加的功能，但是却给我们提供了多个task对于同一个变量并行操作的功能，但是task只能对Accumulator进行累加操作，不能读取它的值，只有Driver程序可以读取Accumulator的值。

Accumulator的底层原理如下图所示：

 

10. 数据本地性是在哪个环节确定的？（☆）

具体的task运行在其它机器上，dag划分stage的时候确定的。

 

11. Spark和MapReduce的区别

1. Spark 基于可以基于内存处理数据,Job 中间输出结果可以保存在内存中，从而不再需要读写HDFS 。

2. Spark 中有DAG 有向无环图。

3. Spark 存储数据可以指定副本个数，MR 默认3 个。

4. Spark 中提供了各种场景的算子，MR 中只有map,reduce 相当于Spark 中的map 和reduceByKey 两个算子。

5. Spark 是粗粒度资源申请，Application 执行快。

6. Spark 中shuffle map 端自动聚合功能，MR 手动设置。

7. Spark 中shuffle ByPass 机制有自己灵活的实现。

 

12. Spark堆内外内存及内存空间分配（☆）

在执行Spark 的应用程序时，Spark 集群会启动 Driver 和 Executor 两种 JVM 进程，前者为主控进程，负责创建 Spark 上下文，提交 Spark 作业（Job），并将作业转化为计算任务（Task），在各个 Executor 进程间协调任务的调度，后者负责在工作节点上执行具体的计算任务，并将结果返回给 Driver，同时为需要持久化的 RDD 提供存储功能。由于 Driver 的内存管理相对来说较为简单，本节主要对 Executor 的内存管理进行分析，下文中的 Spark 内存均特指 Executor 的内存。

1. 堆内和堆外内存规划

作为一个 JVM 进程，Executor 的内存管理建立在 JVM 的内存管理之上，Spark 对 JVM 的堆内（On-heap）空间进行了更为详细的分配，以充分利用内存。同时，Spark 引入了堆外（Off-heap）内存，使之可以直接在工作节点的系统内存中开辟空间，进一步优化了内存的使用。

堆内内存受到JVM统一管理，堆外内存是直接向操作系统进行内存的申请和释放。

图1-1 Executor堆内与堆外内存

（1）堆内内存

堆内内存的大小，由 Spark 应用程序启动时的–executor-memory 或spark.executor.memory 参数配置。Executor 内运行的并发任务共享 JVM 堆内内存，这些任务在缓存 RDD 数据和广播（Broadcast）数据时占用的内存被规划为存储（Storage）内存，而这些任务在执行 Shuffle 时占用的内存被规划为执行（Execution）内存，剩余的部分不做特殊规划，那些 Spark 内部的对象实例，或者用户定义的 Spark 应用程序中的对象实例，均占用剩余的空间。不同的管理模式下，这三部分占用的空间大小各不相同。

Spark 对堆内内存的管理是一种逻辑上的”规划式”的管理，因为对象实例占用内存的申请和释放都由 JVM 完成，Spark 只能在申请后和释放前记录这些内存，我们来看其具体流程：

申请内存流程如下：

1.   Spark 在代码中 new 一个对象实例；

2.   JVM 从堆内内存分配空间，创建对象并返回对象引用；

3.   Spark 保存该对象的引用，记录该对象占用的内存。

释放内存流程如下：

1.   Spark记录该对象释放的内存，删除该对象的引用；

2.   等待JVM的垃圾回收机制释放该对象占用的堆内内存。

我们知道，JVM 的对象可以以序列化的方式存储，序列化的过程是将对象转换为二进制字节流，本质上可以理解为将非连续空间的链式存储转化为连续空间或块存储，在访问时则需要进行序列化的逆过程——反序列化，将字节流转化为对象，序列化的方式可以节省存储空间，但增加了存储和读取时候的计算开销。

对于 Spark 中序列化的对象，由于是字节流的形式，其占用的内存大小可直接计算，而对于非序列化的对象，其占用的内存是通过周期性地采样近似估算而得，即并不是每次新增的数据项都会计算一次占用的内存大小，这种方法降低了时间开销但是有可能误差较大，导致某一时刻的实际内存有可能远远超出预期。此外，在被 Spark 标记为释放的对象实例，很有可能在实际上并没有被 JVM 回收，导致实际可用的内存小于 Spark 记录的可用内存。所以 Spark 并不能准确记录实际可用的堆内内存，从而也就无法完全避免内存溢出（OOM, Out of Memory）的异常。

虽然不能精准控制堆内内存的申请和释放，但 Spark 通过对存储内存和执行内存各自独立的规划管理，可以决定是否要在存储内存里缓存新的 RDD，以及是否为新的任务分配执行内存，在一定程度上可以提升内存的利用率，减少异常的出现。

（2）堆外内存

为了进一步优化内存的使用以及提高Shuffle 时排序的效率，Spark 引入了堆外（Off-heap）内存，使之可以直接在工作节点的系统内存中开辟空间，存储经过序列化的二进制数据。

堆外内存意味着把内存对象分配在Java虚拟机的堆以外的内存，这些内存直接受操作系统管理（而不是虚拟机）。这样做的结果就是能保持一个较小的堆，以减少垃圾收集对应用的影响。

利用 JDK Unsafe API（从 Spark 2.0 开始，在管理堆外的存储内存时不再基于Tachyon，而是与堆外的执行内存一样，基于 JDK Unsafe API 实现），Spark 可以直接操作系统堆外内存，减少了不必要的内存开销，以及频繁的 GC 扫描和回收，提升了处理性能。堆外内存可以被精确地申请和释放（堆外内存之所以能够被精确的申请和释放，是由于内存的申请和释放不再通过JVM机制，而是直接向操作系统申请，JVM对于内存的清理是无法准确指定时间点的，因此无法实现精确的释放），而且序列化的数据占用的空间可以被精确计算，所以相比堆内内存来说降低了管理的难度，也降低了误差。

在默认情况下堆外内存并不启用，可通过配置 spark.memory.offHeap.enabled 参数启用，并由spark.memory.offHeap.size 参数设定堆外空间的大小。除了没有 other 空间，堆外内存与堆内内存的划分方式相同，所有运行中的并发任务共享存储内存和执行内存。

（*该部分内存主要用于程序的共享库、Perm Space、线程Stack和一些Memory mapping等, 或者类C方式allocate object）

2. 内存空间分配

（1）静态内存管理

在 Spark 最初采用的静态内存管理机制下，存储内存、执行内存和其他内存的大小在 Spark 应用程序运行期间均为固定的，但用户可以应用程序启动前进行配置，堆内内存的分配如图1-2 所示：

      

图1-2 静态内存管理——堆内内存

可以看到，可用的堆内内存的大小需要按照代码清单1-1的方式计算：

代码清单1-1 堆内内存计算公式

可用的存储内存 = systemMaxMemory *spark.storage.memoryFraction * spark.storage.safety Fraction可用的执行内存 = systemMaxMemory *spark.shuffle.memoryFraction * spark.shuffle.safety Fraction

其中 systemMaxMemory 取决于当前 JVM 堆内内存的大小，最后可用的执行内存或者存储内存要在此基础上与各自的 memoryFraction 参数和 safetyFraction 参数相乘得出。上述计算公式中的两个safetyFraction 参数，其意义在于在逻辑上预留出 1-safetyFraction 这么一块保险区域，降低因实际内存超出当前预设范围而导致 OOM 的风险（上文提到，对于非序列化对象的内存采样估算会产生误差）。值得注意的是，这个预留的保险区域仅仅是一种逻辑上的规划，在具体使用时 Spark 并没有区别对待，和”其它内存”一样交给了 JVM 去管理。

Storage内存和Execution内存都有预留空间，目的是防止OOM，因为Spark堆内内存大小的记录是不准确的，需要留出保险区域。

堆外的空间分配较为简单，只有存储内存和执行内存，如图1-3所示。可用的执行内存和存储内存占用的空间大小直接由参数spark.memory.storageFraction 决定，由于堆外内存占用的空间可以被精确计算，所以无需再设定保险区域。

图1-3 静态内存管理

静态内存管理机制实现起来较为简单，但如果用户不熟悉 Spark 的存储机制，或没有根据具体的数据规模和计算任务或做相应的配置，很容易造成”一半海水，一半火焰”的局面，即存储内存和执行内存中的一方剩余大量的空间，而另一方却早早被占满，不得不淘汰或移出旧的内容以存储新的内容。由于新的内存管理机制的出现，这种方式目前已经很少有开发者使用，出于兼容旧版本的应用程序的目的，Spark 仍然保留了它的实现。

（3）统一内存管理

Spark 1.6 之后引入的统一内存管理机制，与静态内存管理的区别在于存储内存和执行内存共享同一块空间，可以动态占用对方的空闲区域，统一内存管理的堆内内存结构如图 1-4所示：

图1-4 统一内存管理——堆内内存

统一内存管理的堆外内存结构如图 1-5所示：

图1-5 统一内存管理——堆外内存

其中最重要的优化在于动态占用机制，其规则如下：

1.    设定基本的存储内存和执行内存区域（spark.storage.storageFraction 参数），该设定确定了双方各自拥有的空间的范围；

2.    双方的空间都不足时，则存储到硬盘；若己方空间不足而对方空余时，可借用对方的空间;（存储空间不足是指不足以放下一个完整的 Block）

3.   执行内存的空间被对方占用后，可让对方将占用的部分转存到硬盘，然后”归还”借用的空间；

4.   存储内存的空间被对方占用后，无法让对方”归还”，因为需要考虑 Shuffle 过程中的很多因素，实现起来较为复杂。

统一内存管理的动态占用机制如图1-6所示：

图1-6 同一内存管理——动态占用机制

凭借统一内存管理机制，Spark 在一定程度上提高了堆内和堆外内存资源的利用率，降低了开发者维护 Spark 内存的难度，但并不意味着开发者可以高枕无忧。如果存储内存的空间太大或者说缓存的数据过多，反而会导致频繁的全量垃圾回收，降低任务执行时的性能，因为缓存的 RDD 数据通常都是长期驻留内存的。所以要想充分发挥 Spark 的性能，需要开发者进一步了解存储内存和执行内存各自的管理方式和实现原理。

 

13. Spark yarn部署流程

yarn-client模式

1. 提交应用

2. 创建资源管理器

3. 申请资源

4. 返回资源列表

5. 创建Spark 执行器对象

6. 反向注册

7. 分解任务，并调度任务

 

14. Spark调优（☆）

在《02-Spark性能调优与故障处理》中有详细内容，这里只是枚举

1.1 常规性能调优

1.1.1 最优资源配置

1.1.2 RDD优化

1.1.3 并行度调节

1.1.4 广播大变量

1.1.5 Kryo序列化

1.1.6 调节本地化等待时长

1.2 算子调优

1.2.1 mapPartitions

1.2.2 foreachPartition优化数据库操作

1.2.3 filter与coalesce配合使用

1.2.4 repartition解决SparkSQL低并行度问题

1.2.5 reduceByKey本地聚合

1.3 Shuffle调优

1.3.1 调节map端缓冲区大小

1.3.2 调节reduce端拉取数据缓冲区大小

1.3.3 调节reduce端拉取数据重试次数

1.3.4 调节reduce端拉取数据等待间隔

1.3.5 调节SortShuffle排序操作阈值

1.4 JVM调优

1.4.1 降低cache操作的内存占比

1.4.2 调节Executor堆外内存

1.4.3 调节连接等待时长

以上是关于Spark面试题的主要内容，如果未能解决你的问题，请参考以下文章

「每日一道大数据面试题系列」spark如何调优

Spark面试题——说下对RDD的理解？RDD特点算子？

Spark面试题

Spark面试题——Spark的内存管理机制

spark面试题-1

Java工程师面试题，二级java刷题软件