大数据工程师面试题(四)

2.23. 我们开发job时，是否可以去掉reduce阶段。
可以。设置reduce数为0 即可。
2.24. datanode在什么情况下不会备份
datanode在强制关闭或者非正常断电不会备份。
2.25. combiner出现在那个过程
出现在map阶段的map方法后等。
2.26. hdfs的体系结构
hdfs有namenode、secondraynamenode、datanode组成。
为n+1模式
namenode负责管理datanode和记录元数据
secondraynamenode负责合并日志
datanode负责存储数据
2.27. 3个datanode中有一个datanode出现错误会怎样？
这个datanode的数据会在其他的datanode上重新做备份。
2.28. 描述一下hadoop中，有哪些地方使用了缓存机制，作用分别是什么？
在mapreduce提交job的获取id之后，会将所有文件存储到分布式缓存上，这样文件可以被所有的mapreduce共享。
2.29. 如何确定hadoop集群的健康状态
通过页面监控,脚本监控。
2.30.生产环境中为什么建议使用外部表？
1、因为外部表不会加载数据到hive，减少数据传输、数据还能共享。
2、hive不会修改数据，所以无需担心数据的损坏
3、删除表时，只删除表结构、不删除数据。
3.15期新增
3.1.新增
1）hadoop的核心配置文件名称是什么？
core-site.xml
2）“jps”命令的用处？
jps位于jdk的bin目录下，其作用是显示当前系统的java进程情况，及其id号。 jps相当于Solaris进程工具ps。不象”pgrep java”
或”ps -ef grep java”，jps并不使用应用程序名来查找JVM实例。因此，它查找所有的Java应用程序，包括即使没有使用java执行
体的那种（例如，定制的启动 器）。另外，jps仅查找当前用户的Java进程，而不是当前系统中的所有进程。
3）如何检查namenode是否正常运行？重启namenode的命令是什么？
通过节点信息和浏览器查看，通过脚本监控
hadoop-daemon.sh start namenode
hdfs-daemon.sh start namenode
4）避免namenode故障导致集群宕机的解决方法是什么？
自己书写脚本监控重启
5）hbase数据库对行键的设计要求是什么？
行健以字典序排列，设计时充分利用这个特点，将经常一起查询的行健设计在一起，例如时间戳结尾，用户名开头（位置相关性）
6）请给出你的设计方案，比如使用哪些技术框架，该框架起到的作用等。
1、用hive分析业务数据即可
2、将数据导入到hive中
sql的设计思路：多表关联
1、找到所有在2015-01-01到2015-01-31时间内访问A页面的用户
2、在这些用户中删选在2015-01-01到2015-03-31下单的用户
3、统计总数
3.2.  你们数据库怎么导入hive 的,有没有出现问题
在导入hive的时候，如果数据库中有blob或者text字段，会报错，解决方案在sqoop笔记中
在将数据由Oracle数据库导入到Hive时，发现带有clob字段的表的数据会错乱，出现一些字段全为NULL的空行。
由于在项目中CLOB字段没有实际的分析用途，因此考虑将CLOB字段去掉。
同时，为了防止CLOB字段产生一些问题，因此将HIVE中CLOB字段禁用，禁用的方式如下：
[Hadoop@master sqoop-1.4.5]$ cd $SQOOP_HOME/conf
[hadoop@master conf]$ vi oraoop-site.xml 
将以下属性的注释去掉，并且将value改为true
  <property>
    <name>oraoop.import.omit.lobs.and.long</name>
    <value>true</value>
    <description>If true, OraOop will omit BLOB, CLOB, NCLOB and LONG columns during an Import.
    </description>
  </property>
有些表中虽然有clob字段，但是不能排除掉，因为其他字段使我们所需要，因此在导入的时候采用指定--columns的方式来进行导入
sqoop import  --hive-import --hive-database  test  --create-hive-table      --connect  jdbc  --username user--password user 
--bindir //scratch  --outdir /Java  --table aaa --columns "ID,NAME"  -m 1 --null-string '\\N'  --null-non-string '\\N'
3.3.  公司技术选型可能利用storm 进行实时计算,讲解一下storm
描述下storm的设计模式，是基于work、excutor、task的方式运行代码，由spout、bolt组成等等
3.4.  一个datanode 宕机,怎么一个流程恢复
将datanode数据删除，重新当成新节点加入即可。
3.5.  Hbase 的特性,以及你怎么去设计 rowkey 和 columnFamily ,怎么去建一个table
hbase是列式数据库，rowkey是字典序的，设计时的规则同上。
每个列族是一个文件，将经常一起查询的列放到同一个列族中，减少文件的寻址时间。
3.6.  Redis,传统数据库,hbase,hive 每个之间的区别
redis：分布式缓存，强调缓存，内存中数据
传统数据库：注重关系
hbase：列式数据库，无法做关系数据库的主外键，用于存储海量数据，底层基于hdfs
hive：数据仓库工具，底层是mapreduce。不是数据库，不能用来做用户的交互存储
3.7.  shuffle 阶段,你怎么理解的
shuffle过程包括在Map和Reduce两端中。 
在Map端的shuffle过程是对Map的结果进行分区（partition）、排序（sort）和分割（spill），然后将属于同一个划分的输出合并在一起
（merge）并写在硬盘上，同时按照不同的划分将结果发送给对应的Reduce（Map输出的划分与Reduce的对应关系由JobTracker确定）。
Reduce端又会将各个Map送来的属于同一个划分的输出进行合并（merge），然后对merge的结果进行排序，最后交给Reduce处理。通俗的讲，
就是对Map输出结果先进行分区（partition），如“aaa”经过Partitioner后返回0，也就是这对值应当交由第一个reducer来处理。接下来，
需要将数据写入内存缓冲区中，缓冲区的作用是批量收集map结果，减少磁盘IO的影响。我们的key/value对以及Partition的结果都会被写
入缓冲区。当然写入之前，key与value值都会被序列化成字节数组。这个内存缓冲区是有大小限制的，默认是100MB。当map task的输出结果
很多时，需要在一定条件下将缓冲区中的数据临时写入磁盘，然后重新利用这块缓冲区。这个从内存往磁盘写数据的过程被称为Spill。
Spill可以认为是一个包括Sort和Combiner（Combiner是可选的，用户如果定义就有）的过程。先进行sort可以把缓冲区中一段范围key的数
据排在一起，（如果数据多的时候，多次刷新往内存缓冲区中写入的数据可能会有属于相同范围的key，也就是说，多个spill文件中可能会
有统一范围的key，这就是需要下面Map端merge的原因），这里有点绕，具体的介绍可以看下面的详细过程，执行过sort之后，如果用户定义

了combiner就会执行combine，然后执行merge操作，接着就是Reduce端。

3.8.  Mapreduce 的 map 数量 和 reduce 数量 怎么确定 ,怎么配置
map的数量由数据块决定，reduce数量随便配置。
3.9.  唯一难住我的是他说实时计算,storm 如果碰上了复杂逻辑,需要算很长的时间,你怎么去优化,怎么保证实时性
3.10. Hive 你们用的是外部表还是内部表,有没有写过UDF,hive 的版本
3.11. Hadoop 的版本
1.04、1.20都为稳定版，是两个常用的hadoop1版本。
3.12. 实时流式计算 的结果内容有哪些,你们需要统计出来么
3.13. 
      1）设计日志收集分析系统
      日志分布在各个业务系统中，我们需要对当天的日志进行实时汇总统计，同时又能按天查询历史的汇总数据（可以围绕PV、UV、IP等
指标进行阐述）
      1、通过flume将不同系统的日志收集到kafka中
      2、通过storm实时的处理PV、UV、IP
      3、通过kafka的consumer将日志生产到hbase中。
      4、通过离线的mapreduce或者hive，处理hbase中的数据
      2）如果你来做技术分享，你会选择什么主题，课程安排是什么样的？
      大体分为3个部分:
      1、离线hadoop技术分享（mapreduce、hive）
      2、nosql数据库hbase分享
      3、实时流计算分享
      5）Hive语句实现WordCount。
      假设数据存放在hadoop下，路径为：/home/hadoop/worddata里面全是一些单词
      1、建表
      2、分组（group by）统计wordcount
      select word,count(1) from table1 group by word;
      6）给定a、b两个文件，各存放50亿个url，每个url各占64字节，内存限制是4G，找出a、b文件共同的url？
      可以估计每个文件的大小为50亿×64=298G，远远大于内存限制的4G。所以不可能将其完全加载到内存中处理。考虑采取分而治之的方法。
      1、将文件存储到hdfs中，这样每个文件为64M或者是128M
      2、分别对两个文件的url进行去重、排序输出，这样能排除a文件中相同的url，b文件也一样
      3、对a、b两个文件处理后的结果进行wordcount，并且在reduce中判断单词个数，个数为2的时候输出，这样就找到了a、b文件中的相同url。
      4、此计算步骤中的每一步加载到内存中的文件大小都不会超过64M，远远小于4G。
      7）一亿个数据获取前100个最大值（步骤及算法复杂度）
      两种思路：
      1. 根据快速排序划分的思想 
      a. 假设数组为 array[N] (N = 1 亿)，首先利用quicksort的原理把array分成两个部分，左边部分比 array[N - 1] (array中的最后一个值，
即pivot) 大， 右边部分比pivot 小。然后，可以得到 array[array.length - 1] (即 pivot) 在整个数组中的位置，假设是 k.
      b. 如果 k 比 99 大，我们在数组[0, k - 1]里找前 100 最大值。 （继续递归）
      c. 如果 k 比 99 小， 我们在数组[k + 1, ..., N ]里找前 100 - (k + 1) 最大值。（继续递归）
      d. 如果 k == 99, 那么数组的前 100 个值一定是最大的。（退出）
      2.先取出前100个数，维护一个100个数的最小堆，遍历一遍剩余的元素，在此过程中维护堆就可以了。具体步骤如下： 
      step1：取前m个元素（例如m=100），建立一个小顶堆。保持一个小顶堆得性质的步骤，运行时间为O（lgm);建立一个小顶堆运行时间为m*O（lgm）=O(m lgm);       
      step2:顺序读取后续元素，直到结束。每次读取一个元素，如果该元素比堆顶元素小，直接丢弃 
      如果大于堆顶元素，则用该元素替换堆顶元素，然后保持最小堆性质。最坏情况是每次都需要替换掉堆顶的最小元素，因此需要维护堆的代价为(N-m)*O(lgm); 
      最后这个堆中的元素就是前最大的10W个。时间复杂度为O(N lgm）。 
      两种思路比较：
      基于最小堆方法运行时间很稳定（每次运行时间相差很小），基于quicksort原理的方法运行时间不稳定（每次运行时间相差大）。
Random rand = new Random(); PriorityQueue<Integer> P = new PriorityQueue<Integer>(); for(int i = 0,num = rand.nextInt(); (i < 100 && P.add(num)) || (i < 100000000 && (P.peek() < num && P.add(num) && P.remove() != null || 1==1));
 i++,num = rand.nextInt()); //System.out.println(P);
top K问题
        在大规模数据处理中，经常会遇到的一类问题：在海量数据中找出出现频率最好的前k个数，或者从海量数据中找出最大的前k个数，这类问题通常被称为top K问题。例如，在搜索引擎中，
统计搜索最热门的10个查询词；在歌曲库中统计下载最高的前10首歌等。
        针对top K类问题，通常比较好的方案是分治+Trie树/hash+小顶堆（就是上面提到的最小堆），即先将数据集按照Hash方法分解成多个小数据集，
然后使用Trie树活着Hash统计每个小数据集中的query词频，之后用小顶堆求出每个数据集中出现频率最高的前K个数，最后在所有top K中求出最终的top K。
eg：有1亿个浮点数，如果找出期中最大的10000个？
        最容易想到的方法是将数据全部排序，然后在排序后的集合中进行查找，最快的排序算法的时间复杂度一般为O（nlogn），如快速排序。但是在32位的机器上，
每个float类型占4个字节，1亿个浮点数就要占用400MB的存储空间，对于一些可用内存小于400M的计算机而言，很显然是不能一次将全部数据读入内存进行排序的。
其实即使内存能够满足要求（我机器内存都是8GB），该方法也并不高效，因为题目的目的是寻找出最大的10000个数即可，而排序却是将所有的元素都排序了，做了很多的无用功。
        第二种方法为局部淘汰法，该方法与排序方法类似，用一个容器保存前10000个数，然后将剩余的所有数字——与容器内的最小数字相比，如果所有后续的元素都比容器内的10000个数还小，
那么容器内这个10000个数就是最大10000个数。如果某一后续元素比容器内最小数字大，则删掉容器内最小元素，并将该元素插入容器，最后遍历完这1亿个数，
得到的结果容器中保存的数即为最终结果了。此时的时间复杂度为O（n+m^2），其中m为容器的大小，即10000。
        第三种方法是分治法，将1亿个数据分成100份，每份100万个数据，找到每份数据中最大的10000个，最后在剩下的100*10000个数据里面找出最大的10000个。如果100万数据选择足够理想，
那么可以过滤掉1亿数据里面99%的数据。100万个数据里面查找最大的10000个数据的方法如下：用快速排序的方法，将数据分为2堆，如果大的那堆个数N大于10000个，
继续对大堆快速排序一次分成2堆，如果大的那堆个数N大于10000个，继续对大堆快速排序一次分成2堆，如果大堆个数N小于10000个，就在小的那堆里面快速排序一次，找第10000-n大的数字；
递归以上过程，就可以找到第1w大的数。参考上面的找出第1w大数字，就可以类似的方法找到前10000大数字了。此种方法需要每次的内存空间为10^6*4=4MB，一共需要101次这样的比较。
        第四种方法是Hash法。如果这1亿个书里面有很多重复的数，先通过Hash法，把这1亿个数字去重复，这样如果重复率很高的话，会减少很大的内存用量，从而缩小运算空间，
然后通过分治法或最小堆法查找最大的10000个数。
        第五种方法采用最小堆。首先读入前10000个数来创建大小为10000的最小堆，建堆的时间复杂度为O（mlogm）（m为数组的大小即为10000），然后遍历后续的数字，并于堆顶（最小）
数字进行比较。如果比最小的数小，则继续读取后续数字；如果比堆顶数字大，则替换堆顶元素并重新调整堆为最小堆。整个过程直至1亿个数全部遍历完为止。然后按照中序遍历的方式输出当前
堆中的所有10000个数字。该算法的时间复杂度为O（nmlogm），空间复杂度是10000（常数）。
实际运行：
        实际上，最优的解决方案应该是最符合实际设计需求的方案，在时间应用中，可能有足够大的内存，那么直接将数据扔到内存中一次性处理即可，也可能机器有多个核，这样可以采用
多线程处理整个数据集。
       下面针对不容的应用场景，分析了适合相应应用场景的解决方案。
（1）单机+单核+足够大内存
        如果需要查找10亿个查询次（每个占8B）中出现频率最高的10个，考虑到每个查询词占8B，则10亿个查询次所需的内存大约是10^9 * 8B=8GB内存。如果有这么大内存，直接在内存中对
查询次进行排序，顺序遍历找出10个出现频率最大的即可。这种方法简单快速，使用。然后，也可以先用HashMap求出每个词出现的频率，然后求出频率最大的10个词。
（2）单机+多核+足够大内存
        这时可以直接在内存总使用Hash方法将数据划分成n个partition，每个partition交给一个线程处理，线程的处理逻辑同（1）类似，最后一个线程将结果归并。
        该方法存在一个瓶颈会明显影响效率，即数据倾斜。每个线程的处理速度可能不同，快的线程需要等待慢的线程，最终的处理速度取决于慢的线程。而针对此问题，解决的方法是，
将数据划分成c×n个partition（c>1），每个线程处理完当前partition后主动取下一个partition继续处理，知道所有数据处理完毕，最后由一个线程进行归并。
（3）单机+单核+受限内存
        这种情况下，需要将原数据文件切割成一个一个小文件，如次啊用hash(x)%M，将原文件中的数据切割成M小文件，如果小文件仍大于内存大小，继续采用Hash的方法对数据文件进行分割，
知道每个小文件小于内存大小，这样每个文件可放到内存中处理。采用（1）的方法依次处理每个小文件。
（4）多机+受限内存
        这种情况，为了合理利用多台机器的资源，可将数据分发到多台机器上，每台机器采用（3）中的策略解决本地的数据。可采用hash+socket方法进行数据分发。
        从实际应用的角度考虑，（1）（2）（3）（4）方案并不可行，因为在大规模数据处理环境下，作业效率并不是首要考虑的问题，算法的扩展性和容错性才是首要考虑的。
算法应该具有良好的扩展性，以便数据量进一步加大（随着业务的发展，数据量加大是必然的）时，在不修改算法框架的前提下，可达到近似的线性比；算法应该具有容错性，
即当前某个文件处理失败后，能自动将其交给另外一个线程继续处理，而不是从头开始处理。
        top K问题很适合采用MapReduce框架解决，用户只需编写一个Map函数和两个Reduce 函数，然后提交到Hadoop（采用Mapchain和Reducechain）上即可解决该问题。
具体而言，就是首先根据数据值或者把数据hash(MD5)后的值按照范围划分到不同的机器上，最好可以让数据划分后一次读入内存，这样不同的机器负责处理不同的数值范围，
实际上就是Map。得到结果后，各个机器只需拿出各自出现次数最多的前N个数据，然后汇总，选出所有的数据中出现次数最多的前N个数据，这实际上就是Reduce过程。
对于Map函数，采用Hash算法，将Hash值相同的数据交给同一个Reduce task；对于第一个Reduce函数，采用HashMap统计出每个词出现的频率，对于第二个Reduce 函数，统计所有Reduce task，
输出数据中的top K即可。
        直接将数据均分到不同的机器上进行处理是无法得到正确的结果的。因为一个数据可能被均分到不同的机器上，而另一个则可能完全聚集到一个机器上，同时还可能存在具有相同数目的数据。
以下是一些经常被提及的该类问题。
（1）有10000000个记录，这些查询串的重复度比较高，如果除去重复后，不超过3000000个。一个查询串的重复度越高，说明查询它的用户越多，也就是越热门。请统计最热门的10个查询串，
要求使用的内存不能超过1GB。
（2）有10个文件，每个文件1GB，每个文件的每一行存放的都是用户的query，每个文件的query都可能重复。按照query的频度排序。
（3）有一个1GB大小的文件，里面的每一行是一个词，词的大小不超过16个字节，内存限制大小是1MB。返回频数最高的100个词。
（4）提取某日访问网站次数最多的那个IP。
（5）10亿个整数找出重复次数最多的100个整数。
（6）搜索的输入信息是一个字符串，统计300万条输入信息中最热门的前10条，每次输入的一个字符串为不超过255B，内存使用只有1GB。
（7）有1000万个身份证号以及他们对应的数据，身份证号可能重复，找出出现次数最多的身份证号。
重复问题
        在海量数据中查找出重复出现的元素或者去除重复出现的元素也是常考的问题。针对此类问题，一般可以通过位图法实现。例如，已知某个文件内包含一些电话号码，每个号码为8位数字，
统计不同号码的个数。
        本题最好的解决方法是通过使用位图法来实现。8位整数可以表示的最大十进制数值为99999999。如果每个数字对应于位图中一个bit位，那么存储8位整数大约需要99MB。因为1B=8bit，
所以99Mbit折合成内存为99/8=12.375MB的内存，即可以只用12.375MB的内存表示所有的8位数电话号码的内容。
      8）实时数据统计会用到哪些技术，它们各自的应用场景及区别是什么？
      flume：日志收集系统，主要用于系统日志的收集
      kafka：消息队列，进行消息的缓存和系统的解耦
      storm：实时计算框架，进行流式的计算。
      1）String和StringBuffer的区别，StringBuffer与StringBuilder的区别
      简单地说，就是一个变量和常量的关系。StringBuffer对象的内容可以修改；而String对象一旦产生后就不可以被修改，重新赋值其实是两个对象。
      StringBuilder：线程非安全的
      StringBuffer：线程安全的
　　  当我们在字符串缓冲去被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。
当然大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的，就是速度的原因。