2019大数据精华面试题(转存)

1. ConcurrentHashMap 是怎么实现的？

答：concurrent 包中线程安全的哈希表，采用分段锁，能够理解为把一个大的 Map 拆分红 N 个小的 HashTable，根据 key.hashCode() 来决定把 key 放到哪一个 HashTabl 中。在 ConcurrentHashMap 中，就是把 Map 分红了 N 个 Segment，put 和 get 的时候，都是现根据 key.hashCode() 算出放到哪一个 Segment 中。

2. sparksql 和 sparkstreaming 哪一个比较熟

答：都还行，SparkSql 的 DataFrame 或者 DataSet 和 SparkStreaming 的 DStream 都是基于SparkCore 的，最终都会转化为 Sparktask 执行。咱们能够交流一下本质的东西 SparkCore，而SparkCore 的核心又是 RDD。

3. 说一下 sparkshuffle

答：Spark 的 shuffle 也是一处理问题的思想：分而治之。shuffle 通常称为洗牌，通常会有Shuffle。

Write 阶段 和 Shuffle

Read 阶段。在 Spark 中实现 Shuffle 的方式有两种，一种是 HashShuffle，一种是 SortShuffle。shuffle 的性能是影响 spark 应用程序性能的关键。shuffle 发生在 stage 之间，stage 中用的 pipline 的计算模式。

4. Spark Shuffle 的调优势：

答:(1)：Shuffle 的选择 (2)：缓冲区的大小 (3)：拉去的数据量的大小 (4)：间隔时间重试次数。

5. 缓存这块熟悉吗，介绍缓存级别

答：Spark 的缓存机制是 Spark 优化的一个重要点，它将须要重复使用或者共用的 RDD 缓存在内存中，能够提升 Spark 的性能。Spark 的底层源码中使用 StorageLevel 来表示缓存机制，其中包括：使用内存，使用磁盘，使用序列化，使用堆外内存。在他的半生对象中基于这几种方式提供了一些实现：不使用缓存，Memory_Only，Disk_only，offHeap 分别都有相应的序列化，副本，组合的实现提供选择。持久化的级别 StorageLevel 能够自定义，可是通常不自定义。如何选择 RDD 的缓存级别的本质是在内存的利用率和 CPU 的利用率之间的权衡。通常默认选择的是 Memory_only, 其次是 Memery_only_Ser, 再次是 Memory_only_and_Dis 至于怎么选择你得本身权衡。

6. 说一下 cache 和 checkpoint 的区别

答：要知道区别，首先要知道实现的原理和使用的场景 catche 的就是将共用的或者重复使用的 RDD 按照持久化的级别进行缓存 checkpoint 的是将业务场景很是长的逻辑计算的中间结果缓存到 HDFS 上，它的实现原理是: 首先找到 stage 最后的 finalRDD，而后按照 RDD 的依赖关系进行回溯，找到使用了 checkPoint 的 RDD 而后标记这个使用了 checkPoint 的 RDD 从新的启动一个线程来将 checkPoint 以前的 RDD 缓存到 HDFS 上面最后将 RDD 的依赖关系从 checkPoint 的位置切断知道了实现的原理和使用场景后咱们就很容易的知道了 catch 和 checkpoint 的区别了。

7. spark 运行模式 local local[] local[*] 分别是什么

答：该模式被称为 Local[N] 模式，是用单机的多个线程来模拟 Spark 分布式计算，一般用来验证开发出来的应用程序逻辑上有没有问题其中N表明可使用 N 个线程，每一个线程拥有一个 core 。若是不指定 N，则默认是1个线程（该线程有1个 core ）。若是是 local[*]，则表明 Run Spark locally with as many worker threads as logical cores on your machine： 在本地运行Spark，与您的机器上的逻辑内核同样多的工做线程。

8. Spark 怎么设置垃圾回收机制 ？

答：Spark 中各个角色的JVM参数设置：http://blog.csdn.net/wuxb2000/article/details/52870198 1)Driver 的 JVM 参数： GC 方式，若是是 yarn-client 模式，默认读取的是 spark-class 文件中的 JAVAOPTS；若是是 yarn-cluster 模式，则读取的是 spark-default.conf 文件中的 spark.driver.extraJavaOptions 对应的参数值。 (2)Executor 的 JVM 参数： GC 方式，两种模式都是读取的是 spark-default.conf 文件中的spark.executor.extraJavaOptions 对应的 JVM 参数值。

9. 一台节点上以 root 用户执行一个 spark 程序，以其余非 root 用户也同时在执行一个 spark 程序，这时以 spark 用户登陆，这个节点上，使用 Jps 会看到哪些线程？

答：单独的用户只能看本身的进程

10. hive 怎么解决数据倾斜的问题？

参考博客：https://www.cnblogs.com/ggjucheng/archive/2013/01/03/2842860.html 本质：使 map 的输出数据更均匀的分布到 reduce 中去，是咱们的最终目标

11. 数据倾斜的缘由：

key 分布不均匀 业务数据自己的欠缺性 建表设计方法不对 有些 SQL 不免会有一下数据倾斜不可避免 表现的形式： 任务完成进度卡死在99%，或者进度完成度在100%可是查看任务监控，发现仍是有少许（1个或几个）reduce 子任务未完成。由于其处理的数据量和其余 reduce 差别过大。单一reduce 的记录数与平均记录数差别过大，一般可能达到3倍甚至更多。 最长时长远大于平均时长。

解决方案： 参数调整： hive.map.aggr=true： Map 端部分聚合，至关于 Combiner hive.groupby.skewindata=true： 有数据倾斜的时候进行负载均衡，当选项设定为 true，生成的查询计划会有两个 MR Job。第一个 MR Job 中，Map 的输出结果集合会随机分布到 Reduce 中，每一个 Reduce 作部分聚合操做，并输出结果，这样处理的结果是相同的 Group By Key 有可能被分发到不一样的 Reduce 中，从而达到负载均衡的目的；第二个 MR Job 再根据预处理的数据结果按照 Group By Key 分布到 Reduce 中（这个过程能够保证相同的 Group By Key 被分布到同一个 Reduce 中），最后完成最终的聚合操做。 2：参数调节： 如何 Join： 关于驱动表的选取，选用 join key 分布最均匀的表做为驱动表 作好列裁剪和 filter 操做，以达到两表作 join 的时候，数据量相对变小的效果 大小表 Join： 使用 map join 让小的维度表（1000条如下的记录条数） 先进内存。在 map 端完成 reduce. 大表 Join 大表： 把空值的 key 变成一个字符串加上随机数，把倾斜的数据分到不一样的 reduce 上，因为 null值关联不上，处理后并不影响最终结果 count distinct 大量相同特殊值 count distinct 时，将值为空的状况单独处理，若是是计算 count distinct，能够不用处理，直接过滤，在最后结果中加1。若是还有其余计算，须要进行 group by，能够先将值为空的记录单独处理，再和其余计算结果进行 union。 group by 维度太小： 采用 sum() group by 的方式来替换 count(distinct) 完成计算。 特殊状况特殊处理： 在业务逻辑优化效果的不大状况下，有些时候是能够将倾斜的数据单独拿出来处理。最后 union 回去。 若是确认业务须要这样倾斜的逻辑，考虑如下的优化方案： 总结： 一、对于 join，在判断小表不大于1 G 的状况下，使用 map join 二、对于 group by 或 distinct，设定 hive.groupby.skewindata=true 三、尽可能使用上述的 SQL 语句调节进行优化

12. 若是链表的实现方式中 hash 的值有冲突的话，怎么解决？若是解决之后怎么解决再链表的常数次的查询？

答案：使用链表来存储重复的 hash 值，如何对链表进行常数次的查找，须要将链表+随机数再 hash

13. HDFS 的读写流程细节？HDFS 中的 fsimage 里面存储的是什么信息？副本的存放策略？

答：这个你们最好回家准备一个详细的流程图而后根据本身的图讲给面试官看

14. HDFS 的机架感知？

答：根据副本的存放策略，HDFS 是如何知道多个不一样 node 是否在同一个机架上呢 ?在namenode 启动时若是 net.topology.script.file.name 配置的参数不为空，表示已经动机架感知，当 datanode 注册时和 heartbeat 时，会把 datanode 的 ip 做为参数传入，返回信息为此datanode 的机架信息。若是没有参数配置，datanode 统一为默认的机架 /default-rack

15. 若是 Client 节点就在 HDFS 中的一台 DataNode 节点上，副本的数据又是如何存储的？

答案：存放在当前的 DN 上，其余的和副本的存放的策略同样，第二个副本存放在和第一个副本不一样的机架上的节点上，第三个副本存放在同第二个副本相同的机架的不一样的节点上

16. Spark 的提交方式？

答案：无论是提交到 yarn 上面仍是提交到 standalone 上都分为 Client 的方式提交和 Cluster 的方式提交

17. 项目的模型训练和项目的准确度是多少？

答：通常在项目的初期准确度通常在百分之85左右就能够了，这个精准度还要根据业务的不断调整去不断的调节

18. 项目组多少人？怎么分工的？薪水多少？项目中你负责那一块？

答：这一块你们能够根据要面试的公司规模来提早准备几十人几百人分组均可以，可是薪水必定不要说滴，若是你是10k的工资去面试30k的岗位人家首先会对你产生怀疑的。

19. 手写冒泡排序和二分查找？

这个建议你们在去面试以前必定要紧紧的记住怎么写，起码要本身能加拿大的写一个小的demo，这样才能在面试官面前书写流畅。

20. 如何将一个标题等在一千万数据中进行进行 Top10 的推荐？

答案：标题向量化，数据清洗和降维，计算类似度，推荐

21. kafka 用到了什么

答：消息持久化，消息批量发送，消息有效期，负载均衡方面均可以说，同步异步的问题，可是必定要挑本身熟悉的说

22. hadoop 支持三种调度器

答：先进先出的调度器：最先的 hadoop 采用的是 FIFO（默认-先进先出的）调度器调度用户提交的做业。做业按照提交的顺序被调度，做业必须等待轮询到本身才能运行。 可是考虑到公平在多用户之间分配资源，设置了做业的优先级功能，可是不支持抢占式的。

公平调度器：公平调度器的目标是让每个用户公平的共享集群能力，充分的利用闲置的任务槽，采用“让用户公平的共享集群”的方式分配资源。做业放在做业池之中，每一个用户拥有本身的做业池。提交的做业越多并不会所以得到更多的资源，公平调度器支持抢占式的机制，一个做业池中若没有公平的共享资源，则会将多余的资源空出来。

容量调度器：集群中不少的队列组成的，这些队列具备必定的层次结构，每一个队列都有必定的容量。每一个队列的内部支持 FIIFO 方式。本质上容量调度器容许用户或则组织模拟出一个使用 FIFO 调度策略的独立 MApReduce 集群

23. 编写 mapreduce 的方式：

java 编写-经常使用 Hadoop Streaming：使用 unix 标准的输入和输出流做为 hadooop 和应用程序之间的接口，支持像Ruby，python 等不一样的编程语言编写 map 和 reduce Hadoop Pipes 是 hadoop 提供的 C++ 的接口的名称

24. hive 保存元数据的方式有三种：

1：自带的内存数据库 Derby 方式保存，只支持单个会话，挺小，不经常使用 2：本地 mysql ：经常使用本地调用 3：Remote 远程 mysql 方式：远程调用

25. hadoop 二级排序：

hadoop 默认的是对 key 进行排序，若是想要再对 value 进行排序，那么就要使用：二级排序 二级排序的方式： 1：将 reduce 接收到的 value-list 的值缓存，而后作 reduce 内排序，再写出，这样排序速度快一些，因为value-list 的数据可能很庞大，可能会形成内存的溢出 2：将值的一部分或则整个部分加入 key ，生成一个合并的能够。生成组合 key 的过程很简单。咱们须要先分析一下，在排序时须要把值的哪些部分考虑在内，而后，把它们加进 key 里去。随后，再修改 key 类的 compareTo 方法或是 Comparator 类，确保排序的时候使用这个组合而成的 key。

26. 内部表&外部表

hive 的内部表和外部表的區別是 hive 的内部表是由 hive 本身管理的，外部表只是管理元数据，当删除数据的时候，内部表会连数据和元数据所有删除，而外部表则只会删除元数据，数据依然存放在 hdfs 中。外部表相对来讲更加的安全一些，数据的组织也更加的灵活一些，方便共享源数据.

下面来点数据结构方面的题转换一下思路 手写数据结构和算法：比较重要，基础中的基础

27. 冒泡排序

private static void bubbleSort(int[] array) {
    int temp = 0;
    for (int i = 0; i < array.length - 1; i++) {
        for (int j = 0; j < array.length - 1 - i; j++) {
            if (array[j + 1] < array[j]) {
                temp = array[j]
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

28. 二分查找

public static int binarySearch(int srcArray,int des){
        int low=0;
        int height=srcArray.length-1;
        while(low<=height){
            int middle=(low+height)/2;
            if(des==srcArray[middle]){
                return middle;
            }else if(des<srcArray[middle]){
                height=middle-1;
            }else{
                low=middle+1;
            }
        }
        return -1;
    }

29. 递归的方式实现：

public static int binarySearch(int[] dataset;int data,int beginIndex,int endIndex){ int midIndex=(beginIndex+endIndex)/2;
        if(data<dataset[beginIndex] || data>dataset[endIndex] || beginIndex>endIndex){
            return -1;
        }
        if(data<dataset[midIndex]){
            return binarySearch(dataset,data,beginIndex,midelIndex-1); }else if(data>dataset[midIndex]){
            return binarySearch(dataset,data,midIndex+1,endIndex); }else{
            return midIndex;
        }
    }

30. 单链表反转

class ListNode {
        int val;
        ListNode next;

        ListNode(int x) {
            val = x;
        }
    }

    public static ListNode reverseList(ListNode head) {
        ListNode prev = null;
        while (head != null) {
            ListNode temp = head.next;
            head.next = prev;
            prev = head;
            head = temp;
        }
        return prev;
    }

31. 插入排序：

初始时假设第一个记录自成一个有序序列，其他记录为无序序列。接着从第二个记录开始，按照记录的大小依次将当前处理的记录插入到其以前的有序序列中，直至最后一个记录插入到有序序列中为止

public static void insertSort(int[] a) {
        int temp;
        for (int i = 1; i < a.length; i++) {
            for (int j = i; j > 0; j--) {
                if (a[j - 1] > a[j]) {
                    temp = a[j - 1]
                    a[j - 1] = a[j]
                    a[j] = temp
                }
            }
        }
    }

32. 选择排序：

把最小或者最大的选择出来 对于给定的一组记录，通过第一轮比较后获得最小的记录，而后将该记录与第一个记录的位置进行交换；接着对不包括第一个记录之外的其余记录进行第二轮比较，获得最小的记录并与第二个记录进行位置交换；重复该过程，直到进行比较的记录只有一个时为止

public static void selectSort(int[] a) {
        if (a == null || a.length <= 0) {
            return;
        }
        for (int i = 0; i < a.length; i++) {
            int min = i;
            for (int j = i + 1; j < a.length; j++) {
                if (a[j] < a[min]) {
                    min = j;
                }
            }
            if (i != min) {
                int tmp = a[min];
                a[min] = a[i];
                a[i] = tmp;
            }
        }
    }

数据结构在面试方面基本上就是这些内容，下面继续给你们展现一下有关 hive/hbase 方面的面试题

33. 你认为用 Java、streaming、pipe 方式开发 map/reduce ， 各有哪些优势

就用过 java 和 hiveQL。 Java 写 mapreduce 能够实现许多复杂的逻辑思惟，可是一旦对于简单的需求来讲太过于繁琐。

HiveQL 基本的针对对象是 hive 上的表，可是一旦遇到很复杂的逻辑的话就去实很难去实现。对于语句书写方面来讲仍是很简单的。

34. hive 有哪些方式保存元数据，各有哪些优势

三种：自带内嵌数据库 derby，挺小，不经常使用，最致命的是只能用于单节点。

35. 请简述 hadoop 怎样实现二级排序（对 key 和 value 双排序）

第一种方法是，Reducer 将给定 key 的全部值都缓存起来，而后对它们在 Reduce 内部作一个内排序。可是，因为 Reducer 须要缓存给定 key 的全部值，数据量多的话可能会致使内存不足。

第二种方法是，将值的一部分或整个值键入到原始 key 中，从新组合成一个新的 key 。这两种方法各有各的特色，第一种方法编写简单，可是须要较小的并发度，数据量大的话可能会形成内存耗尽卡死的状态。 第二种方法则是将排序的任务交给 MapReduce 框架进行 shuffle，更符合 Hadoop/Reduce 的设计思想。

36. 请简述 mapreduce 中的 combine 和 partition 的做用

答：combiner 是发生在 map 的最后一个阶段，其原理也是一个小型的 reducer，主要做用是减小输出到 reduce 的数据量，提升网络传输瓶颈，提升 reducer 的执行效率。 partition 的主要做用将 map 阶段产生的全部 k，v 对分配给不一样的 reducer task 处理，能够将 reduce 阶段的处理负载进行分摊。

37. hive 内部表和外部表的区别

Hive 向内部表导入数据时，会将数据移动到数据仓库指向的路径；如果外部表，用户在建表的时候就要肯定表的位置 在删除表的时候，内部表的元数据和数据会被一块儿删除， 而外部表只删除元数据，不删除数据。 这样外部表相对来讲更加安全些，数据组织也更加灵活，方便共享源数据。

38. Hbase 的 rowKey 怎么建立比较好？

答：rowkey 的设计必定要有规则而且有序，经常使用的一些 rowkey 必定要连续连续，而且 rowkey的设计规则最好加入之后要查询的规则在里面方便往后校对查询。

39. 列族的建立：

根据业务的特色对数据进行归类。

40. 用 mapreduce 怎么处理数据倾斜问题

本质：让各个分区的数据均匀分布，而且根据本身的业务特色设置合适的 partition 策略，具体的设置方法能够上网查询一下，这里就不过多的介绍了。若是事先不知道业务数据的分布规律，只能利用随机抽样以后生成 partition 策略后再作处理

41. hadoop 框架怎么来优化

答：能够从不少方面来进行：好比 hdfs，mapreduce，yarn 的 job 调度，hbase，hive 能够优化的有太多地方了，具体要在哪里优化只能看你数据的特色了，根据真实场景来判断。

42. hbase 内部机制是什么

答：Hbase 是一个能适应联机业务的数据库系统 物理存储：hbase 的持久化数据是存放在 hdfs 上 存储管理：一个表是划分为不少 region 的，这些 region 分布式地存放在不少 regionserver 上

版本管理：hbase 中的数据更新本质上是不断追加新的版本，经过 compact 操做来作版本间的文件合并 Region 的 split 集群管理：zookeeper + hmaster（职责） + hregionserver（职责）

43. 咱们在开发分布式计算 job 的时候，是否能够去掉 reduce 阶段

答：能够，若是不涉及到有关数据的计算的话仍是能够省才去 mapreduce 阶段的

44. hadoop 中经常使用的数据压缩算法

答：Lzo，Gzip，Default，Snapyy 若是要是对数据进行压缩的话最好将数据转化一下：quenceFile 或者 Parquet File（spark）

45. mapreduce 的做业调度模式

答： 公平调度器：为每一个任务分配资源的方法，按照做业的优先级高低，再按照到达时间的前后选择被执行的做业

46. hive 底层与数据库交互原理

答：Hive 的查询功能是由 hdfs 和 mapreduce 结合起来实现的，对于大规模数据查询仍是不建议在 hive 中，由于过大数据量会形成查询十分缓慢。 Hive 与 mysql 的关系：只是借用 mysql 来存储 hive 中的表的元数据信息，称为 metastore

47. 现场出问题测试 mapreduce 掌握状况和 hive 的 ql 语言掌握状况

答：这个就要看你们的功底了，现场问题我也想不出来。

48. datanode 在什么状况下不会备份数据

答：在客户端上传文件时指定文件副本数量为1，可是基本咱们作大数据都是设置副本的数量是，这个还要根据本身公司的状况而定。

49. combine 合并出如今哪一个过程

答：shuffle 过程当中具体来讲，combine 之不过是一个特殊的 reduce 而已，而且发生在本地，累加 map 里面 key 的值而后发给 reduce 处理

50. hdfs 的体系结构

答：集群架构： namenode datanode secondarynamenode journalnode zkfc 这个是简单的基本架构，在文章末尾我会找一下架构图形提供给你们参考。

51. flush 的过程

答：flush 是在内存的基础上进行的，首先写入文件的时候，会先将文件写到内存中，当内存写满的时候，一次性的将文件所有都写到硬盘中去保存，并清空缓存中的文件，

52. 什么是队列

答：就是一种简单的调度策略，先来先进，先进先出

53. Spark 都有什么算子?

答案：map，reducebykey，filter，mapPartition，flatmap，cogroup，foreach，first，take， join， sortBy，distinct，等等

54. List 与 set 的区别

答：List 和 Set 都是接口。他们各自有本身的实现类，有无顺序的实现类，也有有顺序的实现类。 最大的不一样就是 List 是能够重复的。而Set是不能重复的。 List 适合常常追加数据，插入，删除数据。但随即取数效率比较低。 Set 适合常常地随即储存，插入，删除。可是在遍历时效率比较低。

55. 数据的三范式

答： 第一范式（）无重复的列 第二范式（2NF）属性彻底依赖于主键 [消除部分子函数依赖] 第三范式（3NF）属性不依赖于其它非主属性 [消除传递依赖]

56. 三个 datanode 中当有一个 datanode 出现错误时会怎样？

答：Namenode 会第一时间经过心跳发现 datanode 下线，而且经过副本策略将这个 datanode 上的block 快从新发送分配到集群中而且从新复制一份保持每一个 block 块的副本数量不变。在此同事运维团队必定要第一时间被通知处处理这个问题，尽快维修上线

57. sqoop 在导入数据到 mysql 中，如何不重复导入数据，若是存在数据问题，sqoop 如何处理？

答：FAILED java.util.NoSuchElementException 此错误的缘由为 sqoop 解析文件的字段与 MySql 数据库的表的字段对应不上形成的。所以须要在执行的时候给 sqoop 增长参数，告诉 sqoop 文件的分隔符，使它可以正确的解析文件字段。 hive 默认的字段分隔符为 '\001'

58. MapReduce 优化经验

答：1.设置合理的 map 和 reduce 的个数。合理设置块的大小，要注意一个任务对应一个 map 2避免数据倾斜，合理分配数据对应的 key，尽可能对 sql 进行优化 3 combine 函数 4 对数据进行压缩处理，必要的时候对数据进行拆分。 5小文件处理优化：事先合并成大文件，combineTextInputformat，在 hdfs 上用 mapreduce 将小文件合并成 SequenceFile 大文件（key: 文件名，value：文件内容），而且要按期在非工做时间作一次大合并，可是要提早估算好工做量，由于大合并期间全部任务是没办法执行的。 6参数优化，具体什么参数比较多你们能够自行百度。

59. 请列举出曾经修改过的 /etc/ 下面的文件，并说明修改要解决什么问题？

答：/etc/profile 这个文件，主要是用来配置环境变量。让 hadoop 命令能够在任意目录下面执行。可是每一个开发人员都有本身的目录设置习惯，这个须要根据本身的习惯具体来回答。 /ect/sudoers /etc/hosts /etc/sysconfig/network /etc/inittab

60. 请描述一下开发过程当中如何对上面的程序进行性能分析，对性能分析进行优化的过程。

61. 现有 1 亿个整数均匀分布，若是要获得前 1K 个最大的数，求最优的算法。

参见《海量数据算法面试大全》

62. mapreduce 的大体流程

答：主要分为八个步骤

对文件进行切片，提早想好块的大小如何分配 启动相应数量的 maptask 进程 调用 FileInputFormat 中的 RecordReader，读一行数据并封装为 k1v1 调用自定义的 map 函数，并将 k1v1 传给 map，一个任务对应一个 map 收集 map 的输出，进行分区和排序，这块要注意优化。 reduce task 任务启动，并从 map 端拉取数据 reduce task 调用自定义的 reduce 函数进行处理 调用 outputformat 的 recordwriter 将结果数据输出 63. 搭建 hadoop 集群 ， master 和 slaves 都运行哪些服务

答：master 是主节点，slaves 是从节点

64. hadoop 运行原理

答：hadoop 的主要由两部分组成，HDFS 和 mapreduce，HDFS 就是把数据进行分块存储。 Mapreduce 的原理就是使用 JobTracker 和 TaskTracke r来进行做业的执行。Map 就是将任务展开，reduce 是汇总处理后的结果。简单的来讲就是提交一个 jar 包，这个时候须要 mapreduce 来处理。

65. HDFS 存储机制

答：HDFS 主要是一个分布式的文件存储系统，由 namenode 来接收用户的操做请求，而后根据文件大小，以及定义的 block 块的大小，将大的文件切分红多个 block 块来进行保存，这里存在的优化问题点比较多，前期处理很差可能会形成后期的数据倾斜比较严重。

66. 举一个例子说明 mapreduce 是怎么运行的。

自带的实例 Wordcount，可是最好是本身准备一个写熟了的例子。

67. 如何确认 hadoop 集群的健康情况

答：有完善的集群监控体系（ganglia，nagios） Hdfs dfsadmin –report Hdfs haadmin –getServiceState nn1

选择题（此部分来源于网络筛选）

68. 下面哪一个程序负责 HDFS 数据存储。 答案 C

a) NameNode b) Jobtracker c) Datanode d) secondaryNameNode e) tasktracker

69. HDfS 中的 block 默认保存几份？ 答案 A

a) 3 份 b)2 份 c) 1 份 d) 不肯定

70. 下列哪一个程序一般与 NameNode 在一个节点启动？

a) SecondaryNameNode b) DataNode c) TaskTracker d) Jobtracker e) zkfc

71. Hadoop 做者 答案 D

a) Martin Fowler b) Kent Beck c) Doug cutting

72. HDFS 默认 Block Size 答案 B

a) 32MB b) 64MB c) 128MB

73. 下列哪项一般是集群的最主要瓶颈 答案 D

a) CPU b)网络 c)磁盘 d)内存

74. 关于 SecondaryNameNode 哪项是正确的？ 答案 C

a) 它是 NameNode 的热备 b) 它对内存没有要求 c) 它的目的是帮助 NameNode 合并编辑日志，减小 NameNode 启动时间 d) SecondaryNameNode 应与 NameNode 部署到一个节点

75. 配置机架感知[M3] 的下面哪项正确 答案 ABC

a) 若是一个机架出问题，不会影响数据读写 b) 写入数据的时候会写到不一样机架的 DataNode 中 c) MapReduce 会根据机架获取离本身比较近的网络数据

76. Client 端上传文件的时候下列哪项正确 答案 BC

a) 数据通过 NameNode 传递给 DataNode b) Client 端将文件切分为 Block，依次上传 c) Client 只上传数据到一台 DataNode，而后由 NameNode 负责 Block 复制工做

77. 下列哪一个是 Hadoop 运行的模式 答案 ABC

a )单机版 b) 伪分布式 c) 分布式

78. Cloudera 提供哪几种安装 CDH 的方法 答案 ABCD

a )Cloudera manager b) Tar ball c) Yum d) Rpm

判断题（此部分来源于网络筛选）：

79. Ganglia 不只能够进行监控，也能够进行告警。（ X ）

80. Block Size 是不能够修改的。（ X ）

81. Nagios 不能够监控 Hadoop 集群，由于它不提供 Hadoop 支持。（ X ）

82. 若是 NameNode 意外终止， SecondaryNameNode 会接替它使集群继续工做。（ X ）

83. Cloudera CDH 是须要付费使用的。（ X ）

84. Hadoop 是 Java 开发的，因此 MapReduce 只支持 Java 语言编写。（ X ）

85. Hadoop 支持数据的随机读写。（X ）

86. NameNode 负责管理 metadata， client 端每次读写请求，它都会从磁盘中读取或则 会写入 metadata 信息并反馈 client 端。（X ）

87. NameNode 本地磁盘保存了 Block 的位置信息。（X ）

88. DataNode 经过长链接与 NameNode 保持通讯。（ X ）

89. Hadoop 自身具备严格的权限管理和安全措施保障集群正常运行。（X ）

90. Slave节点要存储数据，因此它的磁盘越大越好。（X ）

91. hadoop dfsadmin –report 命令用于检测 HDFS 损坏块。（ X）

92. Hadoop 默认调度器策略为 FIFO（ 正确）

93. 集群内每一个节点都应该配 RAID，这样避免单磁盘损坏，影响整个节点运行。（X ）

94. 由于 HDFS 有多个副本，因此 NameNode 是不存在单点问题的。（X ）

95. 每一个 map 槽（进程）就是一个线程。（X ）

96. Mapreduce 的 input split 就是一个 block。（X ）

97. NameNode的默认 Web UI 端口是 50030，它经过 jetty 启动的 Web 服务。（X ）

98. Hadoop 环境变量中的 HADOOP_HEAPSIZE 用于设置全部 Hadoop 守护线程的内存。它默认是200 GB。（ X ）

99. DataNode 首次加入 cluster 的时候，若是 log中报告不兼容文件版本，那须要 NameNode执行“Hadoop namenode -format ”操做格式化磁盘。（X ）

100. 面试面试官问了大家天天有多少数据，用了多少台机器

答： 通常根据你写的项目，天天产生的数据量规划，假如一天数据量100G 通常集群 规划是年数据量的3倍还要多一点这样算下来大概须要60台左右的机器才能保障运行。

101. 天天运行多久

答：通常一个做业10分钟到-几个小时不等 通常一个做业也就几十分钟。。运行几天的不多

102. 有多少个 MR

答：30-50个左右 通常公司不少个做业。。 你能够说大家部门的,其余你不清楚就别说，，相应你简历上写的项目，不少模板都有做业。。细化一下 好比推荐的做业，统计汇总的做业，用户定位的做业

103. 遇到 bug 怎么解决，上线以后的 bug 怎么解决

答：通常在测试阶段就那部分线上数据测试过了。。 若是在线上还有问题通常 kill 掉做业。。固然能够作 mapreduce 里面设计日志输出到单独文件，， 根据 hadoop 异常日志出什么问题了。。固然 hadoop 每台都会有日志，固然 hadoop 本身的日子很庞大，能够采用 chukwa（大概看看干什么的就行，就是收集方便查看 hadoop 自己的日志）处理而后分析做业代码。

104. 有没有关心过运行时候的状态

答：mapreduce 运行状态，hadoop 有监控页面，固然也能够本身写监控程序，mapreduce 有做业监听方法，能够获取进度。

105. 每台机器的负载

答：采用 ganglia,nagios,zabbix 监控工具监控机器磁盘，内存，cpu 你只须要回答采用这些弄得 具体运维部弄得。固然你研究过会更好

106. 宽窄依赖？

答：除了父 RDD 和子 RDD 一对多外，其余的都是窄依赖

107. spark on yarn 和 mapreduce 中 yarn 有什么区别？

答：没有什么区别，yarn 就是一种任务调度框架

108. spark 运行的 job 在哪里能够看到？

答： 通常是在 WEBUI 上 查看，若是问具体怎么配置的能够推到运维人员身上

109. 用 scala 写一个 wordcount ？

object ScalaWordCount{
        def main (args:Array[String]):Unit = {
            val lines = List("hello java hello python", "hello scala", "hello scala hello java hello scala")
            // 切块
            val words = lines.flatMap(_.split(" "))
            // 生成pair
            val tuples = words.map((_, 1))
            // k,v分组
            val grouped = tuples.groupBy(_._1)
            val sumed = grouped.mapValues(_.size)
            // 排序
            val sorted = sumed.toList.sortBy(_._2)
            // 降序
            val result = sorted.reverse
            println(result)
        }
    }

110. 对 scala 的了解 有用过 play framework 框架吗

答：是一个纯java框架，能够进行快速开发，开发周期较短，而且可以快速创建一个java web所须要的全部内容。

111. scala 中的隐式函数的关键字？

答：implicit

112. val x=y=1 结果是什么？

答：会报错

113. 编译好的 scala 程序，运行的时候还须要 scala 环境吗?

答：不须要

116. 画下项目的架构图介绍下项目？介绍下你作的哪些方面？

答：这个你们最好提早本身画一画，这样每一步对应的数据流程都是你本身最熟悉的，这样才显的最真实，特别是没有从事过大数据行业的人不免会内心发虚。我在文章的最上部简单的画了一下架构图，你们能够照着参考一下。

117. 介绍下 kafka 容错性

kafka 不像集群最少须要三台机器，假若有三个 kafka，若是坏了两个，那么剩下的一个就是主 leader，而且依然正常运行，这就是kafka 的容错性

118. zookeeper 原子广播协议

这个协议的英文名字是 ZooKeeper Atomic Broadcast，这个协议的主要做用是保证大数据分布的一致性，经过主备方式保证副本的一致性。

119. hbase 优化 rowkey 设计

答：rowkey 的做用通常是用来检索数据用的无非有几种方式，按照某个固定的键值对进行检索，或者在必定范围内进行扫描，由于rowkey 是按照字典序存储的，因此在设计 rowkey 的时候要充分的利用这一点，把常常要查询的数据设计在一块儿，而且能够加上时间戳也是一个办法。

120. 内部表外部表的区别 hdfs 数据导入到 hive 的语法

答：首先咱们来说一下建表时的不一样，在建立内部表的时候，数据的指向会指向数仓的路径，可是在建立外部表的时候，仅仅只是记录数据的一个路径，数据不会像数仓移动，数据的位置不会改变。 咱们再讨论删除表的不一样，那就是在删除内部表的同时，元数据和数据都会被一块儿删除，而在删除外部表的时候只删除元数据并不会删除数据，相比之下外部表仍是比较灵活的。 至于从 hdfs 导入 hive 的语法我举个例子：load data inpath '/////' into table test;

121. spark 提交任务的流程

在这里我找了一个网图，相信看图来的更加直接一些。

122. cache 和 persist 的区别

答：cache 只有一个缓存级别能够设置，可是 persist 能够设置多个级别的缓存级别。

123.reduceBykey 和 groupByKey哪一个快？

固然是 reduceBykey 比较快，在到 reduce 端以前会对要传输的结果进行一个本地的 merge，这样到达 reduce端的数据就会大幅度的减小，而 groupbykey 会对每个过来的 RDD 进行一个序列化，而且这个过程是发生在 reduce 端进行执行的，因此会形成一旦数据量过大的时候会形成内存溢出等麻烦，因此建议仍是尽可能少用比较好。

124. 随便写一个算法

答：在这里我就说一下通常会用到哪些算法，至于每一个算法的 demo 你们能够自行百度一下，经常使用的有推荐算法（CB，CF），分类算法（SVM，NB），聚类算法（层次聚类，K-means），回归算法。

125. 工厂模式

答：工厂模式通常分为三种： 简单工厂模式、工厂方法模式、抽象工厂模式

126. hive on spark 了解过吗？

答：说实话 hive on spark 跟 hive 没有多大的关系，只不过 hive 一直在用MR这样在数据量庞大的时候就形成速度过慢的状况，这个时候就要将逻辑转换成 RDD 模式，这样在集群中跑的话速度明显就上来了，只不过就是继续延续了hive的标准而已。

127. udf 和 uda f写过吗？有什么区别？有一个场景，用 udf 实现一个字段自增怎么弄？

答：这块涉水比较深，建议你们对答案简单掠过就好，UDF 是自定义函数，通常是一进一出，而 UDFA 是自定义聚合函数，多进一出。 这个字段自增我就找了一个模板让你们借鉴一下，最好在面试以前本身准备一下。 import org.apache.hadoop.hive.ql.exec.Description; import org.apache.hadoop.hive.ql.exec.UDF; import org.apache.hadoop.hive.ql.udf.UDFType; import org.apache.hadoop.io.LongWritable; /* * UDF RowSequence */ @Description(name = "autosequence", value = "FUNC_() - Returns a generated row sequence number starting from 1") @UDFType(deterministic = false) public class RowSequence extends UDF { private LongWritable result = new LongWritable(); public RowSequence(){ result.set(0); } public LongWritable evaluate(){ result.set(result.get() + 1); return result; } }

128. kafka 数据落地磁盘有哪些好处？

答：一、缓存由 linux 自己进行维护 二、磁盘的顺序读写速度完胜内存读写速度 三、避免占用内存过大的状况 四、不害怕系统冷启动

129. storm 的容错机制

在这里我找了一个架构图你们先直面的看一下:

在非 nimbus 服务器有节点故障时，nimbus 会将这些 task 任务分配出去，好比 worker 挂掉时会快速失败，而且能保障消息完整性的实现机制。

130. 怎么优化 shffle

答：hashshufflemanager 能够开启 consolidate 机制、bypass 运行机制、或者修改一些参数以下 spark.shuffle.file.buffer spark.reducer.maxSizeInFlight spark.shuffle.io.maxRetries spark.shuffle.io.retryWait spark.shuffle.memoryFraction spark.shuffle.manager spark.shuffle.sort.bypassMergeThreshold spark.shuffle.consolidateFiles

131. rdd 怎么转 dataFrame

答：能够经过反射的方式来推断元数据，由于 RDD 自己是没有元数据的，经过反射就能够了解这些元数据而且进一步转换成 dtaframe

132. OOM 的缘由？

答：首先能够分析一下这个是栈溢出仍是堆溢出，而后再根据溢出类型进一步分析是什么缘由。

133. 问我 spark、jdk、scala 的版本

JDK:1.8 SPARK:2.2.0 SCALA:2.11.8 HADOOP:2.6.5

134.zookeeper 脑裂

答：脑裂就是在当只有两台 cluster 的时候，会选择一个做为 master 可是若是这两台机器存在通讯问题的话就会产生两个 master，这就是脑裂。zookeeper 通常会采用 quorums 的方式，只有当集群超过半数的时候才会投票选举出一个 master 来保障集群的可用性。

135. 多线程有几种建立方式？

一、runnable 建立 threa 线程 二、callable 建立线程 三、thread 建立线程 四、exctor 建立线程池

136. 代码怎么肯定二叉树的高度？

答：能够用后序遍历二叉树，层次遍历二叉树，递归遍历二叉树

137. 为何选择 kafka kafka 为何快

答：由于kafka是落地磁盘，顺序读取磁盘的速度要远高于内存读取。

138. spark 和 storm 的区别？

答：storm是对大量的小型数据块进行处理，而且是动态数据 spark通常是对大量数据进行进行全集处理，而且侧重传输数据的过程

139. persist 和 checkpoint 的区别

答：persits通常是将数据持久化到磁盘上可是一旦进程被停掉的话，在磁盘上的数据也会同时被清空 而checkpoint 是将 RDD 持久化到 HDFS 上的，若是不手动删除的话是一直存在的。

140. spark 和 mapreduce 的对比

答：MR 通常处理大量数据的时候通常会存在高延迟，浪费时间，对于一些有时间要求的业务就很不适合。可是若是用 spark 处理的话就很是快了，特别是对于实时动态处理的过程。

下面我会针对人事简历方面的问题总结一下个人想法

141. 对于项目问题如何写简历

答：千万不要写一堆配置信息，人家觉得你是搞运维的，而且最好写一些公司的大数据项目，以前的一些java项目就不要往上写了，而且必定要写技术细节，业务场景，业务模块，必定要写本身最熟悉的。

142. 为何要从上家公司离职？

答：千万不要说：上家公司外包太累、加班太多、领导很差，能够从技术发展的角度去谈

143. 面试完，面试官问你有什么还须要问个人问题

答：尽可能请教一些技术问题，最好在面试前就针对公司的业务介绍准备一些问题，切记千万不要问录用不录用的问题，对于指望的薪资若是技术回答的不错能够适当的多要一点，通常三年工做经验的都在 16K 以上。

144. 面试和复习问题

答：面试后回家应该立马写总结，今天问了哪些问题，哪些没有回答好，哪些问题都没听过，对应本身的简历进行修改更新。写简历就要把本身当成面试官。

145. 专业技能要有侧重点

答：对于本身熟悉的技能要有本身的侧重点，好比 spark 很熟，着重写spark的着重点，写上简历的必定要会，不然面试官可能认为你在欺骗他。

146. 是否有本身的博客，我的的技术栈

答：必定要写这一项，这一项说明你热爱技术，善于学习总结，乐于分享，而且利用本身的业余时间投入到本身的事业当中。

147. 专业技能，至少写的有层次感

答：分块写：好比 1) 按层次写 2） 好比hadoop 3） 实时计算 4） 机器学习 5） 编程语言等等

148. 简历

答：写清楚工做经历 每一个时间段，在哪一个公司工做，什么职位 项目名称： 写为 XXX公司XXX系统或平台（必须带上公司名称） 项目架构：写清楚使用到那些技术 好比 flume+kafka+hadoop+hbase+mapreduce+spark等等 整体人数：10人 项目描述：根据项目解决问题，一共有哪些功能写，功能不必定要写你都作过，由于这里只是描述 责任描述： 你负责的模块，写大的功能，不要写实现细节 解决问题：描述这个问题便可，怎么解决，面试的时候去说 项目最好设计 以 storm spark mahout 相关

149. 本身的优缺点

答：这个问题很很差回答，最好的回答就是不要回答，谈谈本身的兴趣爱好逐渐转移到技术点位上

150. 为何来某地发展

答：这个问题就是面试官想肯定你的工做态度是否稳定，也能够谈谈要在某地定居，之后就在某地发展的事。

下面咱们最后来讲一下异地灾备的问题

如今大多数的公司的数据存储都是在本地而不是异地，这样在数据和业务上就存在很大的风险，一旦本地发生火灾或者重大人员事故真实想哭都不知道怎么哭，因此在经济条件容许的条件下仍是要作异地备份。可是条件不容许怎么办，咱们能够对办公区进行数据分离，将简单的备份文件传输到不一样业务区的（除主存储）的备份机房。这个过程重中之重的就是数据的保密性，安全性，而且敏感数据最好进行数据脱敏，对于数据必定要加密存储，必定当心不要弄丢密码。

转自:https://blog.csdn.net/qq_44868502/article/details/103202702 (手动感谢)