spark面试总结2

Spark core面试篇02
1.cache后面能不能接其他算子,它是不是action操作？
答：cache可以接其他算子，但是接了算子之后，起不到缓存应有的效果，因为会重新触发cache。
cache不是action操作
2.reduceByKey是不是action？
答：不是，很多人都会以为是action，reduce rdd是action
3.数据本地性是在哪个环节确定的？
具体的task运行在那他机器上，dag划分stage的时候确定的
4.RDD的弹性表现在哪几点？
1）自动的进行内存和磁盘的存储切换；
2）基于Lingage的高效容错；
3）task如果失败会自动进行特定次数的重试；
4）stage如果失败会自动进行特定次数的重试，而且只会计算失败的分片；
5）checkpoint和persist，数据计算之后持久化缓存
6）数据调度弹性，DAG TASK调度和资源无关
7）数据分片的高度弹性，a.分片很多碎片可以合并成大的，b.par
5.常规的容错方式有哪几种类型？
1）.数据检查点,会发生拷贝，浪费资源
2）.记录数据的更新，每次更新都会记录下来，比较复杂且比较消耗性能
6.RDD通过Linage（记录数据更新）的方式为何很高效？
1）lazy记录了数据的来源，RDD是不可变的，且是lazy级别的，且rDD
之间构成了链条，lazy是弹性的基石。由于RDD不可变，所以每次操作就
产生新的rdd，不存在全局修改的问题，控制难度下降，所有有计算链条
将复杂计算链条存储下来，计算的时候从后往前回溯
900步是上一个stage的结束，要么就checkpoint
2）记录原数据，是每次修改都记录，代价很大
如果修改一个集合，代价就很小，官方说rdd是
粗粒度的操作，是为了效率，为了简化，每次都是
操作数据集合，写或者修改操作，都是基于集合的
rdd的写操作是粗粒度的，rdd的读操作既可以是粗粒度的
也可以是细粒度，读可以读其中的一条条的记录。
3）简化复杂度，是高效率的一方面，写的粗粒度限制了使用场景
如网络爬虫，现实世界中，大多数写是粗粒度的场景
7.RDD有哪些缺陷？
1）不支持细粒度的写和更新操作（如网络爬虫），spark写数据是粗粒度的
所谓粗粒度，就是批量写入数据，为了提高效率。但是读数据是细粒度的也就是
说可以一条条的读
2）不支持增量迭代计算，Flink支持
8.说一说Spark程序编写的一般步骤？
答：初始化，资源，数据源，并行化，rdd转化，action算子打印输出结果或者也可以存至相应的数据存储介质，具体的可看下图：

1. Spark有哪两种算子？
   答：Transformation（转化）算子和Action（执行）算子。
2. Spark提交你的jar包时所用的命令是什么？
   答：spark-submit。
3. Spark有哪些聚合类的算子,我们应该尽量避免什么类型的算子？
   答：在我们的开发过程中，能避免则尽可能避免使用reduceByKey、join、distinct、repartition等会进行shuffle的算子，尽量使用map类的非shuffle算子。这样的话，没有shuffle操作或者仅有较少shuffle操作的Spark作业，可以大大减少性能开销。
4. 你所理解的Spark的shuffle过程？
   答：从下面三点去展开
   1）shuffle过程的划分
   2）shuffle的中间结果如何存储
   3）shuffle的数据如何拉取过来
   可以参考这篇博文：http://www.cnblogs.com/jxhd1/p/6528540.html
5. 你如何从Kafka中获取数据？
   1)基于Receiver的方式
   这种方式使用Receiver来获取数据。Receiver是使用Kafka的高层次Consumer API来实现的。receiver从Kafka中获取的数据都是存储在Spark Executor的内存中的，然后Spark Streaming启动的job会去处理那些数据。
   2)基于Direct的方式
   这种新的不基于Receiver的直接方式，是在Spark 1.3中引入的，从而能够确保更加健壮的机制。替代掉使用Receiver来接收数据后，这种方式会周期性地查询Kafka，来获得每个topic+partition的最新的offset，从而定义每个batch的offset的范围。当处理数据的job启动时，就会使用Kafka的简单consumer api来获取Kafka指定offset范围的数据
6. 对于Spark中的数据倾斜问题你有什么好的方案？
   1）前提是定位数据倾斜，是OOM了，还是任务执行缓慢，看日志，看WebUI
   2)解决方法，有多个方面
   • 避免不必要的shuffle，如使用广播小表的方式，将reduce-side-join提升为map-side-join
   •分拆发生数据倾斜的记录，分成几个部分进行，然后合并join后的结果
   •改变并行度，可能并行度太少了，导致个别task数据压力大
   •两阶段聚合，先局部聚合，再全局聚合
   •自定义paritioner，分散key的分布，使其更加均匀
   15.RDD创建有哪几种方式？
   1).使用程序中的集合创建rdd
   2).使用本地文件系统创建rdd
   3).使用hdfs创建rdd，
   4).基于数据库db创建rdd
   5).基于Nosql创建rdd，如hbase
   6).基于s3创建rdd，
   7).基于数据流，如socket创建rdd
   如果只回答了前面三种，是不够的，只能说明你的水平还是入门级的，实践过程中有很多种创建方式。
   16.Spark并行度怎么设置比较合适
   答：spark并行度，每个core承载2~4个partition,如，32个core，那么64~128之间的并行度，也就是
   设置64~128个partion，并行读和数据规模无关，只和内存使用量和cpu使用
   时间有关
   17.Spark中数据的位置是被谁管理的？
   答：每个数据分片都对应具体物理位置，数据的位置是被blockManager，无论
   数据是在磁盘，内存还是tacyan，都是由blockManager管理
   18.Spark的数据本地性有哪几种？
   答：Spark中的数据本地性有三种：
   a.PROCESS_LOCAL是指读取缓存在本地节点的数据
   b.NODE_LOCAL是指读取本地节点硬盘数据
   c.ANY是指读取非本地节点数据
   通常读取数据PROCESS_LOCAL>NODE_LOCAL>ANY，尽量使数据以PROCESS_LOCAL或NODE_LOCAL方式读取。其中PROCESS_LOCAL还和cache有关，如果RDD经常用的话将该RDD cache到内存中，注意，由于cache是lazy的，所以必须通过一个action的触发，才能真正的将该RDD cache到内存中。
   19.rdd有几种操作类型？
   1）transformation，rdd由一种转为另一种rdd
   2）action，
   3）cronroller，crontroller是控制算子,cache,persist，对性能和效率的有很好的支持
   三种类型，不要回答只有2中操作
   19.rdd有几种操作类型？
   1）transformation，rdd由一种转为另一种rdd
   2）action，
   3）cronroller，crontroller是控制算子,cache,persist，对性能和效率的有很好的支持
   三种类型，不要回答只有2中操作
   20.Spark如何处理不能被序列化的对象？
   将不能序列化的内容封装成object
   21.collect功能是什么，其底层是怎么实现的？
   答：driver通过collect把集群中各个节点的内容收集过来汇总成结果，collect返回结果是Array类型的，collect把各个节点上的数据抓过来，抓过来数据是Array型，collect对Array抓过来的结果进行合并，合并后Array中只有一个元素，是tuple类型（KV类型的）的。
   22.Spaek程序执行，有时候默认为什么会产生很多task，怎么修改默认task执行个数？
   答：1）因为输入数据有很多task，尤其是有很多小文件的时候，有多少个输入
   block就会有多少个task启动；2）spark中有partition的概念，每个partition都会对应一个task，task越多，在处理大规模数据的时候，就会越有效率。不过task并不是越多越好，如果平时测试，或者数据量没有那么大，则没有必要task数量太多。3）参数可以通过spark_home/conf/spark-default.conf配置文件设置:
   spark.sql.shuffle.partitions 50 spark.default.parallelism 10
   第一个是针对spark sql的task数量
   第二个是非spark sql程序设置生效
   23.为什么Spark Application在没有获得足够的资源，job就开始执行了，可能会导致什么什么问题发生?
   答：会导致执行该job时候集群资源不足，导致执行job结束也没有分配足够的资源，分配了部分Executor，该job就开始执行task，应该是task的调度线程和Executor资源申请是异步的；如果想等待申请完所有的资源再执行job的：需要将spark.scheduler.maxRegisteredResourcesWaitingTime设置的很大；spark.scheduler.minRegisteredResourcesRatio 设置为1，但是应该结合实际考虑
   否则很容易出现长时间分配不到资源，job一直不能运行的情况。
   24.map与flatMap的区别
   map：对RDD每个元素转换，文件中的每一行数据返回一个数组对象
   flatMap：对RDD每个元素转换，然后再扁平化
   将所有的对象合并为一个对象，文件中的所有行数据仅返回一个数组
   对象，会抛弃值为null的值
   25.列举你常用的action？
   collect，reduce,take,count,saveAsTextFile等
   26.Spark为什么要持久化，一般什么场景下要进行persist操作？
   为什么要进行持久化？
   spark所有复杂一点的算法都会有persist身影,spark默认数据放在内存，spark很多内容都是放在内存的，非常适合高速迭代，1000个步骤
   只有第一个输入数据，中间不产生临时数据，但分布式系统风险很高，所以容易出错，就要容错，rdd出错或者分片可以根据血统算出来，如果没有对父rdd进行persist 或者cache的化，就需要重头做。
   以下场景会使用persist
   1）某个步骤计算非常耗时，需要进行persist持久化
   2）计算链条非常长，重新恢复要算很多步骤，很好使，persist
   3）checkpoint所在的rdd要持久化persist，
   lazy级别，框架发现有checnkpoint，checkpoint时单独触发一个job，需要重算一遍，checkpoint前
   要持久化，写个rdd.cache或者rdd.persist，将结果保存起来，再写checkpoint操作，这样执行起来会非常快，不需要重新计算rdd链条了。checkpoint之前一定会进行persist。
   4）shuffle之后为什么要persist，shuffle要进性网络传输，风险很大，数据丢失重来，恢复代价很大
   5）shuffle之前进行persist，框架默认将数据持久化到磁盘，这个是框架自动做的。
   27.为什么要进行序列化
   序列化可以减少数据的体积，减少存储空间，高效存储和传输数据，不好的是使用的时候要反序列化，非常消耗CPU
   28.介绍一下join操作优化经验？
   答：join其实常见的就分为两类： map-side join 和 reduce-side join。当大表和小表join时，用map-side join能显著提高效率。将多份数据进行关联是数据处理过程中非常普遍的用法，不过在分布式计算系统中，这个问题往往会变的非常麻烦，因为框架提供的 join 操作一般会将所有数据根据 key 发送到所有的 reduce 分区中去，也就是 shuffle 的过程。造成大量的网络以及磁盘IO消耗，运行效率极其低下，这个过程一般被称为 reduce-side-join。如果其中有张表较小的话，我们则可以自己实现在 map 端实现数据关联，跳过大量数据进行 shuffle 的过程，运行时间得到大量缩短，根据不同数据可能会有几倍到数十倍的性能提升。
   备注：这个题目面试中非常非常大概率见到，务必搜索相关资料掌握，这里抛砖引玉。
   29.介绍一下cogroup rdd实现原理，你在什么场景下用过这个rdd？
   答：cogroup的函数实现:这个实现根据两个要进行合并的两个RDD操作,生成一个CoGroupedRDD的实例,这个RDD的返回结果是把相同的key中两个RDD分别进行合并操作,最后返回的RDD的value是一个Pair的实例,这个实例包含两个Iterable的值,第一个值表示的是RDD1中相同KEY的值,第二个值表示的是RDD2中相同key的值.由于做cogroup的操作,需要通过partitioner进行重新分区的操作,因此,执行这个流程时,需要执行一次shuffle的操作(如果要进行合并的两个RDD的都已经是shuffle后的rdd,同时他们对应的partitioner相同时,就不需要执行shuffle,)，
   场景：表关联查询
   30 下面这段代码输出结果是什么？
   --------------------------
   def joinRdd(sc:SparkContext) {
   val name= Array(
   Tuple2(1,"spark"),
   Tuple2(2,"tachyon"),
   Tuple2(3,"hadoop")
   )
   val score= Array(
   Tuple2(1,100),
   Tuple2(2,90),
   Tuple2(3,80)
   )
   val namerdd=sc.parallelize(name);
   val scorerdd=sc.parallelize(score);
   val result = namerdd.join(scorerdd);
   result .collect.foreach(println);
   }
   --------------------------
   答案:
   (1,(Spark,100))
   (2,(tachyon,90))
   (3,(hadoop,80))