大数据hadoop 面试经典题

1.从前到后从你教育背景(学过哪些课)到各个项目你负责的模块,问的很细(本以为他是物理学博士,但是所有的技术都懂)
2.hadoop 的 namenode 宕机,怎么解决
先分析宕机后的损失，宕机后直接导致client无法访问，内存中的元数据丢失，但是硬盘中的元数据应该还存在，如果只是节点挂了，
重启即可，如果是机器挂了，重启机器后看节点是否能重启，不能重启就要找到原因修复了。但是最终的解决方案应该是在设计集群的初期
就考虑到这个问题，做namenode的HA。
3.一个datanode 宕机,怎么一个流程恢复
Datanode宕机了后，如果是短暂的宕机，可以实现写好脚本监控，将它启动起来。如果是长时间宕机了，那么datanode上的数据应该已经
被备份到其他机器了，那这台datanode就是一台新的datanode了，删除他的所有数据文件和状态文件，重新启动。
4.Hbase 的特性,以及你怎么去设计 rowkey 和 columnFamily ,怎么去建一个table
因为hbase是列式数据库，列非表schema的一部分，所以在设计初期只需要考虑rowkey 和 columnFamily即可，rowkey有位置相关性，所以
如果数据是练习查询的，最好对同类数据加一个前缀，而每个columnFamily实际上在底层是一个文件，那么文件越小，查询越快，所以讲经
常一起查询的列设计到一个列簇，但是列簇不宜过多。
5.Redis,传统数据库,hbase,hive 每个之间的区别(问的非常细)
Redis是缓存，围绕着内存和缓存说
Hbase是列式数据库，存在hdfs上，围绕着数据量来说
Hive是数据仓库，是用来分析数据的，不是增删改查数据的。
6.公司之后倾向用spark 开发,你会么(就用java代码去写)
会，spark使用scala开发的，在scala中可以随意使用jdk的类库，可以用java开发，但是最好用原生的scala开发，兼容性好，scala更灵活。

10. 面试问题:
1.笔试: java基础(基本全忘,做的很烂,复习大数据连单例都忘了怎么写)
复习java面试宝典
2.开始介绍项目,直接用大数据项目介绍,项目经理也懂大数据
3.Mapreduce 一些流程,经过哪些步骤
Map—combiner—partition—sort—copy—sort—grouping—reduce
4.说下对hadoop 的一些理解,包括哪些组件
详谈hadoop的应用，包括的组件分为三类，分别说明hdfs，yarn，mapreduce
5.详细讲解下你流式实时计算的项目部署以及收集的结果情况
讲解storm集群的部署方案，项目的大小，使用的worker数，数据收集在hbase或者hdfs，好处是什么
6.你的数据库是不是很大么,有没有分表,分区,你是怎么实现的
数据库的分表在设计初期是按照月份进行拆分的，不同的月份查询不同的表。分区没弄过。
7.开始问java的一些东西(从各种框架原理到各种复杂SQL)
8.多线程,并发,垃圾回收机制,数据结构(问这些,基本觉得看你是不是高级程序员了)
多线程要知道操作方式，线程安全的锁，并且要知道lock锁
垃圾回收机制需要详细了解（见云笔记），主要从内存划分，垃圾回收主要的工作区域，垃圾回收器的种类，各有什么优缺点，
用在哪里合适。
数据结构基本的要知道，复杂的参考相关的书籍。

11. 面试问题:
1.BI小组的3个年轻学生一起技术面试(一个是南开博士）
2.数据量多少,集群规模多大,型号
一般中型的电商或者互联网企业，日志量每天在200-500M左右，集群规模在30-50台左右，机器一般为dell的2000左右的服务器，型号不定
大型的互联网公司据网上资料显示，日志量在GP-PB不等，集群规模在500-4000不等，甚至更多，机器型号不确定。
3.项目,mapreduce
介绍整个mapreduce项目流程，数据采集—数据聚合—数据分析—数据展示等
4.实时流式计算框架,几个人,多长时间,细节问题,包括讲flume ,kafka ,storm 的各个的组件组成,你负责那一块,如果需要你搭建你可以
完成么?
5.你觉得spark 可以完全替代hadoop 么? 

12. 面试问题:
1.一些传统的hadoop 问题,mapreduce 他就问shuffle 阶段,你怎么理解的
Shuffle意义在于将不同map处理后的数据进行合理分配，让reduce处理，从而产生了排序、分区。
2.Mapreduce 的 map 数量 和 reduce 数量 怎么确定 ,怎么配置
Map无法配置，reduce随便配置
3.唯一难住我的是他说实时计算,storm 如果碰上了复杂逻辑,需要算很长的时间,你怎么去优化
拆分复杂的业务到多个bolt中，这样可以利用bolt的tree将速度提升
4.Hive 你们用的是外部表还是内部表,有没有写过UDF(当然吹自己写过了),hive 的版本
外部表，udf，udaf等，hive版本为1.0
5.Hadoop 的版本 
如果是1.0版本就说1.2，如果是2.0版本，就说2.6或者2.7
1.2为官方稳定版本，2.7为官方稳定版本。
Apache Hadoop 2.7.1于美国时间2015年07月06日正式发布，本版本属于稳定版本，是自Hadoop 2.6.0以来又一个稳定版，同时也是
Hadoop 2.7.x版本线的第一个稳定版本，也是 2.7版本线的维护版本，变化不大，主要是修复了一些比较严重的Bug
6.实时流式计算的结果内容有哪些,你们需要统计出来么(我就说highchart展示)
简单介绍日志监控、风控等结果内容，统计出来显示在报表或者邮件中。
7.开始问java相关,包括luecne,solr(倒排索引的原理),框架呀,redis呀

扫描二维码关注公众号，回复： 9494134 查看本文章

13. 京东商城 - 大数据
 

（1）Java篇
1、JVM，GC（算法，新生代，老年代），JVM结构
2、hashcode，hashMap，list，hashSet，equals（结构原理），A extends  B（类的加载顺序）
1.父类静态代码块；
2.子类静态代码块；
3.父类非静态代码块；
4.父类构造函数；
5.子类非静态代码块；
6.子类构造函数；
3、多线程，主线程，次线程，唤醒，睡眠
略
4、常见算法：冒泡算法，排序算法，二分查找，时间复杂度
略
（2）Flume篇
1、数据怎么采集到Kafka，实现方式
使用官方提供的flumeKafka插件，插件的实现方式是自定义了flume的sink，将数据从channle中取出，通过kafka的producer写入到kafka中，
可以自定义分区等。
2、flume管道内存，flume宕机了数据丢失怎么解决
1、Flume的channel分为很多种，可以将数据写入到文件
2、防止非首个agent宕机的方法数可以做集群或者主备
3、flume配置方式，flume集群（问的很详细）
Flume的配置围绕着source、channel、sink叙述，flume的集群是做在agent上的，而非机器上。
4、flume不采集Nginx日志，通过Logger4j采集日志，优缺点是什么？
优点：Nginx的日志格式是固定的，但是缺少sessionid，通过logger4j采集的日志是带有sessionid的，而session可以通过redis共享，
保证了集群日志中的同一session落到不同的tomcat时，sessionId还是一样的，而且logger4j的方式比较稳定，不会宕机。
缺点：不够灵活，logger4j的方式和项目结合过于紧密，而flume的方式比较灵活，拔插式比较好，不会影响项目性能。
5、flume和kafka采集日志区别，采集日志时中间停了，怎么记录之前的日志。
Flume采集日志是通过流的方式直接将日志收集到存储层，而kafka试讲日志缓存在kafka集群，待后期可以采集到存储层。
Flume采集中间停了，可以采用文件的方式记录之前的日志，而kafka是采用offset的方式记录之前的日志。
（3）Kafka篇
1、容错机制
分区备份，存在主备partition
2、同一topic不同partition分区
？？？？
3、kafka数据流向
Producer  leader partition  follower partition(半数以上) consumer
4、kafka+spark-streaming结合丢数据怎么解决？

spark streaming从1.2开始提供了数据的零丢失，想享受这个特性，需要满足如下条件：

1. 数据输入需要可靠的sources和可靠的receivers

2. 应用metadata必须通过应用driver checkpoint

3. WAL（write ahead log）

1.1. 可靠的sources和receivers

spark streaming可以通过多种方式作为数据sources（包括kafka），输入数据通过receivers接收，通过replication存储于spark中（为了faultolerance，默认复制到两个spark executors），如果数据复制完成，receivers可以知道（例如kafka中更新offsets到zookeeper中）。这样当receivers在接收数据过程中crash掉，不会有数据丢失，receivers没有复制的数据，当receiver恢复后重新接收。

1.2. metadata checkpoint

可靠的sources和receivers，可以使数据在receivers失败后恢复，然而在driver失败后恢复是比较复杂的，一种方法是通过checkpoint metadata到HDFS或者S3。metadata包括：

· configuration

· code

· 一些排队等待处理但没有完成的RDD（仅仅是metadata，而不是data）

这样当driver失败时，可以通过metadata checkpoint，重构应用程序并知道执行到那个地方。

1.3. 数据可能丢失的场景

可靠的sources和receivers，以及metadata checkpoint也不可以保证数据的不丢失，例如：

· 两个executor得到计算数据，并保存在他们的内存中

· receivers知道数据已经输入

· executors开始计算数据

· driver突然失败

· driver失败，那么executors都会被kill掉

· 因为executor被kill掉，那么他们内存中得数据都会丢失，但是这些数据不再被处理

· executor中的数据不可恢复

1.4. WAL

为了避免上面情景的出现，spark streaming 1.2引入了WAL。所有接收的数据通过receivers写入HDFS或者S3中checkpoint目录，这样当driver失败后，executor中数据丢失后，可以通过checkpoint恢复。

1.5. At-Least-Once

尽管WAL可以保证数据零丢失，但是不能保证exactly-once，例如下面场景：

· Receivers接收完数据并保存到HDFS或S3

· 在更新offset前，receivers失败了

· Spark Streaming以为数据接收成功，但是Kafka以为数据没有接收成功，因为offset没有更新到zookeeper

· 随后receiver恢复了

· 从WAL可以读取的数据重新消费一次，因为使用的kafka High-Level消费API，从zookeeper中保存的offsets开始消费

1.6. WAL的缺点

通过上面描述，WAL有两个缺点：

· 降低了receivers的性能，因为数据还要存储到HDFS等分布式文件系统

· 对于一些resources，可能存在重复的数据，比如Kafka，在Kafka中存在一份数据，在Spark Streaming也存在一份（以WAL的形式存储在hadoop API兼容的文件系统中）

1.7. Kafka direct API

为了WAL的性能损失和exactly-once，spark streaming1.3中使用Kafka direct API。非常巧妙，Spark driver计算下个batch的offsets，指导executor消费对应的topics和partitions。消费Kafka消息，就像消费文件系统文件一样。

1. 不再需要kafka receivers，executor直接通过Kafka API消费数据

2. WAL不再需要，如果从失败恢复，可以重新消费

3. exactly-once得到了保证，不会再从WAL中重复读取数据

1.8. 总结

主要说的是spark streaming通过各种方式来保证数据不丢失，并保证exactly-once，每个版本都是spark streaming越来越稳定，越来越向生产环境使用发展。

5、kafka中存储目录data/dir.....topic1和topic2怎么存储的，存储结构，data.....目录下有多少个分区，每个分区的存储格式是什么样的？
1、topic是按照“主题名-分区”存储的
2、分区个数由配置文件决定
3、每个分区下最重要的两个文件是0000000000.log和000000.index，0000000.log以默认1G大小回滚。
（4）Hive篇
1、hive partition分区
分区表，动态分区
2、insert into 和 override write区别？
insert into：将某一张表中的数据写到另一张表中
override write：覆盖之前的内容。
3、假如一个分区的数据主部错误怎么通过hivesql删除hdfs
alter table ptable drop partition (daytime='20140911',city='bj');
元数据，数据文件都删除，但目录daytime= 20140911还在
（5）Storm篇         
 1、开发流程，容错机制
开发流程：
1、写主类（设计spout和bolt的分发机制）
2、写spout收集数据
3、写bolt处理数据，根据数据量和业务的复杂程度，设计并行度。
容错机制：采用ack和fail进行容错，失败的数据重新发送。
2、storm和spark-streaming：为什么用storm不同spark-streaming
3、mr和spark区别，怎么理解spark-rdd
Mr是文件方式的分布式计算框架，是将中间结果和最终结果记录在文件中，map和reduce的数据分发也是在文件中。
spark是内存迭代式的计算框架，计算的中间结果可以缓存内存，也可以缓存硬盘，但是不是每一步计算都需要缓存的。
Spark-rdd是一个数据的分区记录集合………………

4、sqoop命令

sqoop import --connect jdbc:mysql://192.168.56.204:3306/sqoop --username hive --password hive --table jobinfo --target-dir /sqoop/test7 --inline-lob-limit 16777216 --fields-terminated-by '\t' -m 2

sqoop create-hive-table --connect jdbc:mysql://192.168.56.204:3306/sqoop --table jobinfo --username hive --password hive --hive-table sqtest --fields-terminated-by "\t" --lines-terminated-by "\n";

（6）Redis篇
1、基本操作，存储格式
略
（7）Mysql篇
1、mysql集群的分布式事务
京东自主开发分布式MYSQL集群系统
2、mysql性能优化（数据方面）
数据的分表、分库、分区
（6）Hadoop篇
1、hadoop HA  两个namenode和zk之间的通信，zk的选举机制？
HA是通过先后获取zk的锁决定谁是主
Zk的选举机制，涉及到全新机群的选主和数据恢复的选主

2、mr运行机制

3、yarn流程

1) 用户向YARN 中提交应用程序， 其中包括ApplicationMaster 程序、启动ApplicationMaster 的命令、用户程序等。
2) ResourceManager 为该应用程序分配第一个Container， 并与对应的NodeManager 通信，要求它在这个Container 中启动应用程序
的ApplicationMaster。
3) ApplicationMaster 首先向ResourceManager 注册， 这样用户可以直接通过ResourceManage 查看应用程序的运行状态，然后它将
为各个任务申请资源，并监控它的运行状态，直到运行结束，即重复步骤4~7。
4) ApplicationMaster 采用轮询的方式通过RPC 协议向ResourceManager 申请和领取资源。
5) 一旦ApplicationMaster 申请到资源后，便与对应的NodeManager 通信，要求它启动任务。
6) NodeManager 为任务设置好运行环境（包括环境变量、JAR 包、二进制程序等）后，将任务启动命令写到一个脚本中，并通过运行
该脚本启动任务。
7) 各个任务通过某个RPC 协议向ApplicationMaster 汇报自己的状态和进度，以让ApplicationMaster 随时掌握各个任务的运行状态，
从而可以在任务失败时重新启动任务。在应用程序运行过程中，用户可随时通过RPC 向ApplicationMaster 查询应用程序的当前运行状态。
8) 应用程序运行完成后，ApplicationMaster 向ResourceManager 注销并关闭自己。
（7）Hbase
1、涉及到概念，文档
（8）Spark篇
1、spark原理  

Spark应用转换流程

1、 spark应用提交后，经历了一系列的转换，最后成为task在每个节点上执行

2、 RDD的Action算子触发Job的提交，生成RDD DAG

3、 由DAGScheduler将RDD DAG转化为Stage DAG，每个Stage中产生相应的Task集合

4、 TaskScheduler将任务分发到Executor执行

5、 每个任务对应相应的一个数据块，只用用户定义的函数处理数据块

Driver运行在Worker上

   通过org.apache.spark.deploy.Client类执行作业，作业运行命令如下：

作业执行流程描述：

1、客户端提交作业给Master

2、Master让一个Worker启动Driver，即SchedulerBackend。Worker创建一个DriverRunner线程，DriverRunner启动SchedulerBackend进程。

3、另外Master还会让其余Worker启动Exeuctor，即ExecutorBackend。Worker创建一个ExecutorRunner线程，ExecutorRunner会启动ExecutorBackend进程。

4、ExecutorBackend启动后会向Driver的SchedulerBackend注册。SchedulerBackend进程中包含DAGScheduler，它会根据用户程序，生成执行计划，并调度执行。对于每个stage的task，都会被存放到TaskScheduler中，ExecutorBackend向SchedulerBackend汇报的时候把TaskScheduler中的task调度到ExecutorBackend执行。

5、所有stage都完成后作业结束。

Driver运行在客户端

作业执行流程描述：

1、客户端启动后直接运行用户程序，启动Driver相关的工作：DAGScheduler和BlockManagerMaster等。

2、客户端的Driver向Master注册。

3、Master还会让Worker启动Exeuctor。Worker创建一个ExecutorRunner线程，ExecutorRunner会启动ExecutorBackend进程。

4、ExecutorBackend启动后会向Driver的SchedulerBackend注册。Driver的DAGScheduler解析作业并生成相应的Stage，每个Stage包含的Task通过TaskScheduler分配给Executor执行。

5、所有stage都完成后作业结束。

 
1.在Hadoop中定义的主要公用InputFormat中，默认是哪一个？（A）
 

A、 TextInputFormat

B、 KeyValueInputFormat

C、 SequenceFileInputFormat

1. 下面哪个程序负责 HDFS 数据存储？（C）
 

A.NameNode

B.JobTracker

C.DataNode

D.SecondaryNameNode

E.tasktracker

2.HDFS 中的 block 默认保存几份？（A）
 

A.3 份

B.2 份

C.1 份

D.不确定

3.下列哪个程序通常与 NameNode 在一个节点启动？（D）
 

A.SecondaryNameNode

B.DataNode

C.TaskTracker

D.JobTracker

hadoop的集群是基于master/slave模式，namenode和jobtracker属于master，datanode和tasktracker属于slave，master只有一个，而slave有多个.

SecondaryNameNode内存需求和NameNode在一个数量级上，所以通常secondary NameNode（运行在单独的物理机器上）和 NameNode 运行在不同的机器上。

JobTracker对应于NameNode,TaskTracker对应于DataNode.

DataNode和NameNode是针对数据存放来而言的.JobTracker和TaskTracker是对于MapReduce执行而言的.

mapreduce中几个主要概念，mapreduce 整体上可以分为这么几条执行线索：

jobclient，JobTracker与TaskTracker。

1、JobClient会在用户端通过JobClient类将已经配置参数打包成jar文件的应用存储到hdfs，并把路径提交到Jobtracker,然后由JobTracker创建每一个Task（即 MapTask 和 ReduceTask） 并将它们分发到各个TaskTracker服务中去执行。

2、JobTracker是一master服务，软件启动之后JobTracker接收Job，负责调度Job的每一个子任务。task运行于TaskTracker上，并监控它们，如果发现有失败的task就重新运行它。一般情况应该把JobTracker 部署在单独的机器上。

3、TaskTracker是运行在多个节点上的slaver服务。TaskTracker主动与JobTracker通信，接收作业，并负责直接执行每一个任务。 TaskTracker 都需要运行在HDFS的DataNode上。

4.关于 SecondaryNameNode 哪项是正确的？（C）
 

A.它是 NameNode 的热备

B.它是内存没有要求

C.他的目的使帮助 NameNode 合并编辑日志，减少 NameNode 启动时间

D. SecondaryNameNode 应与 NameNode 部署到一个节点

HDFS 默认 BlockSize 是2.0版本128M，之前低版本64M。
 

下列哪项通常是集群的最主要瓶颈（C）
A.CPU

B.网络

C.磁盘 IO

D.内存

1. 下列哪项可以作为集群的管理？（ABC）
 

A.Puppet

B.Pdsh

C.ClouderaManager

D.Zookeeper

2.Client 端上传文件的时候下列哪项正确？（BC）
 

A.数据经过 NameNode 传递 DataNode

B.Client 端将文件切分为 Block，依次上传

C.Client 只上传数据到一台 DataNode，然后由 NameNode 负责 Block 复制工作

3.下列哪个是 Hadoop 运行的模式？（ABC）
 

A.单机版

B.伪分布式

C.分布式

1.列举几个hadoop生态圈的组件并做简要描述
 

Zookeeper:是一个开源的分布式应用程序协调服务,基于zookeeper可以实现同步服务，配置维护，命名服务。

Flume:一个高可用的，高可靠的，分布式的海量日志采集、聚合和传输的系统。

Hbase:是一个分布式的、面向列的开源数据库, 利用Hadoop HDFS作为其存储系统.

Hive:基于Hadoop的一个数据仓库工具，可以将结构化的数据档映射为一张数据库表，并提供简单的sql 查询功能，可以将sql语句转换为MapReduce任务进行运行。

Sqoop:将一个关系型数据库中的数据导进到Hadoop的 HDFS中，也可以将HDFS的数据导进到关系型数据库中。

Hadoop中需要哪些配置文件，其作用是什么？
 

1>.Core-site.xml：

(1)fs.defaultFS:hdfs://cluster1(域名)，这里的值指的是默认的HDFS路径 。

(2)hadoop.tmp.dir:/export/data/hadoop_tmp,这里的路径默认是NameNode、DataNode、JournalNode等存放数据的公共目录。用户也可以自己单独指定这三类节点的目录。

(3)ha.zookeeper.quorum:hadoop101:2181,hadoop102:2181,hadoop103:2181,这里是ZooKeeper集群的地址和端口。注意，数量一定是奇数，且不少于三个节点 。

2>.Hadoop-env.sh: 只需设置jdk的安装路径，如：export JAVA_HOME=/usr/local/jdk 本机j位置 

3>.Hdfs-site.xml：

(1) dfs.replication:他决定着系统里面的文件块的数据备份个数，默认为3个。

(2) dfs.data.dir:datanode节点存储在文件系统的目录 。

(3) dfs.name.dir:是namenode节点存储hadoop文件系统信息的本地系统路径 。

4>.Mapred-site.xml：

(1)mapred.job.tracker:是jobtracker的主机和端口配置 。

4. 请列出正常工作的Hadoop集群中Hadoop都分别需要启动哪些进程，它们的作用分别是什么?
 

a) NameNode它是hadoop中的主服务器，管理文件系统名称空间和对集群中存储的文件的访问，保存有 metadate.

b).SecondaryNameNode它不是namenode的冗余守护进程，而是提供周期检查点和清理任务。帮助NN合并editslog，减少NN启动时间。

c)DataNode它负责管理连接到节点的存储（一个集群中可以有多个节点）。每个存

储数据的节点运行一个datanode守护进程。

d)ResourceManager（JobTracker）JobTracker负责调度DataNode上的工作。每个DataNode有一个TaskTracker，它们执行实际工作。

e) NodeManager（TaskTracker）执行任务

f) DFSZKFailoverController高可用时它负责监控NN的状态，并及时的把状态信息写入ZK。它通过一个独立线程周期性的调用NN上的一个特定接口来获取NN的健康状态。FC也有选择谁作为Active NN的权利，因为最多只有两个节点，目前选择策略还比较简单（先到先得，轮换）。

g) JournalNode 高可用情况下存放namenode的editlog文件.

HDFS数据写入实现机制
3. HDFS的存储机制？

写入HDFS过程：

Client调用DistributedFileSystem对象的create方法，创建一个文件输出流（FSDataOutputStream）对象，通过DistributedFileSystem对象与Hadoop集群的NameNode进行一次RPC远程调用，在HDFS的Namespace中创建一个文件条目（Entry），该条目没有任何的Block，通过FSDataOutputStream对象，向DataNode写入数据，数据首先被写入FSDataOutputStream对象内部的Buffer中，然后数据被分割成一个个Packet数据包，以Packet最小单位，基于Socket连接发送到按特定算法选择的HDFS集群中一组DataNode（正常是3个，可能大于等于1）中的一个节点上，在这组DataNode组成的 Pipeline上依次传输 Packet， 这组 DataNode 组成的 Pipeline反方向上，发送 ack，最终由 Pipeline 中第一个 DataNode 节点将 Pipeline ack发送给Client，完成向文件写入数据，Client 在文件输出流（FSDataOutputStream）对象上调用close方法，关闭流.调用DistributedFileSystem对象的complete 方法，通知 NameNode 文件写入成功.

读取文件过程：

使用HDFS提供的客户端开发库Client，向远程的Namenode发起RPC请求；Namenode会视情况返回文件的部分或全部block列表，对于每个block，Namenode都会返回有该block拷贝的DataNode地址；客户端开发库Client会选取离客户端最接近的DataNode来读取block；如果客户端本身就是DataNode,那么将从本地直接获取数据.读取完当前block的数据后，关闭与当前的DataNode连接，并为读取下一个block寻找最佳的DataNode；当读完列表的block后，且文件读取还没有结束，客户端开发库会继续向Namenode获取下一批的block列表。读取完一个block都会进行 checksum 验证，如果读取 datanode 时出现错误，客户端会通知 Namenode，然后再从下一个拥有该 block 拷贝的 datanode 继续读。

2.HDFS的存储机制是什么
 

客户端通过把请求发送给NameNode active，NN会把文件切成1个到N个固定大小的block（一般默认为128M）并上传到DN中。当所有block拷贝结束时，NN会立即通知客户端上传结果。但此时上传的流程还未结束。DN还需要根据配置信息的副本数量，在不同的机架节点上通过局域网作数据拷贝工作。

6Hadoop 是由哪几个组件组成

hadoop 是一套处理大数据的生态系统，包括文件存储HDFS ，计算框架MapReduce调度框架Yarn，数据库Hbase ，数据仓库Hive，协调与锁服务zookeeper，关系型数 据库与Hbase转换工具sqoop，工作流模块Oozie,机器学习模块mahout.

1.6 hadoop 节点动态上线下线怎么操作?
 

节点上线操作：

当要新上线数据节点的时候，需要把数据节点的名字追加在 dfs.hosts 文件中

一，关闭新增节点的防火墙

二，在 NameNode 节点的 hosts 文件中加入新增数据节点的 hostname

三，在每个新增数据节点的 hosts 文件中加入 NameNode 的 hostname

四，在 NameNode 节点上增加新增节点的 SSH 免密码登录的操作

五，在 NameNode 节点上的 dfs.hosts 中追加上新增节点的 hostname,

六，在其他节点上执行刷新操作：hdfs dfsadmin -refreshNodes

七，在 NameNode 节点上，更改 slaves 文件，将要上线的数据节点 hostname 追加

到 slaves 文件中

八，启动 DataNode 节点

九，查看 NameNode 的监控页面看是否有新增加的节点

节点下线操作：

一，修改/conf/hdfs-site.xml 文件

二，确定需要下线的机器，dfs.osts.exclude 文件中配置好需要下架的机器，这个是阻

止下架的机器去连接 NameNode

三，配置完成之后进行配置的刷新操作./bin/hadoop dfsadmin -refreshNodes,这个

操作的作用是在后台进行 block 块的移动

四，当执行三的命令完成之后，需要下架的机器就可以关闭了，可以查看现在集

群上连接的节点，正在执行 Decommission，会显示：

Decommission Status : Decommission in progress 执行完毕后，会显示：

Decommission Status : Decommissioned

五，机器下线完毕，将他们从 excludes 文件中移除。

10.Hadoop 中 job 和 task 之间的区别是什么？
 

JobTracker 是一个 master 服务，软件启动之后 JobTracker 接收 Job，负责调度 Job

的每一个子任务 task 运行于 TaskTracker 上，并监控它们，如果发现有失败的 task 就重新

运行它。一般情况应该把 JobTracker 部署在单独的机器上。

TaskTracker 是运行在多个节点上的 slaver 服务。TaskTracker 主动与 JobTracker 通信，

接收作业，并负责直接执行每一个任务11.Hadoop 中通过拆分任务到多个节点运行来实现并行计

算，但某些节点运行较慢会拖慢整个任务的运行，Hadoop

采用何种机制应对这个情况？

答: 推测执行机制是 Hadoop 对“拖后腿”的任务的一种优化机制，当一个作业的某些任务

运行速度明显慢于同作业的其他任务时，Hadoop 会在另一个节点 上为“慢任务”启动一

个备份任务，这样两个任务同时处理一份数据，而 Hadoop 最终会将优先完成的那个任务

的结果作为最终结果，并将另一个任务杀掉。

2. mapred.job.tracker 命令的作用
连接jobtrack服务器的配置项，默认不写是local，在本地运行，默认 map 数1，reduce数1。

7 如何决定一个job的map和reduce的数量?
splitSize=max{minSize,min{maxSize,blockSize}}

map数量由处理的数据分成的block数量决定default_num = total_size / split_size;

reduce的数量job.setNumReduceTasks(x);x 为reduce的数量.

14.如何为一个Hadoop任务设置mappers的数量？
 

具体的数据分片是这样的，InputFormat在默认情况下会根据hadoop集群HDFS块大小进行分片，每一个分片会由一个map任务来进行处理，当然用户还是可以通过参数mapred.min.split.size参数在作业提交客户端进行自定义设置。还有一个重要参数就是mapred.map.tasks，这个参数设置的map数量仅仅是一个提示，只有当InputFormat决定了map任务的个数比mapred.map.tasks值小时才起作用。同样，Map任务的个数也能通过使用JobConf的conf.setNumMapTasks(int num)方法来手动地设置。这个方法能够用来增加map任务的个数，但是不能设定任务的个数小于Hadoop系统通过分割输入数据得到的值。

15.如何为一个Hadoop任务设置要创建的 reducer的数量？
纯粹的 mapreduce task 的 reduce task 数很简单，就是参数 mapred.reduce.tasks

的值，hadoop-site.xml 文件中和 mapreduce job 运行时。不设置的话默认为 1。

10 yarn 的新特性
 

ResourceManager HA：在apache hadoop 4.4 或者CDH5.0.0 版本之后，增加了ResourceMangerHA 特性，支持基于Zookeeper 的热主备切换。

磁盘容错：增加了几个对多磁盘非常友好地参数，这些参数允许YARN 更好地使用NodeManager 上的多块磁盘.

资源调度器：Fair Scheduler 增加了允许用户在线将一个应用程序从一个队列转移到另外一个队列。

11 如何使用mapReduce实现两个表的join?
 

reduce side join : 在map 阶段，map 函数同时读取两个文件File1 和File2，为了区分

两种来源的key/value 数据对，对每条数据打一个标签（tag）,比如：tag=0 表示来自文件File1，

tag=2 表示来自文件File2。

map side join : Map side join 是针对以下场景进行的优化：两个待连接表中，有一个表非常大，而另一个表非常小，以至于小表可以直接存放到内存中。这样，我们可以将小表复制多份，让每个map task 内存中存在一份（比如存放到hash table 中），然后只扫描大表：对于大表中的每一条记录key/value，在hash table 中查找是否有相同的key 的记录，如果有，

则连接后输出即可。

Semi Join : Semi Join，也叫半连接，是从分布式数据库中借鉴过来的方法。它的产生动机是：对于reduce side join，跨机器的数据传输量非常大，这成了join 操作的一个瓶颈，

如果能够在map 端过滤掉不会参加join 操作的数据，则可以大大节省网络IO。

reduce side join + BloomFilter : BloomFilter 最常见的作用是：判断某个元素是否在一个集合里面。它最重要的两个方法是：add() 和contains()。最大的特点是不会存在 falsenegative，即：如果contains()返回false，则该元素一定不在集合中，但会存在一定的 falsepositive，即：如果contains()返回true，则该元素一定可能在集合中。

参考网址：http://my.oschina.net/leejun2005/blog/95186?fromerr=cDqkUyup

8 Hadoop的sequencefile的格式，并说明下什么是java序列化，如何实现java序列化?
 

SequenceFile文件是Hadoop用来存储二进制形式的key-value 对而设计的一种平面文件;Hadoop 的HDFS 和MapReduce子框架主要是针对大数据文件来设计的，在小文件的处理上不但效率低下，而且十分消耗磁盘空间(每一个小文件占用一个Block,HDFS 默认block大小为64M)。

解决办法通常是选择一个容器，将这些小文件组织起来统一存储。HDFS提供了两种类型的容器，分别是SequenceFile和MapFile。

SequenceFile的每条记录是可序列化的字符数组。

序列化是指将结构化的对象转化为字节流以便在网络上传输或写入到磁盘进行永久存 储的过程，反序列化是指将字节流转回结构化对象的过程.

9 简述hadoop1与hadoop2 的架构异同.
 

加入了yarn 解决了资源调度的问题。

加入了对zookeeper 的支持实现比较可靠的高可用.

http://blog.csdn.net/fenglibing/article/details/32916445

13 请描述mapReduce二次排序原理
 

二次排序:就是首先按照第一字段排序，然后再对第一字段相同的行按照第二字段排序，注意不能破坏第一次排序的结果。

在Hadoop中，默认情况下是按照key进行排序。对于同一个key，reduce函数接收到的value list是按照value 排序的。

有两种方法进行二次排序，分别为：buffer and in memory sort和value-to-key conversion。

对于buffer and in memory sort，主要思想是：在reduce()函数中，将某个key对应的所有value保存下来，然后进行排序。 这种方法最大的缺点是：可能会造成 out of memory。

对于value-to-key conversion，主要思想是：将key和部分value拼接成一个组合key（实现WritableComparable接口或者调用setSortComparatorClass函数），这样reduce获取的结果便是先按key排序，后按value排序的结果，需要注意的是，用户需要自己实现Paritioner，以便只按照key进行数据划分。Hadoop显式的支持二次排序，在Configuration 类中有个 setGroupingComparatorClass()方法，可用于设置排序 group的 key 值。

具体参考：http://www.cnblogs.com/xuxm2007/archive/2011/09/03/2165805.html

参考网址：http://my.oschina.net/leejun2005/blog/95186?fromerr=cDqkUyup

14 请描述mapReduce中排序发生的几个阶段
 

一个是在map side发生在spill后partition前。

一个是在reduce side发生在copy后 reduce前。

mapReduce的四个阶段：

Splitting :在进行map 计算之前，mapreduce 会根据输入文件计算输入分片（inputsplit），每个输入分片（input split）针对一个map 任务。输入分片（input split）存储的并非数据本身，而是一个分片长度和一个记录数据位置的数组，输入分片（input split）往往和hdfs 的block（块）关系很密切，假如我们设定hdfs 的块的大小是64mb，如果我们输入有三个文件，大小分别是3mb、65mb 和127mb，那么mapreduce 会把3mb 文件分为一个输入分片（input split），65mb 则是两个输入分片（input split）而127mb 也是两个输入分片（input split），换句话说我们如果在map 计算前做输入分片调整，例如合并小文件，那么就会有5 个map 任务将执行，而且每个map 执行的数据大小不均，这个也是mapreduce 优化计算的一个关键点。

Mapping:就是程序员编写好的map 函数了，因此map 函数效率相对好控制，而且一般map 操作都是本地化操作也就是在数据存储节点上进行；

Shuffle:描述着数据从map task 输出到reduce task 输入的这段过程。

Reduce:对Map阶段多个文件的数据进行合并。

15 请描述mapReduce中shuffle阶段的工作流程，如何优化shuffle阶段
 

分区，排序，溢写，拷贝到对应reduce机器上，增加combiner，压缩溢写的文件。

16 请描述mapReduce 中combiner 的作用是什么，一般使用情景，哪些情况不需要？
 

在MR作业中的Map阶段会输出结果数据到磁盘中。

Combiner只应该适用于那种Reduce的输入（key：value与输出（key：value）类型完全一致，且不影响最终结果的场景。比如累加，最大值等，也可以用于过滤数据，在 map端将无效的数据过滤掉。

在这些需求场景下，输出的数据是可以根据key值来作合并的，合并的目的是减少输出的数据量，减少IO的读写，减少网络传输,以提高MR的作业效率。

1.combiner的作用就是在map端对输出先做一次合并,以减少传输到reducer的数据量.

2.combiner最基本是实现本地key的归并,具有类似本地reduce,那么所有的结果都是reduce完成,效率会相对降低。

3.使用combiner,先完成的map会在本地聚合,提升速度.

3. 简述Hadoop的几个默认端口及其含义
 

dfs.namenode.http-address:50070

dfs.datanode.address:50010

fs.defaultFS:8020

yarn.resourcemanager.webapp.address:8088

5. 谈谈你对MapReduce的优化建议。
 

一.mapper调优

mapper调优主要就一个目标：减少输出量。

我们可以通过增加combine阶段以及对输出进行压缩设置进行mapper调优。

1>combine合并：

    实现自定义combine要求继承reducer类。比较适合map的输出是数值型的，方便进行统计。

2>压缩设置：

    在提交job的时候分别设置启动压缩和指定压缩方式。

二.reducer调优

 reducer调优主要是通过参数调优和设置reducer的个数来完成。

 reducer个数调优：

  要求：一个reducer和多个reducer的执行结果一致，不能因为多个reducer导致执行结果异常。

规则：一般要求在hadoop集群中的执行mr程序，map执行完成100%后，尽量早的看到reducer执行到33%，可以通过命令hadoop job -status job_id或者web页面来查看。

   原因：map的执行process数是通过inputformat返回recordread来定义的；而reducer是有三部分构成的，分别为读取mapper输出数据、合并所有输出数据以及reduce处理，其中第一步要依赖map的执行，所以在数据量比较大的情况下，一个reducer无法满足性能要求的情况下，我们可以通过调高reducer的个数来解决该问题。

优点：充分利用集群的优势。

缺点：有些mr程序没法利用多reducer的优点，比如获取top n的mr程序。

hadoop家族如此强大，为什么还要结合R语言？
 

hadoop和R语言在各自的领域都相当的强大，由RevolutionAnalytics发起的一个开源项目RHadoop将R语言与Hadoop结合在一起，很好发挥了R语言特长。广大R语言爱好者借助强大工具RHadoop，可以在大数据领域大展拳脚。

1. Hadoop家族的强大之处，在于对大数据的处理，让原来的不可能（TB,PB数据量计算），成为了可能。

2.R语言的强大之处，在于统计分析，在没有Hadoop之前，我们对于大数据的处理，要取样本，假设检验，做回归，长久以来R语言都是统计学家专属的工具。

3. hadoop重点是全量数据分析，而R语言重点是样本数据分析。 两种技术放在一起，刚好是取长补短。     4.用R语言，通过分析少量数据，对业务目标回归建模，并定义指标，用Hadoop从海量日志数据中，提取指标数据，用R语言模型，对指标数据进行测试和调优

5.R和Hadoop分别都起着非常重要的作用，以计算机开发人员的思路，所有有事情都用Hadoop去做，没有数据建模和证明，”预测的结果”一定是有问题的。以统计人员的思路，所有的事情都用R去做，以抽样方式，得到的“预测的结果”也一定是有问题的。所以让二者结合，是产界业的必然的导向，也是产界业和学术界的交集，同时也为交叉学科的人才提供了更广阔的发展空间。

5.Mapreduce的工作原理，请举例子说明mapreduce是怎么运行的？
 

离线计算框架，过程分为split map shuffle reduce四个过程 。

架构节点有：Jobtracker TaskTracker 。

Split将文件分割，传输到mapper，mapper接收KV形式的数据，经过处理，再传到shuffle过程。

Shuffle先进行HashPartition或者自定义的partition，会有数据倾斜和reduce的负载均衡问题；再进行排序，默认按字典排序；为减少mapper输出数据，再根据key进行合并，相同key的数据value会被合并；最后分组形成（key,value{}）形式的数据，输出到下一阶段 。

Reduce输入的数据就变成了，key+迭代器形式的数据，再进行处理。

2.两个类TextInputFormat和KeyValueInputFormat的区别是什么？
 

相同点：

TextInputformat和KeyValueTextInputFormat都继承了FileInputFormat类，都是每一行作为一个记录；

区别：

TextInputformat将每一行在文件中的起始偏移量作为 key，每一行的内容作为value。默认以\n或回车键作为一行记录。

KeyValueTextInputFormat 适合处理输入数据的每一行是两列，并用 tab 分离的形式。

3.在一个运行的 Hadoop 任务中，什么是 InputSplit？
 

在执行 mapreduce 之前，原始数据被分割成若干个 split，每个 split 作为一个 map

任务的输入，在 map 执行过程中 split 会被分解成一个个记录（key-value 对）。

4.Hadoop 框架中文件拆分是怎么被调用的？
 

InputFormat 是 MapReduce 中一个很常用的概念是文件拆分必须实现的一个接口，包含了两个方法：

public interface InputFormat<K, V> {

InputSplit[] getSplits(JobConf job, int numSplits) throws IOException;

RecordReader<K, V> createRecordReader(InputSplit split, TaskAttemptContext

context) throws IOException;

}

这两个方法分别完成以下工作：

方法 getSplits 将输入数据切分成 splits，splits 的个数即为 map tasks 的个数，

splits 的大小默认为块大小，即 64M

方法 getRecordReader 将每个 split 解析成 records, 再依次将 record 解析成

<K,V>对，也就是说 InputFormat 完成以下工作：InputFile --> splits --> <K,V>

系 统 常 用 的 InputFormat 又 有 哪 些 呢 ？ TextFileInputFormat ，

KeyValueTextFileInputFormat，SequenceFileInputFormat<key,value>,

NLineInputFormat 其中 Text InputFormat 便是最常用的，它的 <K,V>就代表 <行偏移,

该行内容>

然而系统所提供的这几种固定的将 InputFile 转换为 <K,V>的方式有时候并不能满足我

们的需求：

此时需要我们自定义 InputFormat ，从而使 Hadoop 框架按照我们预设的方式来将

InputFile 解析为<K,V>

在领会自定义 InputFormat 之前，需要弄懂一下几个抽象类、接口及其之间的关系：

InputFormat(interface), FileInputFormat(abstract class), TextInputFormat(class),

RecordReader (interface), Line RecordReader(class)的关系FileInputFormat implements InputFormat

TextInputFormat extends FileInputFormat

TextInputFormat.get RecordReader calls Line RecordReader

Line RecordReader implements RecordReader

对于 InputFormat 接口，上面已经有详细的描述

再看看 FileInputFormat，它实现了 InputFormat 接口中的 getSplits 方法，而将

getRecordReader 与 isSplitable 留给具体类(如 TextInputFormat )实现， isSplitable 方

法通常不用修改，所以只需要在自定义的 InputFormat 中实现

getRecordReader 方 法 即 可 ， 而 该 方 法 的 核 心 是 调 用 Line RecordReader( 即 由

LineRecorderReader 类来实现 " 将每个 s plit 解析成 records, 再依次将 record 解析成

<K,V>对" )，该方法实现了接口 RecordReader

public interface RecordReader<K, V> {

boolean next(K key, V value) throws IOException;

K createKey();

V createValue();

long getPos() throws IOException;

public void close() throws IOException;

float getProgress() throws IOException;

}

定义一个 InputFormat 的核心是定义一个类似于LineRecordReader的RecordReader

5.参考下面的M/R系统的场景：HDFS 块大小为64MB；输入类型为FileInputFormat；有三个文件大小分别是：

64KB65MB 127MB。Hadoop框架会把这些文件拆分为多少块？

分别为 1 块，2 块，2 块。

6.Hadoop 中 RecordReader 的作用是什么?
 

Hadoop 的 MapReduce 框架来处理数据，主要是面向海量大数据，对于这类数据，Hadoop 能够使其真正发挥其能力。对于海量小文件，不是说不能使用 Hadoop 来处理，只不过直接进行处理效率不会高，实际应用中，我们在使用 Hadoop 进行计算的时候，需要考虑将小数据转换成大数据，比如通过合并压缩等方法，我们通过自定义 InputFormat和RecordReader来实现对海量小文件的并行处理。

8.如果没有定义 partitioner，那数据在被送达 reducer 前
是如何被分区的？
 

如果没有自定义的 partitioning，则默认的 partition 算法，即根据每一条数据的 key

的 hashcode 值摸运算（%）reduce 的数量，得到的数字就是“分区号“。

7.Map 阶段结束后， Hadoop 框架会处理： Partitioning，Shuffle 和 Sort，在这个阶段都发生了什么？
 

map task上的洗牌（shuffle）结束，此时 reducer task 上的洗牌开始，抓取 fetch 所

属于自己分区的数据，同时将这些分区的数据进行排序sort（默认的排序是根据每一条数据的键的字典

排序），进而将数据进行合并merge，即根据key相同的，将其 value 组成一个集合，最后输出结果。

5. 请列出你所知道的Hadoop调度器，并简要说明其工作方法。
 

（1）默认的调度器 FIFO

Hadoop中默认的调度器，它先按照作业的优先级高低，再按照到达时间的先后选择被执行的作业。

（2）计算能力调度器 Capacity Scheduler

支持多个队列，每个队列可配置一定的资源量，每个队列采用FIFO调度策略，为了防止同一个用户的作业独占队列中的资源，该调度器会对同一用户提交的作业所占资源量进行限定。调度时，首先按以下策略选择一个合适队列：计算每个队列中正在运行的任务数与其应该分得的计算资源之间的比值，选择一个该比值最小的队列；然后按以下策略选择该队列中一个作业：按照作业优先级和提交时间顺序选择，同时考虑用户资源量限制和内存限制。

（3）公平调度器 Fair Scheduler

同计算能力调度器类似，支持多队列多用户，每个队列中的资源量可以配置，同一队列中的作业公平共享队列中所有资源。实际上， Hadoop的调度器远不止以上三种，最近，出现了很多针对新型应用的Hadoop调度器。

（4）适用于异构集群的调度器LATE

现有的 Hadoop 调度器都是建立在同构集群的假设前提下，具体假设如下：

1）集群中各个节点的性能完全一样

2）对于 reduce task，它的三个阶段：copy、 sort 和 reduce，用时各占 1/3

3）同一 job 的同类型的 task 是一批一批完成的，他们用时基本一样。

现有的Hadoop调度器存在较大缺陷，主要体现在探测落后任务的算法上：如果一个task 的进度落后于同类型 task进度的20%，则把该task当做落后任务(这种任务决定了job的完成时间，需尽量缩短它的执行时间)，从而为它启动一个备份任务（speculative task）。

如果集群异构的，对于同一个task，即使是在相同节点上的执行时间也会有较大差别，因而在异构集群中很容易产生大量的备份任务。

LATE调度器从某种程度上解决了现有调度器的问题，它定义三个阈值 ：

SpeculativeCap，系统中最大同时执行的speculative task 数目（作者推荐值为总slot数的10%）； SlowNodeThreshold（作者推荐值为25%）：得分（分数计算方法见论文）低于该阈值的node（快节点）上不会启动 speculative task；SlowTaskThreshold（作者推荐值为 25%）：当 task 进度低于同批同类 task 的平均进度的 SlowTaskThreshold 时，会为该 task 启动 speculative task。它的调度策略是：当一个节点出现空闲资源且系统中总的备份任务数小 于 SpeculativeCap 时， a.如果该节点是慢节点（节点得分高 于SlowNodeThreshold），则忽略这个请求。 b.对当前正在运行的 task 按估算的剩余完成时间排序 c.选择剩余完成时间最大且进度低于 SlowTaskThreshold 的 task，为该 task 启动备份任务。

（5）适用于实时作业的调度器Deadline Scheduler和Constraint-based Scheduler

这种调度器主要用于有时间限制的作业（Deadline Job），即给作业一个deadline时间，让它在该时间内完成。实际上，这类调度器分为两种，软实时（允许作业有一定的超时）作业调度器和硬实时（作业必须严格按时完成）作业调度器。

Deadline Scheduler 主要针对的是软实时作业，该调度器根据作业的运行进度和剩余时间动态调整作业获得的资源量，以便作业尽可能的在 deadline 时间内完成。

Constraint-based Scheduler 主要针对的是硬实时作业，该调度器根据作业的deadline和当前系统中的实时作业运行情况，预测新提交的实时作 业能不能在 deadline时间内完成，如果不能，则将作业反馈给用户，让他重调整作业的 deadline。

13.有可能使 Hadoop 任务输出到多个目录中么？如果可以，怎么做？
 

Hadoop 内置的输出文件格式有：

MultipleOutputs<K,V> 可以把输出数据输送到不同的目录；

在自定义的reduce的函数中首先使用setup函数（注：该函数在task启动后数据处理前就调用一次）new出MultipleOutputs 对象，利用该对象调用 write 方法定义输出的目录。

12.Hadoop API 中的什么特性可以使 map reducer 任务以不同语言（如 Perl，ruby，awk 等）实现灵活性？
 

Hadoop序列化机制，支持多语言的交互。

1.3Hadoop集群有几种角色的节点，每个节点对应的进程有哪些？

Hadoop 集群从三个角度划分为两个角色。 Hadoop 集群包括 hdfs 作为文件存储系统，mapreduce 作为分布式计算框架。

(1)最基本的划分为主节点和从节点

(2)在 hdfs 中，Namenode 作为主节点，接收客户端的读写服务。 存储文件的的元数据如文件名，文件目录结构，文件属性(生成时间，副本数，文件权限)，以及 block所在的datanode 等等，namenode 的元数据信息会在启动后加载到内存，metadata存储到磁盘文件名为” fsimage” ,block 的信息不会保存到 fsimage,edits 记录对metadata 的操作日志datanode 作为从节点。 Datanode 的作用是存储数据即 block，启动 datanode 线程的时候会向 namenode 汇报 block 信息，通过向 namenode 发送心跳保持与其联系，如果 namenode10 分钟没有收到 datanode 的心跳，则认为 datanode 挂了，并复制其上的 block 到其他 datanode。

(3)在 mapreduce 中的主节点为 jobTracker 和 tasktracker。

JobTracker 作为主节点，负责调度分配每一个子任务 task 运行于 taskTracker上，如果发现有失败的task 就重新分配到其他节点，每个 Hadoop 集群一般有一个JobTaskTracker，运行在 master 节点上。

TaskTracker主动与JobTracker通信，接收作业，并负责直接执行每一个任务，为了减少网络带宽TaskTracker 最好运行在 datanode 上

1.7mapreduce 的优化方法有哪些?

Mapreduce 程序效率的瓶颈在于两点：

一计算机性能

二 I/O 操作优化

优化分为时间和空间两种常见的优化策略如下：

1,输入的文件尽量使用大文件，众多的小文件会导致map的数量众多，每个map任务都会造成一些性能的损失，如果输入的是小的文件可以在进行mapreduce处理之前整合成为大文件，或者直接采用ConbinFileInputFormat来作为输入方式，此时，hadoop 会考虑节点和集群的位置信息，决定将哪些文件打包到一个单元中。

2,合理的分配 map 和 reduce 的任务的数量.

3,压缩中间数据，减少 I/O.

4,在 map 之后先进行 combine 处理，减少 I/O.

1.10 列举你了解的海量数据的处理方法及适用范围，如果有相关使用经验，可简要说明。
 

mapreduce 分布式计算 mapreduce 的思想就是分而治之

倒排索引:一种索引方法，用来存储在全文搜索下某个单词在一个文档或者一组文档中的存储位置的映射，在倒排索引中单词指向了包含单词的文档。

消息队列:大量的数据写入首先存入消息队列进行缓冲，再把消息队列作为数据来源进行数据读取。

数据库读写分离:向一台数据库写入数据，另外的多台数据库从这台数据库中进行读取。

2 编程题MR作业设计: 有两种格式的海量日志文件存放于hdfs上，可以通过文件名前缀区分，其中登录日志格式：
 

user,ip,time,oper(枚举值:1 为上线， 2 位下线 )；

访问日志格式:ip,time,url,假设登录日志中user上下线信息完整，且同一上下线时间段内使用的ip唯一，要计算访问日志中独立 user 数量最多的前 10个url，请给出MapReduce设计思路，如需要几个MapReduce，及每个 MapReduce 算法伪代码。

思路:

将 userid ,ip ,url 封装成一个对象，map 类输入数据，按照 userid 为 key 输出，value

为 1（intwritable）,按照 reduce 计算写一个排序类然后按照 value 降序输出前十个。

2. 运行一个 hadoop 任务的流程是什么样的。
1、 导入数据对需分析的数据进行分片，片的大小默认与 datanode 块大小相同。

2、 每个数据片由一个 mapper 进行分析，mapper 按照需求将数据拆分为一个个 keyvalue 格式的数据。

3、 每个 key-value 数据调用一次 map 方法，对数据进行相应的处理后输出。

4、 将输出的数据复制到对应的分区，默认一个键一个区，相同键放在同一个区中。

5、 将输出的数据进行合并为 key-Iterable 格式。

6、 每个分区有一个 reduce，每个 reduce 将同一个分区的数据进行合并处理为自己所需的数据格式。

7、 将数据输出至 hdfs。

3. secondary namenode / HAnamenode 是如何工作的?
 

1、 secondary namenode 在 namenode 的 edits log 文件超过规定值（默认 64M）时，或者每隔3600秒（默认值）时会剪切 edits log 文件，复制 namenode 上的 fsimage文件（若没有 fsimage）。

2、 namenode 节点创建一个新的 edits 文件。

3、 将 edits log 文件及 fsimage 文件进行合并为一个新 fsimage。

4、 将 fsimage 文件回传至 namenode 节点。

5、 Namenode 节点使用 seconday namenode 节点回传的 fsimage 文件覆盖本地的fsimage 文件。

6、 当 namenode 节点启动时可以从 seconday namenode 节点复制 fsimage 文件达到快速启动的目的。

4. 什么样的计算不能用 mr 来提速，举 5 个例子。
 

1、 数据量很小。

2、 繁杂的小文件。

3、 索引是更好的存取机制的时候。

4、 事务处理。

5、 只有一台机器的时候。

5. 一个 mr 作业跑的比较慢，如何来优化。至少给出 6 个方案。
 

mr跑的慢可能有很多原因，如：数据倾斜、map和reduce数设置不合理、reduce等待过久、小文件过多、spill 次数过多、 merge 次数过多等。

1、解决数据倾斜：数据倾斜可能是partition不合理，导致部分partition中的数据过多，部分过少。可通过分析数据，自定义分区器解决。

2、合理设置map和reduce数：两个都不能设置太少，也不能设置太多。太少，会导致task等待，延长处理时间；太多，会导致 map、 reduce 任务间竞争资源，造成处理超时等错误。

3、设置map、reduce共存：调整slowstart.completedmaps参数，使map运行到一定程度后，reduce也开始运行，减少 reduce 的等待时间。

4、合并小文件：在执行mr任务前将小文件进行合并，大量的小文件会产生大量的map任务，增大map任务装载次数，而任务的装载比较耗时，从而导致 mr 运行较慢。

5、减少spill次数：通过调整io.sort.mb及sort.spill.percent参数值，增大触发spill的内存上限，减少spill 次数，从而减少磁盘 IO。

6、减少merge次数：通过调整io.sort.factor参数，增大merge的文件数目，减少merge的次数，从而缩短mr处理时间。

6. Hadoop会有哪些重大故障，如何应对？至少给出 5个。
 

1、 namenode 单点故障：通过 zookeeper 搭建 HA 高可用，可自动切换 namenode。

2、ResourceManager单点故障：可通过配置YARN的HA，并在配置的namenode上手动启动ResourceManager作为Slave，在 Master 故障后，Slave 会自动切换为Master。

3、reduce阶段内存溢出：是由于单个reduce任务处理的数据量过多，通过增大reducetasks数目、优化partition 规则使数据分布均匀进行解决。

4、datanode内存溢出：是由于创建的线程过多，通过调整linux的maxuserprocesses参数，增大可用线程数进行解决。

5、 集群间时间不同步导致运行异常：通过配置内网时间同步服务器进行解决。

7. 什么情况下会触发 recovery 过程， recover 是怎么做的。
 

当 jobtracker.restart.recover 参数值设置为 true， jobtracker 重启之时会触发recovery。

在JobTracker重启前，会在history log中记录各个作业的运行状态，这样在JobTracker关闭后，系统中所有数据目录、 临时目录均会被保留，待 JobTracker 重启之后，JobTracker 自动重新提交这些作业，并只对未运行完成的 task 进行重新调度，这样可避免已经计算完的 task 重新计算。

JAVA相关
1-1）List 与set 的区别？
 

老掉牙的问题了，还在这里老生常谈：List特点：元素有放入顺序，元素可重复 ，Set特点：元素无放入顺序，元素不可重复。

1-2）数据库的三大范式？
原子性、一致性、唯一性

1-3）java 的io类的图解
 

1-4）对象与引用对象的区别
对象就是好没有初始化的对象，引用对象即使对这个对象进行了初始化，这个初始化可以使自己的直接new的也可以是直接其他的赋值的，那么背new或者背其他赋值的我们叫做是引用对象，最大的区别于

1-5）谈谈你对反射机制的理解及其用途？
反射有三种获取的方式，分别是：forName  / getClass / 直接使用class方式 使用反射可以获取类的实例

1-6）列出至少五种设计模式
设计方式有工厂法，懒加载，观察者模式，静态工厂，迭代器模式，外观模式、、、、

1-7）RPC 原理？
Rpc分为同步调用和一部调用，异步与同步的区别在于是否等待服务器端的返回值。Rpc的组件有RpcServer,RpcClick,RpcProxy,RpcConnection,RpcChannel,RpcProtocol,RpcInvoker等组件，

1-8）ArrayList、Vector、LinkedList 的区别及其优缺点？HashMap、HashTable 的区别及优缺点？
    ArrayList 和 Vector 是采用数组方式存储数据的,是根据索引来访问元素的，都可以

根据需要自动扩展内部数据长度，以便增加和插入元素，都允许直接序号索引元素，但

是插入数据要涉及到数组元素移动等内存操作，所以索引数据快插入数据慢，他们最大

的区别就是 synchronized 同步的使用。

    LinkedList 使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但

是插入数据时只需要记录本项的前后项即可，所以插入数度较快！

如果只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用 Vector

或 ArrayList 都可以。如果是对其它指定位置的插入、删除操作，最好选择 LinkedList

HashMap、HashTable 的区别及其优缺点：

     HashTable 中的方法是同步的 HashMap 的方法在缺省情况下是非同步的 因此在多线程环境下需要做额外的同步机制。

    HashTable 不允许有 null 值 key 和 value 都不允许，而 HashMap 允许有 null 值 key和 value 都允许 因此 HashMap 使用 containKey（）来判断是否存在某个键。

HashTable 使用 Enumeration ，而 HashMap 使用 iterator。

     Hashtable 是 Dictionary 的子类，HashMap 是 Map 接口的一个实现类。

1-9）使用 StringBuffer 而不是 String
当需要对字符串进行操作时，使用 StringBuffer 而不是 String，String 是 read-only 的，如果对它进行修改，会产生临时对象，而 StringBuffer 是可修改的，不会产生临时对象。

1-10）集合的扩充
ArrayList  list = new ArrayList(90000); list扩充多少次？？

 public ArrayList() {

        this(10);

}

默认的扩充是10由此计算

1-11）java的拆包与封包的问题
 

System.out.println("5" + 2);

52

1-12）Java中Class.forName和ClassLoader.loadClass的区别
Class.forName("xx.xx")等同于Class.forName("xx.xx",true,CALLClass.class.getClassLoader())，第二个参数(bool)表示装载类的时候是否初始化该类，即调用类的静态块的语句及初始化静态成员变量。

ClassLoader loader = Thread.currentThread.getContextClassLoader(); //也可以用(ClassLoader.getSystemClassLoader())

Class cls = loader.loadClass("xx.xx"); //这句话没有执行初始化

forName可以控制是否初始化类，而loadClass加载时是没有初始化的。

1-13）hashMap与hashTable的区别
                   HashMap                Hashtable

父类               AbstractMap          Dictiionary

是否同步            否                            是

k，v可否null        是                            否

Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

1-14）怎样实现数组的反转
ArrayList arrayList = new ArrayList();  

 arrayList.add("A");  

 arrayList.add("B");

对数组进行反转

Collections.reverse(arrayList);

1-15）请使用JAVA实现二分查找
一般的面试者都是些向看看你的思路，所以一般答题时只需要把思路写出来即可。

具体的实现如下：

二分查找就是折半查找，要想折半就必须把原来的数据进行排序，才能方便的查找：

实现代码如下：

 public static int binarySearch(int[] srcArray, int des){   

        int low = 0;   

        int high = srcArray.length-1;   

        while(low <= high) {   

            int middle = (low + high)/2;   

            if(des == srcArray[middle]) {   

                return middle;   

            }else if(des <srcArray[middle]) {   

                high = middle - 1;   

            }else {   

                low = middle + 1;   

            }  

        }  

        return -1;  

   }

1-16）java 中有两个线程怎样等待一个线程执行完毕
可以使用join关键字

1-17）hashmap hashtable currentHashMap的使用区别
     hashmap hashtable 的醉的的区别在于hashtable 是线程安全的，而hashmap 不是线程安全的，currentHashMap也是线程安全的。

     ConcurrentHashMap是使用了锁分段技术技术来保证线程安全的。所分段的技术是：讲数据分成一段一段的储存，给每一段的数据添加一把锁，当线程访问一个数据时，其他的数据可以被访问。

1-18）简单描述一下java的gc机制，常用的JAVA调优的方法，OOM如何产生的，如何处理OOM问题？？？
1、程序在运行时会产生很多的对象的信息，当这些对象的信息没有用时，则会被gc回收

2、调优的方式主要是调节年轻代与老年代的内存的大小

3、OOM是OutOfMemory的缩写(搞得跟多高大上似的)就是线程创建的多了，没有及时的回收过来所产生的，代码如下：

public class JavaVMStackOOM {  

    private void dontStop() {  

        while (true) {  

              

        }  

    }  

      

    public void stackLeakByThread() {  

        while (true) {  

            Thread thread = new Thread(new Runnable() {  

                @Override  

                public void run() {  

                    dontStop();  

                }  

            });  

            thread.start();  

        }  

    }  

      

    public static void main(String[] args) {  

        JavaVMStackOOM oom = new JavaVMStackOOM();  

        oom.stackLeakByThread();  

}  

4、既然知道以上的现象，在写代码时应该注意，不要过多的创建线程的数目。

Linux 相关
2-1）关闭不必要的服务
A、使用ntsysv命令查看开启与关闭的服务

B、停止打印服务

[root@hadoop1 /]# /etc/init.d/cups stop

[root@hadoop1 /]# chkconfig cups off

2-2）关闭IP6
[root@hadoop1 /]# vim /etc/modprobe.conf

在下面添加一下配置：

alias net-pf-10 off

alias ipv6 off

2-3）调整文件的最大的打开数
查看当前的文件的数量：[root@hadoop1 /]#ulimit -a

修改配置：
[root@hadoop1 /]# vi /etc/security/limits.conf 在文件最后加上：

* soft nofile 65535

* hard nofile 65535

* soft nproc 65535

* hard nproc 65535

2-4）修改 linux 内核参数
[root@hadoop1 /]# vi /etc/sysctl.conf

在文本的最后追加一下内容：

net.core.somaxconn = 32768

表示物理内存使用到 90%（100-10=90）的时候才使用 swap 交换区

2-5）关闭 noatime
在最后追加一下内容

/dev/sda2 /data ext3 noatime,nodiratime 0 0

2-6)请用shell命令把某一个文件下的所有的文件分发到其他的机器上
Scp  -r  /user/local   hadoop2:/user/local

2-7）echo 1+1 && echo "1+1" 会输出什么
 

[root@hadoop1 ~]# echo 1+1 && echo "1+1"

1+1

1+1

[root@hadoop1 ~]# echo 1+1 && echo "1+1" && echo "1+" 1

1+1

1+1

1+ 1

2-8）在当前的额目录下找出包含祖母a并且文件的额大小大于55K的文件
[root@hadoop1 test]# find  .|  grep -ri "a"

a.text:a

后半句没有写出来，有时间在搞

2-9）linux用什么命令查看cpu,硬盘，内存的信息？
Top 命令

Hadoop相关
3-1）简单概述hdfs原理，以及各个模块的职责
 

1、客户端向 nameNode 发送要上传文件的请求

2、nameNode 返回给用户是否能上传数据的状态

3、加入用户端需要上传一个 1024M 的文件，客户端会通过 Rpc 请求 NameNode，并返回需要上传给那些DataNode(分配机器的距离以及空间的大小等),namonode会选择就近原则分配机器。

4、客户端请求建立 block 传输管道 chnnel 上传数据

5、在上传是 datanode 会与其他的机器建立连接并把数据块传送到其他的机器上

6、dataNode 向 namenode 汇报自己的储存情况以及自己的信息

7、档第一个快上传完后再去执行其他的复制的传送

3-2）mr的工作原理
 

1、当执行mr程序是，会执行一个Job

2、客户端的jobClick会请求namenode的jobTracker要执行任务

3、jobClick会去HDFS端复制作业的资源文件

4、客户端的jobClick会向namenode提交作业,让namenode做准备

5、Namenode的jobTracker会去初始化创建的对象

6、Namenode会获取hdfs的划分的分区

7、Namenode去检查TaskTracker的心跳信息，查看存活的机器

8、当执行的datenode执行任务时Datenode会去HDFS获取作业的资源的文件

9、TaskTracker会去执行代码，并登陆JVM的执行渠道

10、JVM或执行MapTask或者ReduceTask

11、执行终结

3-3）怎样判断文件时候存在
这是linux上的知识，只需要在IF[ -f ] 括号中加上-f参数即可判断文件是否存在

3-4）fsimage和edit的区别？
 

大家都知道namenode与secondary namenode 的关系，当他们要进行数据同步时叫做checkpoint时就用到了fsimage与edit，fsimage是保存最新的元数据的信息，当fsimage数据到一定的大小事会去生成一个新的文件来保存元数据的信息，这个新的文件就是edit，edit会回滚最新的数据。

3-5）hdfs中的block默认保存几份？
不管是hadoop1.x 还是hadoop2.x 都是默认的保存三份，可以通过参数dfs.replication就行修改，副本的数目要根据机器的个数来确定。

3-6）列举几个配置文件优化？
Core-site.xml 文件的优化

fs.trash.interval

默认值： 0

说明： 这个是开启hdfs文件删除自动转移到垃圾箱的选项，值为垃圾箱文件清除时间。一般开启这个会比较好，以防错误删除重要文件。单位是分钟。

dfs.namenode.handler.count

默认值：10

说明：hadoop系统里启动的任务线程数，这里改为40，同样可以尝试该值大小对效率的影响变化进行最合适的值的设定。

mapreduce.tasktracker.http.threads

默认值：40

说明：map和reduce是通过http进行数据传输的，这个是设置传输的并行线程数。

3-7) 谈谈数据倾斜，如何发生的，并给出优化方案
     数据的倾斜主要是两个的数据相差的数量不在一个级别上，在只想任务时就造成了数据的倾斜，可以通过分区的方法减少reduce数据倾斜性能的方法，例如;抽样和范围的分区、自定义分区、数据大小倾斜的自定义侧咯

3-8）简单概括安装hadoop的步骤
1.创建 hadoop 帐户。

2.setup.改 IP。

3.安装 java，并修改/etc/profile 文件，配置 java 的环境变量。

4.修改 Host 文件域名。

5.安装 SSH，配置无密钥通信。

6.解压 hadoop。

7.配置 conf 文件下 hadoop-env.sh、core-site.sh、mapre-site.sh、hdfs-site.sh。

8.配置 hadoop 的环境变量。

9.Hadoop namenode -format

10.Start-all.sh

3-9）简单概述hadoop中的角色的分配以及功能
Namenode:负责管理元数据的信息

SecondName:做namenode冷备份，对于namenode的机器当掉后能快速切换到制定的Secondname上

DateNode:主要做储存数据的。

JobTracker:管理任务，并把任务分配到taskTasker

TaskTracker：执行任务的

3-10）怎样快速的杀死一个job
1、执行hadoop  job -list  拿到job-id

2、Hadoop job kill hadoop-id

3-11)新增一个节点时怎样快速的启动
Hadoop-daemon.sh start datanode

3-12)你认为用java , streaming , pipe 方式开发map/reduce,各有什么优点
开发mapReduce只用过java与hive,不过使用java开发mapreduce显得笨拙，效率也慢，基于java慢的原因于是hive，这样就方便了查询与设计

3-13）简单概述hadoop的join的方法
Hadoop 常用的jion有reduce side join  , map side  join ,  SemiJoin 不过reduce side join 与 map side join 比较常用，不过都是比较耗时的。

3-14）简单概述hadoop的combinet与partition的区别
combine和partition都是函数，中间的步骤应该只有shuffle！ combine分为map端和reduce端，作用是把同一个key的键值对合并在一起，可以自定义的,partition是分割map每个节点的结果，按照key分别映射给不同的reduce，也是可以自定义的。这里其实可以理解归类。

3-15 ) hdfs 的数据压缩算法
 Hadoop 的压缩算法有很多，其中比较常用的就是gzip算法与bzip2算法，都可以可通过CompressionCodec来实现

3-16）hadoop的调度
Hadoop 的调度有三种其中fifo的调度hadoop的默认的，这种方式是按照作业的优先级的高低与到达时间的先后执行的，还有公平调度器：名字见起意就是分配用户的公平获取共享集群呗!容量调度器:让程序都能货到执行的能力，在队列中获得资源。

3-17）reduce 后输出的数据量有多大？
输出的数据量还不是取决于map端给他的数据量，没有数据reduce也没法运算啊!!

3-18) datanode 在什么情况下不会备份？
Hadoop保存的三个副本如果不算备份的话，那就是在正常运行的情况下不会备份，也是就是在设置副本为1的时候不会备份，说白了就是单台机器呗！！还有datanode 在强制关闭或者非正常断电不会备份。

3-19）combine 出现在那个过程？
Hadoop的map过程，根据意思就知道结合的意思吗，剩下的你们就懂了。想想wordcound

3-20) hdfs 的体系结构？
HDFS有 namenode、secondraynamenode、datanode 组成。

namenode 负责管理 datanode 和记录元数据

secondraynamenode 负责合并日志

datanode 负责存储数据

3-21) hadoop flush 的过程？
Flush 就是把数据落到磁盘，把数据保存起来呗!

3-22) 什么是队列
队列的实现是链表，消费的顺序是先进先出。

3-23）三个 datanode，当有一个 datanode 出现错误会怎样？
第一不会给储存带来影响，因为有其他的副本保存着，不过建议尽快修复，第二会影响运算的效率，机器少了，reduce在保存数据时选择就少了，一个数据的块就大了所以就会慢。

3-24）mapReduce 的执行过程
首先map端会Text 接受到来自的数据，text可以把数据进行操作，最后通过context把key与value写入到下一步进行计算，一般的reduce接受的value是个集合可以运算，最后再通过context把数据持久化出来。

3-25）Cloudera 提供哪几种安装 CDH 的方法
· Cloudera manager

· Tarball

· Yum

· Rpm

3-26）选择题与判断题
http://blog.csdn.net/jiangheng0535/article/details/16800415

3-27）hadoop的combinet与partition效果图
 

3-28）hadoop 的机架感知（或者说是扩普）
看图说话

数据块会优先储存在离namenode进的机器或者说成离namenode机架近的机器上，正好是验证了那句话不走网络就不走网络，不用磁盘就不用磁盘。

3-29）文件大小默认为 64M，改为 128M 有啥影响？
这样减少了namenode的处理能力，数据的元数据保存在namenode上，如果在网络不好的情况下会增到datanode的储存速度。可以根据自己的网络来设置大小。

3-30）datanode 首次加入 cluster 的时候，如果 log 报告不兼容文件版本，那需要namenode 执行格式化操作，这样处理的原因是？
     这样处理是不合理的，因为那么 namenode 格式化操作，是对文件系统进行格式

化，namenode 格式化时清空 dfs/name 下空两个目录下的所有文件，之后，会在目

录 dfs.name.dir 下创建文件。

     文本不兼容，有可能时 namenode 与 datanode 的 数据里的 namespaceID、

clusterID 不一致，找到两个 ID 位置，修改为一样即可解决。

3-31）什么 hadoop streaming？
提示：指的是用其它语言处理

3-32）MapReduce 中排序发生在哪几个阶段？这些排序是否可以避免？为什么？
     一个 MapReduce 作业由 Map 阶段和 Reduce 阶段两部分组成，这两阶段会对数

据排序，从这个意义上说，MapReduce 框架本质就是一个 Distributed Sort。在 Map

阶段，在 Map 阶段，Map Task 会在本地磁盘输出一个按照 key 排序（采用的是快速

排序）的文件（中间可能产生多个文件，但最终会合并成一个），在 Reduce 阶段，每

个 Reduce Task 会对收到的数据排序，这样，数据便按照 Key 分成了若干组，之后以

组为单位交给 reduce（）处理。很多人的误解在 Map 阶段，如果不使用 Combiner

便不会排序，这是错误的，不管你用不用 Combiner，Map Task 均会对产生的数据排

序（如果没有 Reduce Task，则不会排序，实际上 Map 阶段的排序就是为了减轻 Reduce

端排序负载）。由于这些排序是 MapReduce 自动完成的，用户无法控制，因此，在

hadoop 1.x 中无法避免，也不可以关闭，但 hadoop2.x 是可以关闭的。

3-33）hadoop的shuffer的概念
Shuffer是一个过程，实在map端到reduce在调reduce数据之前都叫shuffer,主要是分区与排序，也就是内部的缓存分分区以及分发（是reduce来拉数据的）和传输

3-34）hadoop的优化
1、优化的思路可以从配置文件和系统以及代码的设计思路来优化

2、配置文件的优化：调节适当的参数，在调参数时要进行测试

3、代码的优化：combiner的个数尽量与reduce的个数相同，数据的类型保持一致，可以减少拆包与封包的进度

4、系统的优化：可以设置linux系统打开最大的文件数预计网络的带宽MTU的配置

5、为 job 添加一个 Combiner，可以大大的减少shuffer阶段的maoTask拷贝过来给远程的   reduce task的数据量，一般而言combiner与reduce相同。

6、在开发中尽量使用stringBuffer而不是string，string的模式是read-only的，如果对它进行修改，会产生临时的对象，二stringBuffer是可修改的，不会产生临时对象。

7、修改一下配置：

一下是修改 mapred-site.xml 文件

修改最大槽位数

槽位数是在各个 tasktracker 上的 mapred-site.xml 上设置的，默认都是 2

<property>

<name>mapred.tasktracker.map.tasks.maximum</name>

task 的最大数

<value>2</value>

</property>

<property>

<name>mapred.tasktracker.reduce.tasks.maximum</name>

ducetask 的最大数

<value>2</value>

</property>

调整心跳间隔

集群规模小于 300 时，心跳间隔为 300 毫秒

mapreduce.jobtracker.heartbeat.interval.min 心跳时间

北京市昌平区建材城西路金燕龙办公楼一层 电话：400-618-9090

mapred.heartbeats.in.second 集群每增加多少节点，时间增加下面的值

mapreduce.jobtracker.heartbeat.scaling.factor 集群每增加上面的个数，心跳增多少

启动带外心跳

mapreduce.tasktracker.outofband.heartbeat 默认是 false

配置多块磁盘

mapreduce.local.dir

配置 RPC hander 数目

mapred.job.tracker.handler.count 默认是 10，可以改成 50，根据机器的能力

配置 HTTP 线程数目

tasktracker.http.threads 默认是 40，可以改成 100 根据机器的能力

选择合适的压缩方式

以 snappy 为例：

<property>

<name>mapred.compress.map.output</name>

<value>true</value>

</property>

<property>

<name>mapred.map.output.compression.codec</name>

<value>org.apache.hadoop.io.compress.SnappyCodec</value>

</property>

3-35)3 个 datanode 中有一个 个datanode 出现错误会怎样？
这个 datanode 的数据会在其他的 datanode 上重新做备份。

3-36）怎样决定mapreduce的中的map以及reduce的数量
在mapreduce中map是有块的大小来决定的，reduce的数量可以按照用户的业务来配置。

3-37）两个文件合并的问题
给定a、b两个文件，各存放50亿个url，每个url各占用64字节，内存限制是4G，如何找出a、b文件共同的url？

    主要的思想是把文件分开进行计算，在对每个文件进行对比，得出相同的URL,因为以上说是含有相同的URL所以不用考虑数据倾斜的问题。详细的解题思路为：

可以估计每个文件的大小为5G*64=300G，远大于4G。所以不可能将其完全加载到内存中处理。考虑采取分而治之的方法。 
    遍历文件a，对每个url求取hash(url)%1000，然后根据所得值将url分别存储到1000个小文件（设为a0,a1,...a999）当中。这样每个小文件的大小约为300M。遍历文件b，采取和a相同的方法将url分别存储到1000个小文件(b0,b1....b999)中。这样处理后，所有可能相同的url都在对应的小文件(a0 vs b0, a1 vs b1....a999 vs b999)当中，不对应的小文件（比如a0 vs b99）不可能有相同的url。然后我们只要求出1000对小文件中相同的url即可。 
    比如对于a0 vs b0，我们可以遍历a0，将其中的url存储到hash_map当中。然后遍历b0，如果url在hash_map中，则说明此url在a和b中同时存在，保存到文件中即可。 
    如果分成的小文件不均匀，导致有些小文件太大（比如大于2G），可以考虑将这些太大的小文件再按类似的方法分成小小文件即可

3-38）怎样决定一个job的map和reduce的数量
map的数量通常是由hadoop集群的DFS块大小确定的，也就是输入文件的总块数，reduce端是复制map端的数据，相对于map端的任务，reduce节点资源是相对于比较缺少的，同时运行的速度会变慢，争取的任务的个数应该是0.95过着1.75。

3-39）hadoop的sequencefile的格式，并说明下什么是JAVA的序列化，如何实现JAVA的序列化
1、hadoop的序列化(sequencefile)是一二进制的形式来保存的

2、Java的序列化是讲对象的内容进行流化

3、实现序列化需要实现Serializable接口便可以了

3-40）简单概述一下hadoop1与hadoop2的区别
Hadoop2与hadoop1最大的区别在于HDFS的架构与mapreduce的很大的区别，而且速度上有很大的提升，hadoop2最主要的两个变化是：namenode可以集群的部署了，hadoop2中的mapreduce中的jobTracker中的资源调度器与生命周期管理拆分成两个独立的组件，并命名为YARN

3-41）YARN的新特性
YARN是hadoop2.x之后才出的，主要是hadoop的HA(也就是集群)，磁盘的容错，资源调度器

3-42）hadoop join的原理
实现两个表的join首先在map端需要把表标示一下，把其中的一个表打标签，到reduce端再进行笛卡尔积的运算，就是reduce进行的实际的链接操作。

3-43）hadoop的二次排序
Hadoop默认的是HashPartitioner排序，当map端一个文件非常大另外一个文件非常小时就会产生资源的分配不均匀，既可以使用setPartitionerClass来设置分区，即形成了二次分区。

3-44）hadoop的mapreduce的排序发生在几个阶段？
发生在两个阶段即使map与reduce阶段

3-45）请描述mapreduce中shuffer阶段的工作流程，如何优化shuffer阶段的？
 

Mapreduce的shuffer是出在map task到reduce task的这段过程中，首先会进入到copy过程，会通过http方式请求map task所在的task Tracker获取map task 的输出的文件，因此当map  task结束，这些文件就会落到磁盘中，merge实在map端的动作，只是在map拷贝过来的数值，会放到内存缓冲区中，给shuffer使用，reduce阶段，不断的merge后最终会把文件放到磁盘中。

3-46）mapreduce的combiner的作用是什么，什么时候不易使用？？
Mapreduce中的Combiner就是为了避免map任务和reduce任务之间的数据传输而设置的，Hadoop允许用户针对map task的输出指定一个合并函数。即为了减少传输到Reduce中的数据量。它主要是为了削减Mapper的输出从而减少网络带宽和Reducer之上的负载。

在数据量较少时不宜使用。

3-47）

Zookeeper 相关
4-1）写出你对zookeeper的理解
     随着大数据的快速发展，多机器的协调工作，避免主要机器单点故障的问题，于是就引入管理机器的一个软件，他就是zookeeper来协助机器正常的运行。

     Zookeeper有两个角色分别是leader与follower ，其中leader是主节点，其他的是副节点，在安装配置上一定要注意配置奇数个的机器上，便于zookeeper快速切换选举其他的机器。

在其他的软件执行任务时在zookeeper注册时会在zookeeper下生成相对应的目录，以便zookeeper去管理机器。

4-2）zookeeper 的搭建过程
主要是配置文件zoo.cfg 配置dataDir 的路径一句dataLogDir 的路径以及myid的配置以及server的配置，心跳端口与选举端口

Hive 相关
5-1）hive是怎样保存元数据的
保存元数据的方式有：内存数据库rerdy，本地mysql数据库，远程mysql数据库，但是本地的mysql数据用的比较多，因为本地读写速度都比较快

5-2）外部表与内部表的区别
 

先来说下Hive中内部表与外部表的区别： 

Hive 创建内部表时，会将数据移动到数据仓库指向的路径；若创建外部表，仅记录数据所在的路径，不对数据的位置做任何改变。在删除表的时候，内部表的元数据和数据会被一起删除，而外部表只删除元数据，不删除数据。这样外部表相对来说更加安全些，数据组织也更加灵活，方便共享源数据。

5-3）对于 hive，你写过哪些 UDF 函数，作用是什么
UDF: user  defined  function  的缩写，编写hive udf的两种方式extends UDF 重写evaluate第二种extends GenericUDF重写initialize、getDisplayString、evaluate方法

5-4)Hive 的 sort by 和 order by 的区别
  order by 会对输入做全局排序，因此只有一个reducer（多个reducer无法保证全局有序）只有一个reducer，会导致当输入规模较大时，需要较长的计算时间。

   sort by不是全局排序，其在数据进入reducer前完成排序.

因此，如果用sort by进行排序，并且设置mapred.reduce.tasks>1， 则sort by只保证每个reducer的输出有序，不保证全局有序。

5-5）hive保存元数据的方式以及各有什么特点？
1、Hive有内存数据库derby数据库，特点是保存数据小，不稳定

2、mysql数据库，储存方式可以自己设定，持久化好，一般企业开发都用mysql做支撑

5-6）在开发中问什么建议使用外部表？
1、外部表不会加载到hive中只会有一个引用加入到元数据中

2、在删除时不会删除表，只会删除元数据，所以不必担心数据的

5-7）hive partition 分区
分区表，动态分区

5-8）insert into 和 override write 区别？
insert into：将某一张表中的数据写到另一张表中

override write：覆盖之前的内容。

Hbase 相关
6-1）Hbase 的 rowkey 怎么创建比较好？列族怎么创建比较好？
 

Rowkey是一个二进制码流，Rowkey的长度被很多开发者建议说设计在10~100个字节，不过建议是越短越好，不要超过16个字节。在查找时有索引会加快速度。

Rowkey散列原则 、 Rowkey唯一原则 、 针对事务数据Rowkey设计 、 针对统计数据的Rowkey设计 、 针对通用数据的Rowkey设计、 支持多条件查询的RowKey设计。 

总结设计列族：

1、一般不建议设计多个列族

2、数据块的缓存的设计

3、激进缓存设计

4、布隆过滤器的设计(可以提高随机读取的速度)

5、生产日期的设计

6、列族压缩

7、单元时间版本

6-2）Hbase 的实现原理
Hbase  的实现原理是rpc Protocol 

6-3) hbase 过滤器实现原则
感觉这个问题有问题，过滤器多的是啦，说的是哪一个不知道!!!!

Hbase的过滤器有：RowFilter、PrefixFilter、KeyOnlyFilter、RandomRowFilter、InclusiveStopFilter、FirstKeyOnlyFilter、ColumnPrefixFilter、ValueFilter、ColumnCountGetFilter、SingleColumnValueFilter、SingleColumnValueExcludeFilter、WhileMatchFilter、FilterList 

   你看这么多过滤波器呢，谁知道你问的那个啊！！

   比较常用的过滤器有：RowFilter 一看就知道是行的过滤器，来过滤行的信息。PrefixFilter前缀的过滤器，就是把前缀作为参数来查找数据呗！剩下的不解释了看过滤器的直接意思就OK了很简单。

6-4）描述 HBase, zookeeper 搭建过程
Zookeeper 的问题楼上爬爬有步骤，hbase 主要的配置文件有hbase.env.sh 主要配置的是JDK的路径以及是否使用外部的ZK，hbase-site.xml 主要配置的是与HDFS的链接的路径以及zk的信息，修改regionservers的链接其他机器的配置。

6-5）hive 如何调优？
在优化时要注意数据的问题，尽量减少数据倾斜的问题，减少job的数量，同事对小的文件进行成大的文件，如果优化的设计那就更好了，因为hive的运算就是mapReduce所以调节mapreduce的参数也会使性能提高，如调节task的数目。

6-6）hive的权限的设置
Hive的权限需要在hive-site.xml文件中设置才会起作用，配置默认的是false，需要把hive.security.authorization.enabled设置为true，并对不同的用户设置不同的权限，例如select ,drop等的操作。

6-7 ) hbase 写数据的原理
 

1. 首先，Client通过访问ZK来请求目标数据的地址。

2. ZK中保存了-ROOT-表的地址，所以ZK通过访问-ROOT-表来请求数据地址。

3. 同样，-ROOT-表中保存的是.META.的信息，通过访问.META.表来获取具体的RS。

4. .META.表查询到具体RS信息后返回具体RS地址给Client。

5. Client端获取到目标地址后，然后直接向该地址发送数据请求。

6-8）hbase宕机了如何处理？
HBase的RegionServer宕机超过一定时间后，HMaster会将其所管理的region重新分布到其他活动的RegionServer上，由于数据和日志都持久在HDFS中，
该操作不会导致数据丢失。所以数据的一致性和安全性是有保障的。
但是重新分配的region需要根据日志恢复原RegionServer中的内存MemoryStore表，这会导致宕机的region在这段时间内无法对外提供服务。
而一旦重分布，宕机的节点重新启动后就相当于一个新的RegionServer加入集群，为了平衡，需要再次将某些region分布到该server。 
因此，Region Server的内存表memstore如何在节点间做到更高的可用，是HBase的一个较大的挑战。

6-9）Hbase 中的 metastore 用来做什么的？
Hbase的metastore是用来保存数据的，其中保存数据的方式有有三种第一种于第二种是本地储存，第二种是远程储存这一种企业用的比较多

6-10)hbase客户端在客户端怎样优化？
Hbase使用JAVA来运算的，索引Java的优化也适用于hbase，在使用过滤器事记得开启bloomfilter可以是性能提高3-4倍，设置HBASE_HEAPSIZE设置大一些

6-11）hbase是怎样预分区的？
如何去进行预分区，可以采用下面三步：
  1.取样，先随机生成一定数量的rowkey,将取样数据按升序排序放到一个集合里
  2.根据预分区的region个数，对整个集合平均分割，即是相关的splitKeys.
  3.HBaseAdmin.createTable(HTableDescriptor tableDescriptor,byte[][] splitkeys)可以指定预分区的splitKey，即是指定region间的rowkey临界值

6-12）怎样将 mysql 的数据导入到 hbase 中？
不能使用 sqoop，速度太慢了，提示如下：

A、一种可以加快批量写入速度的方法是通过预先创建一些空的 regions，这样当

数据写入 HBase 时，会按照 region 分区情况，在集群内做数据的负载均衡。

B、hbase 里面有这样一个 hfileoutputformat 类，他的实现可以将数据转换成 hfile

格式，通过 new 一个这个类，进行相关配置,这样会在 hdfs 下面产生一个文件，这个

时候利用 hbase 提供的 jruby 的 loadtable.rb 脚本就可以进行批量导入。

6-13）谈谈 HBase 集群安装注意事项？
     需要注意的地方是 ZooKeeper 的配置。这与 hbase-env.sh 文件相关，文件中

HBASE_MANAGES_ZK 环境变量用来设置是使用 hbase 默认自带的 Zookeeper 还

是使用独立的 ZooKeeper。HBASE_MANAGES_ZK=false 时使用独立的，为 true 时

使用默认自带的。

    某个节点的 HRegionServer 启动失败，这是由于这 3 个节点的系统时间不一致相

差超过集群的检查时间 30s。

6-14)简述 HBase 的瓶颈
Hbase主要的瓶颈就是传输问题，在操作时大部分的操作都是需要对磁盘操作的

6-15）Redis, 传统数据库,hbase,hive  每个之间的区别
Redis 是基于内存的数据库，注重实用内存的计算，hbase是列式数据库，无法创建主键，地从是基于HDFS的，每一行可以保存很多的列，hive是数据的仓库，是为了减轻mapreduce而设计的，不是数据库是用来与红薯做交互的。

6-16）Hbase 的特性,以及你怎么去设计 rowkey 和 columnFamily ,怎么去建一个 table
因为hbase是列式数据库，列非表schema的一部分，所以只需要考虑rowkey和columnFamily 即可，rowkey有为的相关性，最好数据库添加一个前缀，文件越小，查询速度越快，再设计列是有一个列簇，但是列簇不宜过多。

6-17）Hhase与hive的区别
     Apache HBase是一种Key/Value系统，它运行在HDFS之上。和Hive不一样，Hbase的能够在它的数据库上实时运行，而不是运行MapReduce任务。Hive被分区为表格，表格又被进一步分割为列簇。列簇必须使用schema定义，列簇将某一类型列集合起来（列不要求schema定义）。例如，“message”列簇可能包含：“to”,”from” “date”, “subject”, 和”body”. 每一个 key/value对在Hbase中被定义为一个cell，每一个key由row-key，列簇、列和时间戳。在Hbase中，行是key/value映射的集合，这个映射通过row-key来唯一标识。Hbase利用Hadoop的基础设施，可以利用通用的设备进行水平的扩展。

6-18）描述hbase的scan和get功能以及实现的异同
 

      HBase的查询实现只提供两种方式： 1、按指定RowKey获取唯一一条记录，get方法（org.apache.hadoop.hbase.client.Get） 2、按指定的条件获取一批记录，scan方法（org.apache.hadoop.hbase.client.Scan） 实现条件查询功能使用的就是scan方式

6-19）HBase scan setBatch和setCaching的区别
      can可以通过setCaching与setBatch方法提高速度（以空间换时间），

setCaching设置的值为每次rpc的请求记录数，默认是1；cache大可以优化性能，但是太大了会花费很长的时间进行一次传输。

   setBatch设置每次取的column size；有些row特别大，所以需要分开传给client，就是一次传一个row的几个column。

6-20）hbase 中cell的结构
cell中的数据是没有类型的，全部是字节码形式存贮。

6-21）hbase 中region太多和region太大带来的冲突
Hbase的region会自动split，当region太时，regio太大时分布会不均衡，同时对于大批量的代入数据建议如下：

1、还是必须让业务方对rowkey进行预分片，对业务数据rowkey进行md5或者其他的hash策略，让数据尽量随机分布而不是顺序写入。

2、随时观察region的大小，是否出现大region的情况。

Flume相关
7-1）flume 不采集 Nginx 日志，通过 Logger4j 采集日志，优缺点是什么？
在nginx采集日志时无法获取session的信息，然而logger4j则可以获取session的信息，logger4j的方式比较稳定，不会宕机。缺点：不够灵活，logger4j的方式和项目结合过滤紧密，二flume的方式就比较灵活，便于插拔式比较好，不会影响项目的性能。

7-2）flume 和 kafka 采集日志区别，采集日志时中间停了，怎么记录之前的日志。
Flume 采集日志是通过流的方式直接将日志收集到存储层，而 kafka 试讲日志缓存在 kafka

集群，待后期可以采集到存储层。Flume 采集中间停了，可以采用文件的方式记录之前的日志，而 kafka 是采用 offset(偏移量) 的方式记录之前的日志。

Kafka 相关
8-1）kafka 中怎样储存数据，哟及结构的，data.....目录下有多少个分区，每个分区的存储格式是什么样的？
1、topic 是按照“主题名-分区”存储的

2、分区个数由配置文件决定

3、每个分区下最重要的两个文件是 0000000000.log 和 000000.index，0000000.log

以默认 1G 大小回滚。

Spark 相关
9-1）mr 和 spark 区别，怎么理解 spark-rdd
     Mr 是文件方式的分布式计算框架，是将中间结果和最终结果记录在文件中，map 和 reduce的数据分发也是在文件中。

spark 是内存迭代式的计算框架，计算的中间结果可以缓存内存，也可以缓存硬盘，但是不是每一步计算都需要缓存的。

Spark-rdd 是一个数据的分区记录集合，是利用内存来计算的，spark之所以快是因为有内存的模式

9-2）简单描述spark的wordCount的执行过程
scala> sc.textFile("/usr/local/words.txt")

res0: org.apache.spark.rdd.RDD[String] = /usr/local/words.txt MapPartitionsRDD[1] at textFile at <console>:22

scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" "))

res2: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[4] at flatMap at <console>:22

scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" ")).map((_,1))

res3: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[8] at map at <console>:22

scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_)

res5: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[17] at reduceByKey at <console>:22

scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect

res6: Array[(String, Int)] = Array((dageda,1), (xiaoli,1), (hellow,4), (xisdsd,1), (xiaozhang,1))

9-3）按照需求使用spark编写一下程序
A、当前文件a.text的格式为，请统计每个单词出现的个数

A,b,c,d

B,b,f,e

A,a,c,f

sc.textFile(“/user/local/a.text”).flatMap(_.split(“,”)).map((_,1)).ReduceByKey(_+_).collect()

或：

package cn.bigdata

import org.apache.spark.SparkConf

import org.apache.spark.SparkContext

import org.apache.spark.rdd.RDD

object Demo {

  /*

a,b,c,d

b,b,f,e

a,a,c,f

c,c,a,d

   * 计算第四列每个元素出现的个数

   */

  def main(args: Array[String]): Unit = {

    val conf: SparkConf = new SparkConf().setAppName("demo").setMaster("local")

    val sc: SparkContext = new SparkContext(conf)

    val data: RDD[String] = sc.textFile("f://demo.txt")

    //数据切分

    val fourthData: RDD[(String, Int)] = data.map { x =>

      val arr: Array[String] = x.split(",")

      val fourth: String = arr(3)

      (fourth, 1)

    }

    val result: RDD[(String, Int)] = fourthData.reduceByKey(_ + _);

    println(result.collect().toBuffer)

  }

}

B、HDFS中有两个文件a.text与b.text,文件的格式为(ip,username),如：a.text,b.text

a.text

127.0.0.1  xiaozhang

127.0.0.1  xiaoli

127.0.0.2  wangwu

127.0.0.3  lisi

B.text

127.0.0.4  lixiaolu

127.0.0.5  lisi

每个文件至少有1000万行，请用程序完成一下工作，

1）每个文件的个子的IP

2)出现在b.text而没有出现在a.text的IP

3)每个user出现的次数以及每个user对应的IP的个数

代码如下：

1）各个文件的ip数

package cn.bigdata

import java.util.concurrent.Executors

import org.apache.hadoop.conf.Configuration

import org.apache.hadoop.fs.FileSystem

import org.apache.hadoop.fs.LocatedFileStatus

import org.apache.hadoop.fs.Path

import org.apache.hadoop.fs.RemoteIterator

import org.apache.spark.SparkConf

import org.apache.spark.SparkContext

import org.apache.spark.rdd.RDD

import org.apache.spark.rdd.RDD.rddToPairRDDFunctions

//各个文件的ip数

object Demo2 {

  val cachedThreadPool = Executors.newCachedThreadPool()

  def main(args: Array[String]): Unit = {

    val conf: SparkConf = new SparkConf().setAppName("demo2").setMaster("local")

    val sc: SparkContext = new SparkContext(conf)

    val hdpConf: Configuration = new Configuration

    val fs: FileSystem = FileSystem.get(hdpConf)

    val listFiles: RemoteIterator[LocatedFileStatus] = fs.listFiles(new Path("f://txt/2/"), true)

    while (listFiles.hasNext) {

      val fileStatus = listFiles.next

      val pathName = fileStatus.getPath.getName

      cachedThreadPool.execute(new Runnable() {

        override def run(): Unit = {

          println("=======================" + pathName)

          analyseData(pathName, sc)

        }

      })

    }

  }

  def analyseData(pathName: String, sc: SparkContext): Unit = {

    val data: RDD[String] = sc.textFile("f://txt/2/" + pathName)

    val dataArr: RDD[Array[String]] = data.map(_.split(" "))

    val ipAndOne: RDD[(String, Int)] = dataArr.map(x => {

      val ip = x(0)

      (ip, 1)

    })

    val counts: RDD[(String, Int)] = ipAndOne.reduceByKey(_ + _)

    val sortedSort: RDD[(String, Int)] = counts.sortBy(_._2, false)

    sortedSort.saveAsTextFile("f://txt/3/" + pathName)

  }

}

2）出现在b.txt而没有出现在a.txt的ip

package cn.bigdata

import java.util.concurrent.Executors

import org.apache.spark.SparkConf

import org.apache.spark.SparkContext

import org.apache.spark.rdd.RDD

/*

 * 出现在b.txt而没有出现在a.txt的ip

 */

object Demo3 {

  

  val cachedThreadPool = Executors.newCachedThreadPool()

  

  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setAppName("Demo3").setMaster("local")

    val sc = new SparkContext(conf)

    val data_a = sc.textFile("f://txt/2/a.txt")

    val data_b = sc.textFile("f://txt/2/b.txt")

    val splitArr_a = data_a.map(_.split(" "))

    val ip_a: RDD[String] = splitArr_a.map(x => x(0))

    val splitArr_b = data_b.map(_.split(" "))

    val ip_b: RDD[String] = splitArr_b.map(x => x(0))

    val subRdd: RDD[String] = ip_b.subtract(ip_a)

    subRdd.saveAsTextFile("f://txt/4/")

  }

}

3）

package cn.bigdata

import org.apache.spark.SparkConf

import org.apache.spark.SparkContext

import org.apache.spark.rdd.RDD

import scala.collection.mutable.Set

/*

 * 每个user出现的次数以及每个user对应的ip数

 */

object Demo4 {

  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setAppName("Demo4").setMaster("local")

    val sc = new SparkContext(conf)

    val data: RDD[String] = sc.textFile("f://txt/5/")

    val lines = data.map(_.split(" "))

    val userIpOne = lines.map(x => {

      val ip = x(0)

      val user = x(1)

      (user, (ip, 1))

    })

    val userListIpCount: RDD[(String, (Set[String], Int))] = userIpOne.combineByKey(

      x => (Set(x._1), x._2),

      (a: (Set[String], Int), b: (String, Int)) => {

        (a._1 + b._1, a._2 + b._2)

      },

      (m: (Set[String], Int), n: (Set[String], Int)) => {

        (m._1 ++ n._1, m._2 + n._2)

      })

    val result: RDD[String] = userListIpCount.map(x => {

      x._1 + ":userCount:" + x._2._2 + ",ipCount:" + x._2._1.size

    })

    println(result.collect().toBuffer)

  }

}

Sqoop 相关
10-1）sqoop在导入到MySql数据库是怎样保证数据重复，如果重复了该怎么办？？

在导入时在语句的后面加上一下命令作为节点：

--incremental append \

--check-column id \

--last-value 1208

Redis 相关
10-1）redis保存磁盘的时间
#   Note: you can disable saving at all commenting all the "save" lines.

#

#   It is also possible to remove all the previously configured save

#   points by adding a save directive with a single empty string argument

#   like in the following example:

#

#   save ""

save 900 1

save 300 10

save 60 10000

环境配置
1）你们的集群规模？
这个得看个人在公司的规模，下面介绍一下我们公司的一些配置：

联想System x3750  服务器，价格3.5万，内存容量32G，产品类型机架式，硬盘接口SSD,CPU频率2.6GH,CPU数量2颗，三级缓存15MB,cpu核心6核，cpu线程数12线程,最大内存支持1.5T,网络是千兆网卡,可插拔时硬盘接口12个卡槽,配置1T的容量

详细：http://detail.zol.com.cn/server/index1101243.shtml

名字                               软件                     运行管理

Hadoop1                           JDK,hadoop                namenode

Hadoop2                           JDK,hadoop                namenode

Hadoop3                           JDK,hadoop                secondaryNamenode

Hadoop4                           JDK,hadoop                secondaryNamenode

Hadoop5                           JDK,hadoop                datanode

Hadoop6                           JDK,hadoop                datanode

Hadoop7                           JDK,hadoop                datanode

Hadoop8                           JDK,hadoop                datanode

Hadoop9                           JDK,hadoop                datanode

Hadoop10                          JDK,zookeeper,tomcat,mvn,kafka leader

Hadoop11                          JDK,zookeeper,tomcat,mvn,kafka  follower

Hadoop12                          JDK,zookeeper,tomcat,mvn,kafka  follower

Hadoop13                          JDK,hive,mysql,svn,logstarh    hive,mysql,svn

Hadoop14                          JDK,hbase,mysql备份        datanode

Hadoop15                          JDK,nginx,Log日志手机       datanode

数据就是每天访问的Log日志不是很大，有的时候大有的时候小的可怜

2)你在项目中遇到了哪些难题，是怎么解决的？
1、在执行任务时发现副本的个数不对，经过一番的查找发现是超时的原因，修改了配置文件hdfs-site.xml：中修改了超时时间。

2、由于当时在分配各个目录空间大小时，没有很好的分配导致有的目录的空间浪费，于是整体商量后把储存的空间调大了一些。

设计题
1-1）采集nginx产生的日志，日志的格式为user  ip   time  url   htmlId  每天产生的文件的数据量上亿条，请设计方案把数据保存到HDFS上，并提供一下实时查询的功能（响应时间小于3s）

A、某个用户某天访问某个URL的次数

B、某个URL某天被访问的总次数

实时思路是：使用Logstash + Kafka + Spark-streaming + Redis + 报表展示平台

离线的思路是：Logstash + Kafka + Elasticsearch +  Spark-streaming + 关系型数据库

A、B、数据在进入到Spark-streaming 中进行过滤，把符合要求的数据保存到Redis中

                                      Hadoop就业面试宝典

1.0   简要描述如何安装配置apache的一个开源hadoop，只描述即可，无需列出具体步骤，列出具体步骤更好。

答：第一题：1使用root账户登录

2 修改IP

3 修改host主机名

4 配置SSH免密码登录

5 关闭防火墙

6  安装JDK

6 解压hadoop安装包

7 配置hadoop的核心文件 hadoop-env.sh，core-site.xml , mapred-site.xml ， hdfs-site.xml

8 配置hadoop环境变量

9 格式化 hadoop namenode-format

10 启动节点start-all.sh

2.0 请列出正常的hadoop集群中hadoop都分别需要启动 哪些进程，他们的作用分别都是什么，请尽量列的详细一些。

       答：namenode：负责管理hdfs中文件块的元数据，响应客户端请求，管理datanode上文件block的均衡，维持副本数量

Secondname:主要负责做checkpoint操作；也可以做冷备，对一定范围内数据做快照性备份。

Datanode:存储数据块，负责客户端对数据块的io请求

Jobtracker :管理任务，并将任务分配给 tasktracker。

Tasktracker: 执行JobTracker分配的任务。

Resourcemanager

Nodemanager

Journalnode

Zookeeper

Zkfc

3.0请写出以下的shell命令 

（1）杀死一个job

（2）删除hdfs上的 /tmp/aaa目录

（3）加入一个新的存储节点和删除一个节点需要执行的命令

答：（1）hadoop job –list   得到job的id，然后执   行 hadoop job  -kill  jobId就可以杀死一个指定jobId的job工作了。

（2）hadoopfs  -rmr /tmp/aaa

(3)  增加一个新的节点在新的几点上执行

            Hadoop  daemon.sh start  datanode

                     Hadooop daemon.sh  start  tasktracker/nodemanager

下线时，要在conf目录下的excludes文件中列出要下线的datanode机器主机名

              然后在主节点中执行  hadoop  dfsadmin  -refreshnodes  à下线一个datanode

删除一个节点的时候，只需要在主节点执行

 hadoop mradmin -refreshnodes  ---à下线一个tasktracker/nodemanager

4.0       请列出你所知道的hadoop调度器，并简要说明其工作方法

答：Fifo schedular :默认，先进先出的原则

Capacity schedular :计算能力调度器，选择占用最小、优先级高的先执行，依此类推。

Fair schedular:公平调度，所有的 job 具有相同的资源。

5.0       请列出你在工作中使用过的开发mapreduce的语言

答：java，hive，（python，c++）hadoop streaming

6.0       当前日志采样格式为

           a , b , c , d

           b , b , f , e

           a , a , c , f        

请你用最熟悉的语言编写mapreduce，计算第四列每个元素出现的个数

答：

public classWordCount1 {

       public static final String INPUT_PATH ="hdfs://hadoop0:9000/in";

       public static final String OUT_PATH ="hdfs://hadoop0:9000/out";

       public static void main(String[] args)throws Exception {

              Configuration conf = newConfiguration();

              FileSystem fileSystem =FileSystem.get(conf);

              if(fileSystem.exists(newPath(OUT_PATH))){}

              fileSystem.delete(newPath(OUT_PATH),true);

              Job job = newJob(conf,WordCount1.class.getSimpleName());

              //1.0读取文件，解析成key,value对

              FileInputFormat.setInputPaths(job,newPath(INPUT_PATH));

              //2.0写上自己的逻辑，对输入的可以，value进行处理，转换成新的key,value对进行输出

              job.setMapperClass(MyMapper.class);

              job.setMapOutputKeyClass(Text.class);

              job.setMapOutputValueClass(LongWritable.class);

              //3.0对输出后的数据进行分区

              //4.0对分区后的数据进行排序，分组，相同key的value放到一个集合中

              //5.0对分组后的数据进行规约

              //6.0对通过网络将map输出的数据拷贝到reduce节点

              //7.0 写上自己的reduce函数逻辑，对map输出的数据进行处理

              job.setReducerClass(MyReducer.class);

              job.setOutputKeyClass(Text.class);

              job.setOutputValueClass(LongWritable.class);

              FileOutputFormat.setOutputPath(job,new Path(OUT_PATH));

              job.waitForCompletion(true);

       }

       static class MyMapper extendsMapper<LongWritable, Text, Text, LongWritable>{

              @Override

              protected void map(LongWritablek1, Text v1,

                            org.apache.hadoop.mapreduce.Mapper.Contextcontext)

                            throws IOException,InterruptedException {

                     String[] split =v1.toString().split("\t");

                     for(String words :split){

                            context.write(split[3],1);

                     }

              }

       }

       static class MyReducer extends Reducer<Text,LongWritable, Text, LongWritable>{

             

              protected void reduce(Text k2,Iterable<LongWritable> v2,

                            org.apache.hadoop.mapreduce.Reducer.Contextcontext)

                            throws IOException,InterruptedException {

                     Long count = 0L;

                     for(LongWritable time :v2){

                            count += time.get();

                     }

                     context.write(v2, newLongWritable(count));

              }

       }

}

7.0       你认为用java ， streaming ， pipe方式开发map/reduce ， 各有哪些优点

就用过 java 和 hiveQL。

Java 写 mapreduce 可以实现复杂的逻辑，如果需求简单，则显得繁琐。

HiveQL 基本都是针对 hive 中的表数据进行编写，但对复杂的逻辑（杂）很难进行实现。写起来简单。

8.0 hive有哪些方式保存元数据，各有哪些优点

              三种：自带内嵌数据库derby，挺小，不常用，只能用于单节点

mysql常用

上网上找了下专业名称：single user mode..multiuser mode...remote user mode

9.0 请简述hadoop怎样实现二级排序（就是对key和value双排序）

    第一种方法是，Reducer将给定key的所有值都缓存起来，然后对它们再做一个Reducer内排序。但是，由于Reducer需要保存给定key的所有值，可能会导致出现内存耗尽的错误。

第二种方法是，将值的一部分或整个值加入原始key，生成一个组合key。这两种方法各有优势，第一种方法编写简单，但并发度小，数据量大的情况下速度慢(有内存耗尽的危险)，

第二种方法则是将排序的任务交给MapReduce框架shuffle，更符合Hadoop/Reduce的设计思想。这篇文章里选择的是第二种。我们将编写一个Partitioner，确保拥有相同key(原始key，不包括添加的部分)的所有数据被发往同一个Reducer，还将编写一个Comparator，以便数据到达Reducer后即按原始key分组。

10.简述hadoop实现jion的几种方法

Map side join----大小表join的场景，可以借助distributed cache

Reduce side join

11.0 请用java实现非递归二分查询

1.   public class BinarySearchClass  

2.   {  

3.     

4.       public static int binary_search(int[] array, int value)  

5.       {  

6.           int beginIndex = 0;// 低位下标  

7.           int endIndex = array.length - 1;// 高位下标  

8.           int midIndex = -1;  

9.           while (beginIndex <= endIndex) {  

10.              midIndex = beginIndex + (endIndex - beginIndex) / 2;//防止溢出  

11.              if (value == array[midIndex]) {  

12.                  return midIndex;  

13.              } else if (value < array[midIndex]) {  

14.                  endIndex = midIndex - 1;  

15.              } else {  

16.                  beginIndex = midIndex + 1;  

17.              }  

18.          }  

19.          return -1;  

20.          //找到了，返回找到的数值的下标，没找到，返回-1         

21.      }  

22.    

23.    

24.      //start 提示：自动阅卷起始唯一标识，请勿删除或增加。  

25.      public static void main(String[] args)  

26.      {  

27.          System.out.println("Start...");  

28.          int[] myArray = new int[] { 1, 2, 3, 5, 6, 7, 8, 9 };  

29.          System.out.println("查找数字8的下标：");  

30.          System.out.println(binary_search(myArray, 8));          

31.      }  

32.      //end //提示：自动阅卷结束唯一标识，请勿删除或增加。  

33.  }     

12.0 请简述mapreduce中的combine和partition的作用

答：combiner是发生在map的最后一个阶段，其原理也是一个小型的reducer，主要作用是减少输出到reduce的数据量，缓解网络传输瓶颈，提高reducer的执行效率。

partition的主要作用将map阶段产生的所有kv对分配给不同的reducer task处理，可以将reduce阶段的处理负载进行分摊

13.0 hive内部表和外部表的区别

Hive 向内部表导入数据时，会将数据移动到数据仓库指向的路径；若是外部表，数据的具体存放目录由用户建表时指定

在删除表的时候，内部表的元数据和数据会被一起删除， 

而外部表只删除元数据，不删除数据。

这样外部表相对来说更加安全些，数据组织也更加灵活，方便共享源数据。 

14. Hbase的rowKey怎么创建比较好？列簇怎么创建比较好？

答：

rowKey最好要创建有规则的rowKey，即最好是有序的。

经常需要批量读取的数据应该让他们的rowkey连续；

将经常需要作为条件查询的关键词组织到rowkey中；

列族的创建：

按照业务特点，把数据归类，不同类别的放在不同列族

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

本质：让各分区的数据分布均匀

可以根据业务特点，设置合适的partition策略

如果事先根本不知道数据的分布规律，利用随机抽样器抽样后生成partition策略再处理

16. hadoop框架怎么来优化

答：

可以从很多方面来进行：比如hdfs怎么优化，mapreduce程序怎么优化，yarn的job调度怎么优化，hbase优化，hive优化。。。。。。。

17. hbase内部机制是什么

答：

Hbase是一个能适应联机业务的数据库系统

物理存储：hbase的持久化数据是存放在hdfs上

存储管理：一个表是划分为很多region的，这些region分布式地存放在很多regionserver上

Region内部还可以划分为store，store内部有memstore和storefile

版本管理：hbase中的数据更新本质上是不断追加新的版本，通过compact操作来做版本间的文件合并

Region的split

集群管理：zookeeper  + hmaster（职责）  + hregionserver（职责）

18. 我们在开发分布式计算job的时候，是否可以去掉reduce阶段

答：可以，例如我们的集群就是为了存储文件而设计的，不涉及到数据的计算，就可以将mapReduce都省掉。

比如，流量运营项目中的行为轨迹增强功能部分

怎么样才能实现去掉reduce阶段

19 hadoop中常用的数据压缩算法

答：

Lzo

Gzip

Default

Snapyy

如果要对数据进行压缩，最好是将原始数据转为SequenceFile  或者 Parquet File（spark）

20. mapreduce的调度模式（题意模糊，可以理解为yarn的调度模式，也可以理解为mr的内部工作流程）

答： appmaster作为调度主管，管理maptask和reducetask

Appmaster负责启动、监控maptask和reducetask

Maptask处理完成之后，appmaster会监控到，然后将其输出结果通知给reducetask，然后reducetask从map端拉取文件，然后处理；

当reduce阶段全部完成之后，appmaster还要向resourcemanager注销自己

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

答：

Hive的查询功能是由hdfs + mapreduce结合起来实现的

Hive与mysql的关系：只是借用mysql来存储hive中的表的元数据信息，称为metastore

22. hbase过滤器实现原则

答：可以说一下过滤器的父类（比较过滤器，专用过滤器）

过滤器有什么用途：

增强hbase查询数据的功能

减少服务端返回给客户端的数据量

23. reduce之后数据的输出量有多大（结合具体场景，比如pi）

Sca阶段的增强日志（1.5T---2T）

过滤性质的mr程序，输出比输入少

解析性质的mr程序，输出比输入多（找共同朋友）

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

25.datanode在什么情况下不会备份数据

答：在客户端上传文件时指定文件副本数量为1

26.combine出现在哪个过程

答：shuffle过程中

具体来说，是在maptask输出的数据从内存溢出到磁盘，可能会调多次

Combiner使用时候要特别谨慎，不能影响最后的逻辑结果

27. hdfs的体系结构

答：

集群架构： 

namenode  datanode  secondarynamenode

 (active namenode ,standby namenode)journalnode  zkfc

内部工作机制：

数据是分布式存储的

对外提供一个统一的目录结构

对外提供一个具体的响应者（namenode）

数据的block机制，副本机制

Namenode和datanode的工作职责和机制

读写数据流程

28. flush的过程

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

29. 什么是队列

答：是一种调度策略，机制是先进先出

30. List与set的区别

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

31.数据的三范式

答：
第一范式（）无重复的列

第二范式（2NF）属性完全依赖于主键  [消除部分子函数依赖]
第三范式（3NF）属性不依赖于其它非主属性  [消除传递依赖]

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

答：

Namenode会通过心跳机制感知到datanode下线

会将这个datanode上的block块在集群中重新复制一份，恢复文件的副本数量

会引发运维团队快速响应，派出同事对下线datanode进行检测和修复，然后重新上线

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

答：

34.描述一下hadoop中，有哪些地方使用到了缓存机制，作用分别是什么？

答：

Shuffle中

Hbase----客户端/regionserver

35.MapReduce优化经验

答：(1.)设置合理的map和reduce的个数。合理设置blocksize

(2.)避免出现数据倾斜

(3.combine函数

(4.对数据进行压缩

(5.小文件处理优化：事先合并成大文件，combineTextInputformat，在hdfs上用mapreduce将小文件合并成SequenceFile大文件（key:文件名，value：文件内容）

(6.参数优化

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

答：/etc/profile这个文件，主要是用来配置环境变量。让hadoop命令可以在任意目录下面执行。

/ect/sudoers

/etc/hosts

/etc/sysconfig/network

/etc/inittab

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

38. 现有 1 亿个整数均匀分布，如果要得到前 1K 个最大的数，求最优的算法。

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

39.mapreduce的大致流程

答：主要分为八个步骤

1/对文件进行切片规划

2/启动相应数量的maptask进程

3/调用FileInputFormat中的RecordReader，读一行数据并封装为k1v1

4/调用自定义的map函数，并将k1v1传给map

5/收集map的输出，进行分区和排序

6/reduce task任务启动，并从map端拉取数据

7/reduce task调用自定义的reduce函数进行处理

8/调用outputformat的recordwriter将结果数据输出

41.用mapreduce实现sql语 select  count (x) from  a  group by b;

44.搭建hadoop集群 ， master和slaves都运行哪些服务

答：master主要是运行我们的主节点，slaves主要是运行我们的从节点。

45. hadoop参数调优

46. pig ,  latin  ,  hive语法有什么不同

答：

46. 描述Hbase，ZooKeeper搭建过程

48.hadoop运行原理

答：hadoop的主要核心是由两部分组成，HDFS和mapreduce，首先HDFS的原理就是分布式的文件存储系统，将一个大的文件，分割成多个小的文件，进行存储在多台服务器上。

Mapreduce的原理就是使用JobTracker和TaskTracker来进行作业的执行。Map就是将任务展开，reduce是汇总处理后的结果。

49.mapreduce的原理

答：mapreduce的原理就是将一个MapReduce框架由一个单独的master JobTracker和每个集群节点一个slave TaskTracker共同组成。master负责调度构成一个作业的所有任务，这些的slave上，master监控它们的执行，重新执行已经失败的任务。而slave仅负责执行由maste指派的任务。

50.HDFS存储机制

答：HDFS主要是一个分布式的文件存储系统，由namenode来接收用户的操作请求，然后根据文件大小，以及定义的block块的大小，将大的文件切分成多个block块来进行保存

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

Wordcount

52.如何确认hadoop集群的健康状况

答：有完善的集群监控体系（ganglia，nagios）

Hdfs dfsadmin –report

Hdfs haadmin  –getServiceState  nn1

53.mapreduce作业，不让reduce输出，用什么代替reduce的功能。

54.hive如何调优

答：hive最终都会转化为mapreduce的job来运行，要想hive调优，实际上就是mapreduce调优，可以有下面几个方面的调优。解决收据倾斜问题，减少job数量，设置合理的map和reduce个数，对小文件进行合并，优化时把我整体，单个task最优不如整体最优。按照一定规则分区。

55.hive如何控制权限

我们公司没做，不需要

56.HBase写数据的原理是什么？

答：

57.hive能像关系型数据库那样建多个库吗？

答：当然能了。

58.HBase宕机如何处理

答：宕机分为HMaster宕机和HRegisoner宕机，如果是HRegisoner宕机，HMaster会将其所管理的region重新分布到其他活动的RegionServer上，由于数据和日志都持久在HDFS中，该操作不会导致数据丢失。所以数据的一致性和安全性是有保障的。

如果是HMaster宕机，HMaster没有单点问题，HBase中可以启动多个HMaster，通过Zookeeper的Master Election机制保证总有一个Master运行。即ZooKeeper会保证总会有一个HMaster在对外提供服务。

59.假设公司要建一个数据中心，你会如何处理？

先进行需求调查分析

设计功能划分

架构设计

吞吐量的估算

采用的技术类型

软硬件选型

成本效益的分析

项目管理

扩展性

安全性，稳定性

60. 单项选择题

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

a)NameNode  b)Jobtracker   c)Datanoded)secondaryNameNode  e)tasktracker

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

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

3.  下列哪个程序通常与  NameNode 在一个节点启动？

a)SecondaryNameNode b)DataNodec)TaskTracker d)Jobtracker e)zkfc

4. Hadoop 作者          答案D

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

5. HDFS 默认  Block Size  答案 B    [M1] 

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

6.  下列哪项通常是集群的最主要瓶颈  答案D[M2] 

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

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

a)它是NameNode的热备    

b)它对内存没有要求

c)它的目的是帮助  NameNode 合并编辑日志，减少  NameNode 启动时间

d)SecondaryNameNode  应与  NameNode  部署到一个节点

多选题：

8.  下列哪项可以作为集群的管理工具    答案  ABCD

a)Puppet b)Pdsh c)Cloudera Manager  d)Zookeeper

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

a)如果一个机架出问题，不会影响数据读写

b)写入数据的时候会写到不同机架的  DataNode  中

c)MapReduce 会根据机架获取离自己比较近的网络数据

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

a)数据经过  NameNode  传递给  DataNode

b)Client 端将文件切分为  Block，依次上传

c)Client 只上传数据到一台  DataNode，然后由  NameNode  负责  Block  复制工作

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

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

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

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

判断题：全部都是错误滴

13. Ganglia 不仅可以进行监控，也可以进行告警。（  ）

14. Block Size  是不可以修改的。（  ）

15. Nagios 不可以监控  Hadoop 集群，因为它不提供  Hadoop 支持。（  ）

16.  如果 NameNode  意外终止， SecondaryNameNode  会接替它使集群继续工作。（  ）

17. Cloudera CDH  是需要付费使用的。（  ）

18. Hadoop 是  Java  开发的，所以  MapReduce 只支持  Java  语言编写。（  ）

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

20. NameNode  负责管理  metadata， client  端每次读写请求，它都会从磁盘中读取或则

会写入  metadata 信息并反馈  client 端。（  ）

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

22. DataNode  通过长连接与  NameNode  保持通信。（  ）

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

24. Slave节点要存储数据，所以它的磁盘越大越好。（  ）

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

26. Hadoop 默认调度器策略为  FIFO（  ）

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

28.  因为 HDFS  有多个副本，所以  NameNode 是不存在单点问题的。（  ）

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

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

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

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

33. DataNode  首次加入 cluster  的时候，如果  log中报告不兼容文件版本，那需要

NameNode执行“Hadoop namenode -format”操作格式化磁盘。（  ）

63. 谈谈 hadoop1 和 hadoop2 的区别

答：

hadoop1的主要结构是由HDFS和mapreduce组成的，HDFS主要是用来存储数据，mapreduce主要是用来计算的，那么HDFS的数据是由namenode来存储元数据信息，datanode来存储数据的。Jobtracker接收用户的操作请求之后去分配资源执行task任务。

在hadoop2中，首先避免了namenode单点故障的问题，使用两个namenode来组成namenode  feduration的机构，两个namenode使用相同的命名空间，一个是standby状态，一个是active状态。用户访问的时候，访问standby状态，并且，使用journalnode来存储数据的原信息，一个namenode负责读取journalnode中的数据，一个namenode负责写入journalnode中的数据，这个平台组成了hadoop的HA就是high  availableAbility高可靠。

然后在hadoop2中没有了jobtracker的概念了，统一的使用yarn平台来管理和调度资源，yarn平台是由resourceManager和NodeManager来共同组成的，ResourceManager来接收用户的操作请求之后，去NodeManager上面启动一个主线程负责资源分配的工作，然后分配好了资源之后告知ResourceManager，然后ResourceManager去对应的机器上面执行task任务。

64. 说说值对象与引用对象的区别？

65. 谈谈你对反射机制的理解及其用途？

答：java中的反射，首先我们写好的类，经过编译之后就编程了.class文件，我们可以获取这个类的.class文件，获取之后，再来操作这个类。这个就是java的反射机制。

66. ArrayList、Vector、LinkedList 的区别及其优缺点？HashMap、HashTable 的区别及其优缺点？

答：ArrayList 和Vector是采用数组方式存储数据， ，Vector由于使用了synchronized方法（线程安全）所以性能上比ArrayList要差，LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项的前后项即可，所以插入数度较快！

HashMap和HashTable：Hashtable的方法是同步的，而HashMap的方法不是，Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。HashMap是一个线程不同步的，那么就意味着执行效率高，HashTable是一个线程同步的就意味着执行效率低，但是HashMap也可以将线程进行同步，这就意味着，我们以后再使用中，尽量使用HashMap这个类。

67. 文件大小默认为 64M，改为 128M 有啥影响？

答：更改文件的block块大小，需要根据我们的实际生产中来更改block的大小，如果block定义的太小，大的文件都会被切分成太多的小文件，减慢用户上传效率，如果block定义的太大，那么太多的小文件可能都会存到一个block块中，虽然不浪费硬盘资源，可是还是会增加namenode的管理内存压力。

69. RPC 原理？

答：

1.调用客户端句柄；执行传送参数

2.调用本地系统内核发送网络消息

3. 消息传送到远程主机

4. 服务器句柄得到消息并取得参数

5. 执行远程过程

6. 执行的过程将结果返回服务器句柄

7. 服务器句柄返回结果，调用远程系统内核

8. 消息传回本地主机

9. 客户句柄由内核接收消息

10. 客户接收句柄返回的数据

70. 对 Hadoop 有没有调优经验，没有什么使用心得？（调优从参数调优讲起）

dfs.block.size

Mapredure：

io.sort.mb

io.sort.spill.percent

mapred.local.dir

mapred.map.tasks &mapred.tasktracker.map.tasks.maximum

mapred.reduce.tasks &mapred.tasktracker.reduce.tasks.maximum

mapred.reduce.max.attempts

mapred.reduce.parallel.copies
 

mapreduce.reduce.shuffle.maxfetchfailures

mapred.child.java.opts

mapred.reduce.tasks.speculative.execution

mapred.compress.map.output &mapred.map.output.compression.codec

mapred.reduce.slowstart.completed.maps

72以你的实际经验，说下怎样预防全表扫描

答：

1.应尽量避免在where 子句中对字段进行null 值判断，否则将导致引擎放弃使用索引而进行全表扫描
2.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫

3.描应尽量避免在 where 子句中使用or 来连接条件，否则将导致引擎放弃使用索引而进行

全表扫描

4.in 和 not  in，用具体的字段列表代替，不要返回用不到的任何字段。in 也要慎用，否则会导致全表扫描

5.避免使用模糊查询
6.任何地方都不要使用select* from t

73. zookeeper 优点，用在什么场合

答：极大方便分布式应用的开发；（轻量，成本低，性能好，稳定性和可靠性高）

75.把公钥追加到授权文件的命令？该命令是否在 root 用户下执行？

答：ssh-copy-id

哪个用户需要做免密登陆就在哪个用户身份下执行

76. HadoopHA 集群中各个服务的启动和关闭的顺序？

答：

77. 在 hadoop 开发过程中使用过哪些算法？其应用场景是什么？

答：排序，分组，topk，join，group

78. 在实际工作中使用过哪些集群的运维工具，请分别阐述期作用。

答：nmon   ganglia   nagios

79. 一台机器如何应对那么多的请求访问，高并发到底怎么实现，一个请求怎么产生的，

在服务端怎么处理的，最后怎么返回给用户的，整个的环节操作系统是怎么控制的？

80. java 是传值还是传址？

答：引用传递。

81. 问：你们的服务器有多少台？

82. 问：你们服务器的内存多大？

83. hbase 怎么预分区？

建表时可以通过shell命令预分区，也可以在代码中建表做预分区

《具体命令详见笔记汇总》

84. hbase 怎么给 web 前台提供接口来访问（HTABLE可以提供对 HBase的访问，但是怎么查询同一条记录的多个版本数据）？

答：使用HTable来提供对HBase的访问，可以使用时间戳来记录一条数据的多个版本。

85. .htable API 有没有线程安全问题，在程序中是单例还是多例？[M4] 

86. 你们的数据是用什么导入到数据库的？导入到什么数据库？

处理完成之后的导出：利用hive 处理完成之后的数据，通过sqoop 导出到 mysql 数据库

中，以供报表层使用。                                                                                         

87. 你们业务数据量多大？有多少行数据？(面试了三家，都问这个问题)

开发时使用的是部分数据，不是全量数据，有将近一亿行（8、9 千万，具体不详，一般开

发中也没人会特别关心这个问题）

88. 你们处理数据是直接读数据库的数据还是读文本数据？

将日志数据导入到 hdfs 之后进行处理

89. 你们写 hive 的 hql 语句，大概有多少条？

不清楚，我自己写的时候也没有做过统计

90. 你们提交的 job 任务大概有多少个？这些job 执行完大概用多少时间？(面试了三家，都问这个问题)

没统计过，加上测试的，会与很多

Sca阶段，一小时运行一个job，处理时间约12分钟

Etl阶段，有2千多个job，从凌晨12:00开始次第执行，到早上5点左右全部跑完

91. hive 跟 hbase 的区别是？

答：

92. 你在项目中主要的工作任务是？

Leader

预处理系统、手机位置实时查询系统，详单系统，sca行为轨迹增强子系统，内容识别中的模板匹配抽取系统

设计、架构、技术选型、质量把控，进度节点把握。。。。。。

93. 你在项目中遇到了哪些难题，是怎么解决的？

Storm获取实时位置信息动态端口的需求

101. job 的运行流程(提交一个 job 的流程)？

102Hadoop 生态圈中各种框架的运用场景？

103. hive 中的压缩格式 RCFile、TextFile、SequenceFile [M5] 各有什么区别？

以上 3 种格式一样大的文件哪个占用空间大小..等等

104假如：Flume 收集到的数据很多个小文件,我需要写 MR 处理时将这些文件合并

(是在 MR 中进行优化,不让一个小文件一个 MapReduce)

他们公司主要做的是中国电信的流量计费为主,专门写 MR。

105. 解释“hadoop”和“hadoop 生态系统”两个概念

109. MapReduce 2.0”与“YARN”是否等同，尝试解释说明

MapReduce 2.0  --àmapreduce + yarn

110. MapReduce 2.0 中，MRAppMaster 主要作用是什么，MRAppMaster 如何实现任务

容错的？

111. 为什么会产生 yarn,它解决了什么问题，有什么优势？

114. 数据备份,你们是多少份,如果数据超过存储容量,你们怎么处理？

115. 怎么提升多个 JOB 同时执行带来的压力,如何优化,说说思路？

116. 你们用 HBASE 存储什么数据？

流量详单

117. 你们的 hive 处理数据能达到的指标是多少？

118.hadoop中RecorderReader的作用是什么？？？

1、   在hadoop中定义的主要公用InputFormat中，哪个是默认值？ FileInputFormat

2、  两个类TextInputFormat和KeyValueInputFormat的区别是什么？

       答：TextInputFormat主要是用来格式化输入的文本文件的，KeyValueInputFormat则主要是用来指定输入输出的key,value类型的

3、  在一个运行的hadoop任务中，什么是InputSplit？

       InputSplit是InputFormat中的一个方法，主要是用来切割输入文件的，将输入文件切分成多个小文件，

       然后每个小文件对应一个map任务

      

4、  Hadoop框架中文件拆分是怎么调用的？

       InputFormat  --> TextInputFormat  -->RecordReader  --> LineRecordReader  --> LineReader

5、  参考下列M/R系统的场景：hdfs块大小为64MB，输入类为FileInputFormat，有3个文件的大小分别为64KB, 65MB, 127MB

会产生多少个maptask   4个    65M这个文件只有一个切片《原因参见笔记汇总TextInputformat源码分析部分》

8、  如果没有自定义partitioner，那数据在被送达reducer前是如何被分区的？

       hadoop有一个默认的分区类，HashPartioer类，通过对输入的k2去hash值来确认map输出的k2,v2送到哪一个reduce中去执行。

10、分别举例什么情况要使用 combiner，什么情况不使用？

       求平均数的时候就不需要用combiner，因为不会减少reduce执行数量。在其他的时候，可以依据情况，使用combiner，来减少map的输出数量，减少拷贝到reduce的文件，从而减轻reduce的压力，节省网络开销，提升执行效率

11、Hadoop中job和tasks之间的区别是什么？

Job是我们对一个完整的mapreduce程序的抽象封装

Task是job运行时，每一个处理阶段的具体实例，如map task，reduce task，maptask和reduce task都会有多个并发运行的实例

12、hadoop中通过拆分任务到多个节点运行来实现并行计算，但某些节点运行较慢会拖慢整个任务的运行，hadoop采用全程机制应对这个情况？

Speculate 推测执行

14、有可能使hadoop任务输出到多个目录中吗？如果可以，怎么做？

       自定义outputformat或者用multioutputs工具

15、如何为一个hadoop任务设置mappers的数量？

Split机制

16、如何为一个hadoop任务设置要创建reduder的数量？

可以通过代码设置

具体设置多少个，应该根据硬件配置和业务处理的类型来决定

下面是HBASE我非常不懂的地方：

1.hbase怎么预分区？

2.hbase怎么给web前台提供接口来访问（HTABLE可以提供对HTABLE的访问，但是怎么查询同一条记录的多个版本数据）？

3.htable API有没有线程安全问题，在程序中是单例还是多例？

4.我们的hbase大概在公司业务中（主要是网上商城）大概4个表，几个表簇，大概都存什么样的数据？

下面的Storm的问题：

1.metaq消息队列 zookeeper集群 storm集群（包括zeromq,jzmq,和storm本身）就可以完成对商城推荐系统功能吗？还有没有其他的中间件？

mahout

2.storm怎么完成对单词的计数？

本文引用自神之子《hadoop面试可能遇到的问题》

Q1. Name the most common InputFormats defined in Hadoop? Which one is default ? 
Following 2 are most common InputFormats defined in Hadoop 
- TextInputFormat
- KeyValueInputFormat
- SequenceFileInputFormat

Q2. What is the difference betweenTextInputFormatand KeyValueInputFormat class 
TextInputFormat:It reads lines of text files and provides the offset of the line as key to theMapper and actual line as Value to the mapper
KeyValueInputFormat:Reads text file and parses lines into key, val pairs. Everything up to thefirst tab character is sent as key to the Mapper and the remainder of the lineis sent as value to the mapper.

Q3. What is InputSplit in Hadoop

When a hadoop job is run, it splits input files into chunksand assign each split to a mapper to process. This is called Input Split 

Q4. How is the splitting of file invokedin Hadoop Framework  

It is invoked by the Hadoop framework by runninggetInputSplit()method of the Input format class (like FileInputFormat) definedby the user 

Q5. Consider case scenario: In M/R system,

    - HDFS block size is 64MB

    - Input format isFileInputFormat

    - We have 3 files ofsize 64K, 65Mb and 127Mb 

then how many input splits will be madeby Hadoop framework?

Hadoop will make 5splits as follows 

- 1 split for 64K files 

- 2  splits for 65Mb files 

- 2 splits for 127Mb file 

Q6. What is the purpose of RecordReaderin Hadoop

The InputSplithas defined a slice of work,but does not describe how to access it. The RecordReaderclass actually loadsthe data from its source and converts it into (key, value) pairs suitable forreading by the Mapper. The RecordReader instance is defined by theInputFormat 

Q7. After the Map phase finishes,the hadoop framework does"Partitioning, Shuffle and sort". Explain what happens in this phase?

- Partitioning

Partitioning is the process of determiningwhich reducer instance will receive which intermediate keys and values. Eachmapper must determine for all of its output (key, value) pairs which reducerwill receive them. It is necessary that for any key, regardless of which mapperinstance generated it, the destination partition is the same

- Shuffle

After the first map tasks have completed,the nodes may still be performing several more map tasks each. But they alsobegin exchanging the intermediate outputs from the map tasks to where they arerequired by the reducers. This process of moving map outputs to the reducers isknown as shuffling.

- Sort

Each reduce task is responsible forreducing the values associated with several intermediate keys. The set ofintermediate keys on a single node is automatically sorted by Hadoop before they are presented tothe Reducer 

Q9. If no custom partitioner is defined inthe hadoop then how is datapartitioned before its sent to the reducer  

The default partitioner computes a hashvalue for the key and assigns the partition based on this result 

Q10. What is a Combiner 

The Combiner is a "mini-reduce"process which operates only on data generated by a mapper. The Combiner willreceive as input all data emitted by the Mapper instances on a given node. Theoutput from the Combiner is then sent to the Reducers, instead of the outputfrom the Mappers.

Q11. Give an example scenario where a cobiner can be usedand where it cannot be used

There can be several examples following are the mostcommon ones

- Scenario where you can use combiner

  Getting list of distinct words in a file

- Scenario where you cannot use a combiner

  Calculating mean of a list of numbers 

Q12. What is job tracker

Job Tracker is the service within Hadoop that runs Map Reduce jobs onthe cluster

Q13. What are some typical functions ofJob Tracker

The following are some typical tasks ofJob Tracker

- Accepts jobs from clients

- It talks to the NameNode todetermine the location of the data

- It locates TaskTracker nodes withavailable slots at or near the data

- It submits the work to the chosenTask Tracker nodes and monitors progress of each task by receiving heartbeatsignals from Task tracker 

Q14. What is task tracker

Task Tracker is a node in the cluster thataccepts tasks like Map, Reduce and Shuffle operations - from a JobTracker 

Q15. Whats the relationship between Jobsand Tasks in Hadoop

One job is broken down into one or manytasks in Hadoop. 

Q16. Suppose Hadoop spawned 100 tasks for a job and one of the taskfailed. What willhadoop do ?

It will restart the task again on someother task tracker and only if the task fails more than 4 (default setting andcan be changed) times will it kill the job

Q17. Hadoop achievesparallelism by dividing the tasks across many nodes, it is possible for a fewslow nodes to rate-limit the rest of the program and slow down the program.What mechanism Hadoop providesto combat this  

Speculative Execution 

Q18. How does speculative execution worksin Hadoop  

Job tracker makes different task trackersprocess same input. When tasks complete, they announce this fact to the JobTracker. Whichever copy of a task finishes first becomes the definitive copy.If other copies were executing speculatively, Hadoop tells the Task Trackers to abandon the tasksand discard their outputs. The Reducers then receive their inputs fromwhichever Mapper completed successfully, first. 

Q19. Using command line in Linux, how willyou 

- see all jobs running in the hadoop cluster

- kill a job

- hadoop job-list

- hadoop job-kill jobid 

Q20. What is Hadoop Streaming  

Streaming is a generic API that allowsprograms written in virtually any language to be used asHadoop Mapper and Reducerimplementations 

Q21. What is the characteristic ofstreaming API that makes it flexible run map reduce jobs in languages likeperl, ruby, awk etc.  

Hadoop Streamingallows to use arbitrary programs for the Mapper and Reducer phases of a MapReduce job by having both Mappers and Reducers receive their input on stdin andemit output (key, value) pairs on stdout.

Q22. Whats is Distributed Cache in Hadoop
Distributed Cache is a facility provided by the Map/Reduce framework to cachefiles (text, archives, jars and so on) needed by applications during executionof the job. The framework will copy the necessary files to the slave nodebefore any tasks for the job are executed on that node.

Q23. What is the benifit of Distributedcache, why can we just have the file in HDFS and have the application read it 
This is because distributed cache is much faster. It copies the file to alltrackers at the start of the job. Now if the task tracker runs 10 or 100mappers or reducer, it will use the same copy of distributed cache. On theother hand, if you put code in file to read it from HDFS in the MR job thenevery mapper will try to access it from HDFS hence if a task tracker run 100map jobs then it will try to read this file 100 times from HDFS. Also HDFS isnot very efficient when used like this.

Q.24 What mechanism does Hadoop frameworkprovides to synchronize changes made in Distribution Cache during runtime ofthe application  
This is a trick questions.There is no such mechanism. Distributed Cache by design is read only during thetime of Job execution

Q25. Have you ever used Counters in Hadoop.Give us an example scenario 
Anybody who claims to have worked on a Hadoop projectis expected to use counters

Q26. Is it possible to provide multiple input to Hadoop? If yes then how can you give multipledirectories as input to the Hadoop job 
Yes, The input format class provides methods to add multiple directories asinput to a Hadoop job

Q27. Is it possible to have Hadoop joboutput in multiple directories. If yes then how  
Yes, by using Multiple Outputs class

Q28. What will a hadoop jobdo if you try to run it with an output directory that is already present? Willit
- overwrite it
- warn you and continue
- throw an exception and exit
The hadoop job willthrow an exception and exit.

Q29. How can you set an arbitary number of mappers to be created for ajob in Hadoop  
This is a trick question. You cannot set it

Q30. How can you set an arbitary number of reducers to be created for ajob in Hadoop  
You can either do it progamatically by using method setNumReduceTasksin theJobConfclass or set it up as a configuration setting

 [M1]分版本

 [M2]分运算密集型和IO密集型

 [M3]题目很滥，但是机架感知确实可以了解一下：

有一个配置文件用来描述机架的拓扑结构

 [M4]

 [M5]参见笔记

--------------------- 
作者：首席撩妹指导官 
来源：CSDN 
原文：https://blog.csdn.net/qq_36864672/article/details/78499381 
版权声明：本文为博主原创文章，转载请附上博文链接！