hadoop面试题总结1

青旅半醒 2022-08-02 00:25 191阅读 0赞

1. 下面哪个程序负责 HDFS 数据存储。  
a)NameNode  b)Jobtracker  c)Datanode d)secondaryNameNode e)tasktracker  
  
答案C datanode  
  
2. HDfS 中的  [block][]  默认保存几份？  
a)3 份 b)2 份c)1 份d)不确定  
  
答案A默认3分  
![031259g9eeu7bagqp0efax.jpg][]  
3. 下列哪个程序通常与 NameNode 在一个节点启动？  
a)SecondaryNameNode b)DataNode c)TaskTracker d)Jobtracker  
  
答案D  
分析：  
hadoop的集群是基于master/slave模式，namenode和jobtracker属于master，datanode和tasktracker属于slave，master只有一个，而slave有多个  
  
SecondaryNameNode内存需求和NameNode在一个数量级上，所以通常secondary NameNode（运行在单独的物理机器上）和NameNode运行在不同的机器上。  
JobTracker和TaskTracker  
JobTracker  对应于 NameNode  
TaskTracker 对应于 DataNode  
DataNode 和NameNode 是针对数据存放来而言的  
JobTracker和TaskTracker是对于MapReduce执行而言的  
  
mapreduce中几个主要概念，mapreduce整体上可以分为这么几条执行线索：  
[job][]client，JobTracker与TaskTracker。  
1、JobClient会在用户端通过JobClient类将应用已经配置参数打包成jar文件存储到hdfs，  
并把路径提交到Jobtracker,然后由JobTracker创建每一个Task（即MapTask和ReduceTask）  
并将它们分发到各个TaskTracker服务中去执行  
2、JobTracker是一个master服务，软件启动之后JobTracker接收Job，负责调度Job的每一个子任务task运行于TaskTracker上，  
并[监控][Link 1]它们，如果发现有失败的task就重新运行它。一般情况应该把JobTracker部署在单独的机器上。  
3、TaskTracker是运行在多个节点上的slaver服务。TaskTracker主动与JobTracker通信，接收作业，并负责直接执行每一个任务。  
TaskTracker都需要运行在HDFS的DataNode上  
  
  
  
  
4. Hadoop 作者  
a)Martin Fowler b)Kent Beck c)Doug cutting   
  
答案C Doug cutting   
  
  
5. HDFS 默认 Block Size  
a)32MB  b)64MB c)128MB  
  
答案：B  
(因为版本更换较快，这里答案只供参考)  
  
6. 下列哪项通常是集群的最主要瓶颈  
a)CPU   b)网络 c)磁盘IO  d)内存  
  
答案：C磁盘  
首先集群的目的是为了节省成本，用廉价的pc机，取代小型机及大型机。小型机和大型机有什么特点？  
  
1.cpu处理能力强  
2.内存够大  
所以集群的瓶颈不可能是a和d  
3.网络是一种稀缺资源，但是并不是瓶颈。   
  
4.由于大数据面临海量数据，读写数据都需要io，然后还要冗余数据，hadoop一般备3份数据，所以IO就会打折扣。  
同样可以参考下面内容 （磁盘IO：磁盘输出输出）  
对于磁盘IO：当我们面临集群作战的时候，我们所希望的是即读即得。可是面对大数据，读取数据需要经过IO，这里可以把IO理解为水的管道。管道越大越强，我们对于T级的数据读取就越快。所以IO的好坏，直接影响了集群对于数据的处理。  
[集群瓶颈：磁盘IO必读][IO]  
[集群瓶颈为什么磁盘io][io]  
  
  
  
7. 关于 SecondaryNameNode 哪项是正确的？  
a)它是 NameNode 的热备     b)它对内存没有要求  
c)它的目的是帮助 NameNode 合并编辑日志，减少 NameNode 启动时间  
d)SecondaryNameNode 应与 NameNode 部署到一个节点  
  
答案C。  
D答案可以参考第三题  
  
多选题：  
8. 下列哪项可以作为集群的管理？  
a)Puppet b)Pdsh c)Cloudera Manager d)Zookeeper  
  
答案1：ABD  
具体可查看  
[什么是Zookeeper，Zookeeper的作用是什么，在Hadoop及hbase中具体作用是什么][Zookeeper_Zookeeper_Hadoop_hbase]  
二次整理  
修改后答案：ABC  
分析：  
A：puppetpuppet是一种Linux、Unix、windows平台的集中配置管理系统  
B：pdsh可以实现在 在多台机器上执行相同的命令  
详细参考：[集群管理小工具介绍-pdsh][-pdsh]  
C：可以参考 [Cloudera Manager四大功能【翻译】][Cloudera Manager]  
首先这里给管理下一个定义：部署、配置、调试、 [监控][Link 1] ，属于管理  
因为zookeeper不满足上面要求，所以不纳入管理范围。  
  
  
  
9. 配置机架感知的下面哪项正确  
a)如果一个机架出问题，不会影响数据读写  
b)写入数据的时候会写到不同机架的 DataNode 中  
c)MapReduce 会根据机架获取离自己比较近的网络数据  
  
答案ABC  
具体可以参考  
[hadoop机架感知--加强集群稳固性，该如何配置hadoop机架感知][hadoop_--_hadoop]  
  
  
10. Client 端上传文件的时候下列哪项正确  
a)数据经过 NameNode 传递给 DataNode  
b)Client 端将文件切分为 Block，依次上传  
c)Client 只上传数据到一台 DataNode，然后由 NameNode 负责 Block 复制工作  
答案B  
分析：  
Client向NameNode发起文件写入的请求。  
  
  
NameNode根据文件大小和文件块配置情况，返回给Client它所管理部分DataNode的信息。  
  
  
Client将文件划分为多个Block，根据DataNode的地址信息，按顺序写入到每一个DataNode块中。  
具体查看  
[HDFS体系结构简介及优缺点][HDFS]  
  
  
11. 下列哪个是 Hadoop 运行的模式  
a)单机版 b)伪分布式 c)分布式  
  
答案ABC  
  
  
  
12. Cloudera 提供哪几种安装 CDH 的方法  
a)Cloudera manager b)Tarball c)Yum d)Rpm  
答案：ABCD具体可以参考  
[Hadoop CDH四种安装方式总结及实例指导][Hadoop CDH]  
  
判断题：  
13. Ganglia 不仅可以进行 [监控][Link 1] ，也可以进行告警。（ 正确）  
分析：  
此题的目的是考Ganglia的了解。严格意义上来讲是正确。  
  
ganglia作为一款最常用的Linux环境中的[监控软件][Link 2]，它擅长的的是从节点中按照用户的需求以较低的代价采集数据。但是ganglia在预警以及发生事件后通知用户上并不擅长。最新的ganglia已经有了部分这方面的功能。但是更擅长做警告的还有 Nagios。 Nagios，就是一款精于预警、通知的软件。通过将Ganglia和Nagios组合起来，把Ganglia采集的数据作为Nagios的数据源，然后利用Nagios来发送预警通知，可以完美的实现一整套[监控][Link 1]管理的系统。  
具体可以查看  
[完美集群监控组合ganglia和nagios][ganglia_nagios]  
  
14. Block Size 是不可以修改的。（错误 ）  
它是可以被修改的  
  
Hadoop的基础配置文件是hadoop-default.xml，默认建立一个Job的时候会建立Job的Config，Config首先读入hadoop-default.xml的配置，然后再读入hadoop-site.xml的配置（这个文件初始的时候配置为空），hadoop-site.xml中主要配置需要覆盖的hadoop-default.xml的系统级配置。具体配置可以参考下

1.  <property>  
    
2.    <name>dfs.block.size</name>//block的大小，单位字节，后面会提到用处，必须是512的倍数，因为采用crc作文件完整性校验，默认配置512是checksum的最小单元。  
    
3.    <value>5120000</value>  
    
4.    <description>The default [block][] size for new files.</description>  
    
5.  </property>

*复制代码*

15. Nagios 不可以监控 Hadoop 集群，因为它不提供 Hadoop 支持。（错误 ）  
  
分析：  
Nagios是集群监控工具，而且是[云计算][Link 3]三大利器之一  
  
16. 如果 NameNode 意外终止，SecondaryNameNode 会接替它使集群继续工作。（错误 ）  
  
分析：  
SecondaryNameNode是帮助恢复，而不是替代，如何恢复，可以查看  
[hadoop 根据SecondaryNameNode恢复Namenode][hadoop _SecondaryNameNode_Namenode]  
  
  
17. Cloudera CDH 是需要付费使用的。（错误 ）  
  
分析：  
第一套付费产品是Cloudera Enterpris，Cloudera Enterprise在美国加州举行的 Hadoop 大会 (Hadoop Summit) 上公开，以若干私有管理、[监控][Link 1]、运作工具加强 Hadoop 的功能。收费采取合约订购方式，价格随用的 Hadoop 叢集大小变动。  
  
18. Hadoop 是 Java 开发的，所以 MapReduce 只支持 Java 语言编写。（错误 ）  
  
分析：  
rhadoop是用R语言开发的，MapReduce是一个框架，可以理解是一种思想，可以使用其他语言开发。  
具体可以查看  
[Hadoop简介(1):什么是Map/Reduce][Hadoop_1_Map_Reduce]  
  
  
19. Hadoop 支持数据的随机读写。（错 ）  
  
分析：  
lucene是支持随机读写的，而hdfs只支持随机读。但是HBase可以来补救。  
HBase提供随机读写，来解决Hadoop不能处理的问题。HBase自底层设计开始即聚焦于各种可伸缩性问题：表可以很“高”，有数十亿个数据行；也可以很“宽”，有数百万个列；水平分区并在上千个普通商用机节点上自动复制。表的模式是物理存储的直接反映，使系统有可能提高高效的数据结构的序列化、存储和检索。  
  
  
20. NameNode 负责管理 metadata，client 端每次读写请求，它都会从磁盘中读取或则会写入 metadata 信息并反馈 client 端。（错误）  
  
  
修改后分析：  
分析：  
NameNode 不需要从 磁盘 读取 metadata，所有数据都在内存中，硬盘上的只是序列化的结果，只有每次 namenode 启动的时候才会读取。  
1）文件写入  
    Client向NameNode发起文件写入的请求。  
    NameNode根据文件大小和文件块配置情况，返回给Client它所管理部分DataNode的信息。  
    Client将文件划分为多个Block，根据DataNode的地址信息，按顺序写入到每一个DataNode块中。  
  
  
2）文件读取  
    Client向NameNode发起文件读取的请求。  
    NameNode返回文件存储的DataNode的信息。  
    Client读取文件信息。  
  
具体查看  
[hadoop中NameNode、DataNode和Client三者之间协作关系][hadoop_NameNode_DataNode_Client]  
  
  
  
  
21. NameNode 本地磁盘保存了 Block 的位置信息。（ 个人认为正确，欢迎提出其它意见）  
  
分析：  
DataNode是文件存储的基本单元，它将Block存储在本地文件系统中，保存了Block的Meta-data，同时周期性地将所有存在的Block信息发送给NameNode。  
  
具体同样查看  
[hadoop中NameNode、DataNode和Client三者之间协作关系][hadoop_NameNode_DataNode_Client]

另简介，namenode不保存block的位置信息，只是在启动的时候加载datanide信息，并保存在内存里面

22. DataNode 通过长连接与 NameNode 保持通信。（ ）  
  
这个有分歧：具体正在找这方面的有利资料。下面提供资料可参考。  
首先明确一下概念：  
  
（1）.长连接  
Client方与Server方先建立通讯连接，连接建立后不断开，  
然后再进行报文发送和接收。这种方式下由于通讯连接一直  
存在，此种方式常用于点对点通讯。  
  
  
（2）.短连接  
Client方与Server每进行一次报文收发交易时才进行通讯连  
接，交易完毕后立即断开连接。此种方式常用于一点对多点  
通讯，比如多个Client连接一个Server.  
  
  
  
  
23. Hadoop 自身具有严格的权限管理和安全措施保障集群正常运行。（错误 ）  
  
hadoop只能阻止好人犯错，但是不能阻止坏人干坏事  
具体可查看  
[hadoop安全性需不断加强][hadoop]  
  
  
24. Slave 节点要存储数据，所以它的磁盘越大越好。（ 错误）  
  
分析：  
一旦 Slave节点宕机，数据恢复是一个难题  
  
25. hadoop dfsadmin –report 命令用于检测 HDFS 损坏块。（错误 ）  
  
  
分析：  
hadoop dfsadmin -report   
  
用这个命令可以快速定位出哪些节点down掉了，HDFS的容量以及使用了多少，以及每个节点的硬盘使用情况。  
  
当然NameNode有个http页面也可以查询，但是这个命令的输出更适合我们的脚本 [监控][Link 1] dfs的使用状况

1.  Configured Capacity: 77209395855360 (70.22 TB)  
    
2.  Present Capacity: 76079914600683 (69.19 TB)  
    
3.  DFS Remaining: 60534707015680 (55.06 TB)  
    
4.  DFS Used: 15545207585003 (14.14 TB)  
    
5.  DFS Used%: 20.43%  
    
6.    
    
7.  \-------------------------------------------------  
    
8.  Datanodes available: 107 (109 total, 2 dead)  
    
9.    
    
10. Name: 172.16.218.232:50010  
    
11. Rack: /lg/dminterface0  
    
12. Decommission Status : Normal  
    
13. Configured Capacity: 1259272216576 (1.15 TB)  
    
14. DFS Used: 185585852416 (172.84 GB)  
    
15. Non DFS Used: 39060951040 (36.38 GB)  
    
16. DFS Remaining: 1034625413120(963.57 GB)  
    
17. DFS Used%: 14.74%  
    
18. DFS Remaining%: 82.16%  
    
19. Last contact: Wed Nov 18 10:19:44 CST 2009  
    
20.   
    
21. Name: 172.16.216.126:50010  
    
22. Rack: /lg/dminterface2  
    
23. Decommission Status : Normal  
    
24. Configured Capacity: 661261402112 (615.85 GB)  
    
25. DFS Used: 123147280384 (114.69 GB)  
    
26. Non DFS Used: 8803852288 (8.2 GB)  
    
27. DFS Remaining: 529310269440(492.96 GB)  
    
28. DFS Used%: 18.62%  
    
29. DFS Remaining%: 80.05%  
    
30. Last contact: Wed Nov 18 10:19:46 CST 2009

*复制代码*

26. Hadoop 默认调度器策略为 FIFO（正确 ）  
具体参考  
[Hadoop集群三种作业调度算法介绍][Hadoop]  
  
  
  
27. 集群内每个节点都应该配 RAID，这样避免单磁盘损坏，影响整个节点运行。（错误 ）  
分析：  
首先明白什么是 RAID， 可以参考百科 [磁盘阵列][Link 4] 。  
这句话错误的地方在于太绝对，具体情况具体分析。题目不是重点，知识才是最重要的。  
因为hadoop本身就具有冗余能力，所以如果不是很严格不需要都配备 RAID 。具体参考第二题。  
  
  
28. 因为 HDFS 有多个副本，所以 NameNode 是不存在单点问题的。（错误 ）  
分析：  
NameNode存在单点问题。了解详细信息，可以参考  
[Hadoop中Namenode单点故障的解决方案及详细介绍AvatarNode][Hadoop_Namenode_AvatarNode]  
  
29. 每个 map 槽就是一个线程。（错误 ）  
分析：首先我们知道什么是map 槽,map  槽->map slot  
map  slot 只是一个逻辑值 ( org.apache.hadoop.mapred.TaskTracker.TaskLauncher.numFreeSlots )，而不是对应着一个线程或者进程  
具体见：  
[hadoop中槽-slot是线程还是进程讨论][hadoop_-slot]  
  
30. Mapreduce 的 input split 就是一个  [block][] 。（错误 ）  
[InputFormat的数据划分、Split调度、数据读取三个问题的浅析][InputFormat_Split]  
  
31. NameNode 的 Web UI 端口是 50030，它通过 jetty 启动的 Web 服务。（错误 ）  
分析：  
根据下面，很显然JOBTRACKER的 Web UI 端口是 50030  
端口说明：  
  
默认端口    设置位置                                                                                                    
9000          namenode                                                                                                  
8020          namenode                                                                                                  
8021          JT RPC                                                                                                     
50030        mapred. [job][] .tracker.http.address JobTracker administrative web GUI        
50070        dfs.http.address NameNode administrative web GUI                                
50010        dfs.datanode.address DataNode control port                  
50020        dfs.datanode.ipc.address DataNode IPC port, used for  [block][]  transfer       
50060        mapred.task.tracker.http.address Per TaskTracker web interface             
50075        dfs.datanode.http.address Per DataNode web interface                            
50090        dfs.secondary.http.address Per secondary NameNode web interface        
  
  
  
  
设置位置                                                                                                 描述信息  
namenode                                                                                               交互端口  
namenode                                                                                               RPC交互端口  
JT RPC                                                                                                   交互端口  
mapred. [job][] .tracker.http.address JobTracker administrative web GUI     JOBTRACKER的HTTP服务器和端口  
dfs.http.address NameNode administrative web GUI                              NAMENODE的HTTP服务器和端口  
dfs.datanode.address DataNode control port               DATANODE控制端口，主要用于DATANODE初始化时向NAMENODE提出注册和应答请求  
dfs.datanode.ipc.address DataNode IPC port, used for  [block][]  transfer    DATANODE的RPC服务器地址和端口  
mapred.task.tracker.http.address Per TaskTracker web interface           TASKTRACKER的HTTP服务器和端口  
dfs.datanode.http.address Per DataNode web interface                          DATANODE的HTTP服务器和端口  
dfs.secondary.http.address Per secondary NameNode web interface     辅助DATANODE的HTTP服务器和端口  
  
  
  
  
32. Hadoop 环境变量中的 HADOOP\_HEAPSIZE 用于设置所有 Hadoop 守护线程的内存。它默  
认是 200 GB。（ 错误）  
hadoop为各个守护进程（namenode,secondarynamenode,[job][]tracker,datanode,tasktracker）统一分配的内存在hadoop-env.sh中设置，参数为HADOOP\_HEAPSIZE，默认为1000M。  
具体参考 [hadoop集群内存设置][hadoop 1]  
  
33. DataNode 首次加入 cluster 的时候，如果 log 中报告不兼容文件版本，那需要 NameNode  
执行“Hadoop namenode -format”操作格式化磁盘。（错误 ）  
分析：  
首先明白介绍，什么 ClusterID  
ClusterID  
  
添加了一个新的标识符ClusterID用于标识集群中所有的节点。当格式化一个Namenode，需要提供这个标识符或者自动生成。这个ID可以被用来格式化加入集群的其他Namenode。  
二次整理  
有的同学问题的重点不是上面分析内容：内容如下：  
这个报错是说明 DataNode 所装的Hadoop版本和其它节点不一致，应该检查DataNode的Hadoop版本  
  
详细内容 可参考  
[hadoop集群添加namenode的步骤及常识][hadoop_namenode]

======================================================================================================================

1 使用Hive或者自定义MR实现如下逻辑

product\_no      lac\_id  moment  start\_time      user\_id county\_id       staytime        city\_id

13429100031     22554   8       2013-03-11 08:55:19.151754088   571     571     282     571

13429100082     22540   8       2013-03-11 08:58:20.152622488   571     571     270     571

13429100082     22691   8       2013-03-11 08:56:37.149593624   571     571     103     571

13429100087     22705   8       2013-03-11 08:56:51.139539816   571     571     220     571

13429100087     22540   8       2013-03-11 08:55:45.150276800   571     571     66      571

13429100082     22540   8       2013-03-11 08:55:38.140225200   571     571     133     571

13429100140     26642   9       2013-03-11 09:02:19.151754088   571     571     18      571

13429100082     22691   8       2013-03-11 08:57:32.151754088   571     571     287     571

13429100189     22558   8       2013-03-11 08:56:24.139539816   571     571     48      571

13429100349     22503   8       2013-03-11 08:54:30.152622440   571     571     211     571

字段解释：

product\_no：用户手机号；

lac\_id：用户所在基站；

start\_time：用户在此基站的开始时间；

staytime：用户在此基站的逗留时间。

需求描述：

根据lac\_id和start\_time知道用户当时的位置，根据staytime知道用户各个基站的逗留时长。根据轨迹合并连续基站的staytime。

最终得到每一个用户按时间排序在每一个基站驻留时长

期望输出举例：

13429100082     22540   8       2013-03-11 08:58:20.152622488   571     571     270     571

13429100082     22691   8       2013-03-11 08:56:37.149593624   571     571     390     571

13429100082     22540   8       2013-03-11 08:55:38.140225200   571     571     133     571

13429100087     22705   8       2013-03-11 08:56:51.139539816   571     571     220     571

13429100087     22540   8       2013-03-11 08:55:45.150276800   571     571     66      571

2 Linux脚本能力考察

2.1 请随意使用各种类型的脚本语言实现：批量将指定目录下的所有文件中的$HADOOP\_HOME$替换成/home/ocetl/app/hadoop

2.2 假设有10台主机，H1到H10，在开启SSH互信的情况下，编写一个或多个脚本实现在所有的远程主机上执行脚本的功能

例如：runRemoteCmd.sh "ls -l"

期望结果：

H1:

XXXXXXXX

H2:

XXXXXXXX

H3:

...

3 Hadoop基础知识与问题分析的能力

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

3.2 请描述[https://issues.apache.org/jira/browse/HDFS-2379说的是什么问题][https_issues.apache.org_jira_browse_HDFS-2379]，最终解决的思路是什么？

4 MapReduce开发能力

请参照wordcount实现一个自己的map reduce，需求为：

a 输入文件格式：

xxx,xxx,xxx,xxx,xxx,xxx,xxx

b 输出文件格式：

xxx,20

xxx,30

xxx.40

c 功能：根据命令行参数统计输入文件中指定关键字出现的次数，并展示出来

例如：hadoop jar xxxxx.jar keywordcount xxx,xxx,xxx,xxx(四个关键字）

5 MapReduce优化

请根据第五题中的程序, 提出如何优化MR程序运行速度的思路

6 Linux操作系统知识考察

请列举曾经修改过的/etc下的配置文件，并说明修改要解决的问题？

7 Java开发能力

7.1 写代码实现1G大小的文本文件，行分隔符为\\x01\\x02,统计一下该文件中的总行数，要求注意边界情况的处理

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

答案如下：

1. 考虑后，决定使用 MR 来实现，于是使用Java，用一个MR Job完成这个事情：

1.  package org.aboutyun;  
    
2.    
    
3.  import org.apache.commons.lang.StringUtils;  
    
4.  import org.apache.hadoop.conf.Configuration;  
    
5.  import org.apache.hadoop.fs.Path;  
    
6.  import org.apache.hadoop.io.LongWritable;  
    
7.  import org.apache.hadoop.io.Text;  
    
8.  import org.apache.hadoop.mapreduce.Job;  
    
9.  import org.apache.hadoop.mapreduce.Mapper;  
    
10. import org.apache.hadoop.mapreduce.Reducer;  
    
11. import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;  
    
12. import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;  
    
13. import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;  
    
14. import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;  
    
15.   
    
16. import java.io.IOException;  
    
17. import java.text.ParseException;  
    
18. import java.text.SimpleDateFormat;  
    
19. import java.util.ArrayList;  
    
20. import java.util.Collections;  
    
21. import [java][].util.Comparator;  
    
22.   
    
23. public class TimeCount \{  
    
24.     public static void main(String\[\] args) throws Exception \{  
    
25.         Configuration conf = new Configuration();  
    
26.   
    
27.         Job job = new Job(conf, "time\_count");  
    
28.   
    
29.         job.setOutputKeyClass(Text.class);  
    
30.         job.setOutputValueClass(Text.class);  
    
31.   
    
32.         job.setMapperClass(Map.class);  
    
33.         job.setReducerClass(Reduce.class);  
    
34.   
    
35.         job.setInputFormatClass(TextInputFormat.class);  
    
36.         job.setOutputFormatClass(TextOutputFormat.class);  
    
37.   
    
38.         FileInputFormat.addInputPath(job, new Path(args\[0\]));  
    
39.         FileOutputFormat.setOutputPath(job, new Path(args\[1\]));  
    
40.   
    
41.         job.waitForCompletion(true);  
    
42.     \}  
    
43.   
    
44.     public static class Map extends Mapper<LongWritable, Text, Text, Text> \{  
    
45.         private Text id = new Text();  
    
46.         private Text row = new Text();  
    
47.   
    
48.         public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException \{  
    
49.             String line = value.toString();  
    
50.             String\[\] items = line.split("\\t");  
    
51.   
    
52.             if (items.length == 8) \{  
    
53.                 if (StringUtils.isNumeric(items\[6\])) \{  
    
54.                     id.set(items\[0\] + "\\t" + items\[1\]);  
    
55.                     row.set(line);  
    
56.                     context.write(id, row);  
    
57.                 \}  
    
58.             \} else \{  
    
59.                 System.out.println("Wrong length: " + items.length);  
    
60.             \}  
    
61.         \}  
    
62.     \}  
    
63.   
    
64.     public static class Reduce extends Reducer<Text, Text, Text, Text> \{  
    
65.         private static final SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    
66.   
    
67.         static \{  
    
68.             format.setLenient(false);  
    
69.         \}  
    
70.   
    
71.         private Text rest = new Text();  
    
72.   
    
73.         public void reduce(Text key, Iterable<Text> values, Context context)  
    
74.                 throws IOException, InterruptedException \{  
    
75.             //  Parse row to Record  
    
76.             ArrayList<Record> list = new ArrayList<Record>();  
    
77.             for (Text row : values) \{  
    
78.                 String\[\] items = row.toString().split("\\t");  
    
79.                 try \{  
    
80.                     Record record = new Record();  
    
81.                     record.items = items;  
    
82.                     record.start\_time = format.parse(items\[3\]).getTime();  
    
83.                     record.stay\_time = Long.parseLong(items\[6\]) \* 1000;  
    
84.                     list.add(record);  
    
85.                 \} catch (ParseException e) \{  
    
86.                     e.printStackTrace();  
    
87.                 \}  
    
88.   
    
89.             \}  
    
90.   
    
91.             //  Sort  
    
92.             Collections.sort(list, new Comparator<Record>() \{  
    
93.                 @Override  
    
94.                 public int compare(Record r1, Record r2) \{  
    
95.                     return (int) (r1.start\_time - r2.start\_time);  
    
96.                 \}  
    
97.             \});  
    
98.   
    
99.             //  Find and merge slice  
    
100.             ArrayList<Record> result = new ArrayList<Record>();  
    
101.             for (Record r1 : list) \{  
    
102.                 boolean found = false;  
    
103.                 long r1\_stop\_time = r1.start\_time + r1.stay\_time;  
    
104.                 for (Record r2 : result) \{  
    
105.                     long r2\_stop\_time = r2.start\_time + r2.stay\_time;  
    
106.                     if (r1.start\_time > r2.start\_time && r1.start\_time <= r2\_stop\_time && r1\_stop\_time > r2\_stop\_time) \{  
    
107.                         //  merge the new slice  
    
108.                         r2.stay\_time = r1\_stop\_time - r2.start\_time;  
    
109.                         found = true;  
    
110.                     \}  
    
111.                 \}  
    
112.   
    
113.                 if (!found) \{  
    
114.                     result.add(r1);  
    
115.                 \}  
    
116.             \}  
    
117.   
    
118.             //  Output  
    
119.             for (Record r : result) \{  
    
120.                 key.set(r.items\[0\]);  
    
121.   
    
122.                 String value = r.items\[1\] + "\\t"  
    
123.                         + r.items\[2\] + "\\t"  
    
124.                         + r.items\[3\] + "\\t"  
    
125.                         + r.items\[4\] + "\\t"  
    
126.                         + r.items\[5\] + "\\t"  
    
127.                         + (r.stay\_time / 1000) + "\\t"  
    
128.                         + r.items\[6\] + "\\t";  
    
129.                 rest.set(value);  
    
130.   
    
131.                 context.write(key, rest);  
    
132.             \}  
    
133.   
    
134.         \}  
    
135.   
    
136.         static class Record \{  
    
137.             String\[\] items;  
    
138.             long start\_time;  
    
139.             long stay\_time;  
    
140.         \}  
    
141.     \}  
    
142. \}

*复制代码*

2.   
  
2.1 使用 find + sed 来实现：  
find /home/ocetl/app/hadoop -exec sed -i 's/\\$HADOOP\_HOME\\$/\\/home\\/ocetl\\/app\\/hadoop/g' \{\} \\;  
2.2 直接使用ssh的参数

1.  \#!/bin/bash  
    
2.  if \[ $\# -ne 1 \]  
    
3.  then  
    
4.          echo "Usage: \`basename $0\` \{command\}"  
    
5.          exit  
    
6.  fi  
    
7.    
    
8.  for i in H1 H2 H3 H4 H5 H6 H7 H8 H9 H10  
    
9.  do  
    
10.         echo "$i:"  
    
11.         ssh $i "$1"  
    
12. done

*复制代码*

3.   
3.1 不了解，HDFS用了缓存  
3.2 问题是当硬盘空间很大，而内存页面缓存很少的时候，DN的Block report需要很长时间生成，而此时 FSVolumeSet 锁是锁住的，因此所有读写操作都无法执行，最终导致那些操作超时。此问题是建议提供一种方法使[block][block 1] report不需要持有FSVolumeSet锁，从而不会导致那些任务失败。  
  
4. 只是替换分隔符从空格到逗号，以及增加搜索关键字列表：

1.  import org.apache.hadoop.conf.Configuration;  
    
2.  import org.apache.hadoop.fs.Path;  
    
3.  import org.apache.hadoop.io.IntWritable;  
    
4.  import org.apache.hadoop.io.LongWritable;  
    
5.  import org.apache.hadoop.io.Text;  
    
6.  import org.apache.hadoop.mapreduce.Job;  
    
7.  import org.apache.hadoop.mapreduce.Mapper;  
    
8.  import org.apache.hadoop.mapreduce.Reducer;  
    
9.  import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;  
    
10. import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;  
    
11. import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;  
    
12. import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;  
    
13.   
    
14. import java.io.IOException;  
    
15. import [java][].util.ArrayList;  
    
16.   
    
17. public class WordCount \{  
    
18.   
    
19.     public static class Map extends Mapper<LongWritable, Text, Text, IntWritable> \{  
    
20.         private final static IntWritable one = new IntWritable(1);  
    
21.         private Text word = new Text();  
    
22.         private final static ArrayList<String> target\_words = new ArrayList<String>();  
    
23.   
    
24.         public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException \{  
    
25.             String\[\] items = value.toString().toLowerCase().replaceAll("\\\\p\{Punct\}", "").split("\\\\s+");  
    
26.             for (String item : items) \{  
    
27.                 if (target\_words.contains(item)) \{  
    
28.                     word.set(item);  
    
29.                     context.write(word, one);  
    
30.                 \}  
    
31.             \}  
    
32.         \}  
    
33.   
    
34.         public static void clear() \{  
    
35.             target\_words.clear();  
    
36.         \}  
    
37.   
    
38.         public static void add(String word) \{  
    
39.             target\_words.add(word);  
    
40.         \}  
    
41.     \}  
    
42.   
    
43.     public static class Reduce extends Reducer<Text, IntWritable, Text, IntWritable> \{  
    
44.   
    
45.         public void reduce(Text key, Iterable<IntWritable> values, Context context)  
    
46.                 throws IOException, InterruptedException \{  
    
47.             int sum = 0;  
    
48.             for (IntWritable val : values) \{  
    
49.                 sum += val.get();  
    
50.             \}  
    
51.             context.write(key, new IntWritable(sum));  
    
52.         \}  
    
53.     \}  
    
54.   
    
55.     public static void main(String\[\] args) throws Exception \{  
    
56.         Configuration conf = new Configuration();  
    
57.   
    
58.         if (args.length < 3) \{  
    
59.             System.out.println("Usage: wordcount <input\_path> <output\_path> <keyword\_list>");  
    
60.             return;  
    
61.         \}  
    
62.   
    
63.         //  Add to target  
    
64.         String\[\] target\_words = args\[2\].split(",");  
    
65.         for (String word : target\_words) \{  
    
66.             Map.add(word.toLowerCase());  
    
67.         \}  
    
68.   
    
69.         Job job = new Job(conf, "wordcount");  
    
70.   
    
71.         job.setOutputKeyClass(Text.class);  
    
72.         job.setOutputValueClass(IntWritable.class);  
    
73.   
    
74.         job.setMapperClass(Map.class);  
    
75.         job.setReducerClass(Reduce.class);  
    
76.   
    
77.         job.setInputFormatClass(TextInputFormat.class);  
    
78.         job.setOutputFormatClass(TextOutputFormat.class);  
    
79.   
    
80.         FileInputFormat.addInputPath(job, new Path(args\[0\]));  
    
81.         FileOutputFormat.setOutputPath(job, new Path(args\[1\]));  
    
82.   
    
83.         job.waitForCompletion(true);  
    
84.     \}  
    
85.   
    
86. \}

*复制代码*

5. 第五题的程序是什么？  
  
6.   
        hosts：增加局域网主机名和ip对应关系，省得再记住ip;  
        hostname：该主机名，克隆虚拟机的时候经常需要这么做；  
        fstab：修改挂载点，加新硬盘的时候会需要；  
        profile, bash.bashrc: 修改系统范围环境变量时经常用；  
        network/interfaces：配置静态IP时需要。  
  
7  
7.1

1.  package org.aboutyun;  
    
2.    
    
3.  import java.io.BufferedReader;  
    
4.  import java.io.FileNotFoundException;  
    
5.  import java.io.FileReader;  
    
6.  import [java][].io.IOException;  
    
7.    
    
8.  public class LineCounter \{  
    
9.      public static void main(String\[\] args) \{  
    
10.         try \{  
    
11.             BufferedReader reader = new BufferedReader(new FileReader(args\[0\]));  
    
12.             char\[\] buffer = new char\[4096\];  
    
13.             int count;  
    
14.             char last = 0;  
    
15.             long line\_count = 0;  
    
16.             while((count = reader.read(buffer)) >= 0) \{  
    
17.                 if (count > 0 && line\_count == 0) \{  
    
18.                     //  has something in file, so at least 1 line.  
    
19.                     line\_count = 1;  
    
20.                 \}  
    
21.   
    
22.                 for (int i = 0; i < count ; ++i) \{  
    
23.                     char c = buffer\[i\];  
    
24.                     if (c == 0x02) \{  
    
25.                         if (i == 0 && last == 0x01) \{  
    
26.                             //  buffer split the 0x01,0x02  
    
27.                             ++line\_count;  
    
28.                         \} else if (buffer\[i-1\] == 0x01) \{  
    
29.                             //  normal one  
    
30.                             ++line\_count;  
    
31.                         \}  
    
32.                     \}  
    
33.                 \}  
    
34.   
    
35.                 //  keep the last one  
    
36.                 last = buffer\[count-1\];  
    
37.             \}  
    
38.   
    
39.             System.out.println(line\_count);  
    
40.         \} catch (FileNotFoundException e) \{  
    
41.             e.printStackTrace();  
    
42.         \} catch (IOException e) \{  
    
43.             e.printStackTrace();  
    
44.         \}  
    
45.     \}  
    
46. \}

*复制代码*

7.2 可以使用Profiler来对性能进行评估分析，比如Eclipse的TPTP，或者JProfiler。可以观察不同函数调用次数和以及占用时间，从而减少调用次数，以及优化函数内部。

原文地址： [http://www.aboutyun.com/thread-5241-1-1.html][http_www.aboutyun.com_thread-5241-1-1.html]

[block]: http://cpro.baidu.com/cpro/ui/uijs.php?rs=1&u=http%3A%2F%2Fwww%2Eaboutyun%2Ecom%2Fthread%2D6787%2D1%2D1%2Ehtml&p=baidu&c=news&n=10&t=tpclicked3_hc&q=92051019_cpr&k=block&k0=%BC%E0%BF%D8&kdi0=8&k1=block&kdi1=1&k2=job&kdi2=8&k3=%D4%C6%BC%C6%CB%E3&kdi3=8&k4=%BC%E0%BF%D8%C8%ED%BC%FE&kdi4=8&sid=e13fe98dbaabd5&ch=0&tu=u1692056&jk=4b06deca3c78731a&cf=29&fv=12&stid=9&urlid=0&luki=2&seller_id=1&di=128
[031259g9eeu7bagqp0efax.jpg]: /images/20220731/fd56d0b4d4604b1c8950a11accfaa7b4.png
[job]: http://cpro.baidu.com/cpro/ui/uijs.php?rs=1&u=http%3A%2F%2Fwww%2Eaboutyun%2Ecom%2Fthread%2D6787%2D1%2D1%2Ehtml&p=baidu&c=news&n=10&t=tpclicked3_hc&q=92051019_cpr&k=job&k0=%BC%E0%BF%D8&kdi0=8&k1=block&kdi1=1&k2=job&kdi2=8&k3=%D4%C6%BC%C6%CB%E3&kdi3=8&k4=%BC%E0%BF%D8%C8%ED%BC%FE&kdi4=8&sid=e13fe98dbaabd5&ch=0&tu=u1692056&jk=4b06deca3c78731a&cf=29&fv=12&stid=9&urlid=0&luki=3&seller_id=1&di=128
[Link 1]: http://cpro.baidu.com/cpro/ui/uijs.php?rs=1&u=http%3A%2F%2Fwww%2Eaboutyun%2Ecom%2Fthread%2D6787%2D1%2D1%2Ehtml&p=baidu&c=news&n=10&t=tpclicked3_hc&q=92051019_cpr&k=%BC%E0%BF%D8&k0=%BC%E0%BF%D8&kdi0=8&k1=block&kdi1=1&k2=job&kdi2=8&k3=%D4%C6%BC%C6%CB%E3&kdi3=8&k4=%BC%E0%BF%D8%C8%ED%BC%FE&kdi4=8&sid=e13fe98dbaabd5&ch=0&tu=u1692056&jk=4b06deca3c78731a&cf=29&fv=12&stid=9&urlid=0&luki=1&seller_id=1&di=128
[IO]: http://www.aboutyun.com/thread-6874-1-1.html
[io]: http://www.aboutyun.com/thread-6802-1-1.html
[Zookeeper_Zookeeper_Hadoop_hbase]: http://www.aboutyun.com/thread-6628-1-1.html
[-pdsh]: http://www.aboutyun.com/thread-6806-1-1.html
[Cloudera Manager]: http://www.aboutyun.com/thread-6807-1-1.html
[hadoop_--_hadoop]: http://www.aboutyun.com/thread-6786-1-1.html
[HDFS]: http://www.aboutyun.com/thread-5845-1-1.html
[Hadoop CDH]: http://www.aboutyun.com/thread-6789-1-1.html
[Link 2]: http://cpro.baidu.com/cpro/ui/uijs.php?rs=1&u=http%3A%2F%2Fwww%2Eaboutyun%2Ecom%2Fthread%2D6787%2D1%2D1%2Ehtml&p=baidu&c=news&n=10&t=tpclicked3_hc&q=92051019_cpr&k=%BC%E0%BF%D8%C8%ED%BC%FE&k0=%BC%E0%BF%D8&kdi0=8&k1=block&kdi1=1&k2=job&kdi2=8&k3=%D4%C6%BC%C6%CB%E3&kdi3=8&k4=%BC%E0%BF%D8%C8%ED%BC%FE&kdi4=8&sid=e13fe98dbaabd5&ch=0&tu=u1692056&jk=4b06deca3c78731a&cf=29&fv=12&stid=9&urlid=0&luki=5&seller_id=1&di=128
[ganglia_nagios]: http://www.aboutyun.com/thread-6790-1-1.html
[Link 3]: http://cpro.baidu.com/cpro/ui/uijs.php?rs=1&u=http%3A%2F%2Fwww%2Eaboutyun%2Ecom%2Fthread%2D6787%2D1%2D1%2Ehtml&p=baidu&c=news&n=10&t=tpclicked3_hc&q=92051019_cpr&k=%D4%C6%BC%C6%CB%E3&k0=%BC%E0%BF%D8&kdi0=8&k1=block&kdi1=1&k2=job&kdi2=8&k3=%D4%C6%BC%C6%CB%E3&kdi3=8&k4=%BC%E0%BF%D8%C8%ED%BC%FE&kdi4=8&sid=e13fe98dbaabd5&ch=0&tu=u1692056&jk=4b06deca3c78731a&cf=29&fv=12&stid=9&urlid=0&luki=4&seller_id=1&di=128
[hadoop _SecondaryNameNode_Namenode]: http://www.aboutyun.com/thread-6196-1-1.html
[Hadoop_1_Map_Reduce]: http://www.aboutyun.com/thread-5541-1-1.html
[hadoop_NameNode_DataNode_Client]: http://www.aboutyun.com/thread-6794-1-1.html
[hadoop]: http://www.aboutyun.com/thread-6795-1-1.html
[Hadoop]: http://www.aboutyun.com/thread-6798-1-1.html
[Link 4]: http://baike.baidu.com/view/63423.htm?from_id=33858&type=syn&fromtitle=RAID&fr=aladdin
[Hadoop_Namenode_AvatarNode]: http://www.aboutyun.com/thread-6799-1-1.html
[hadoop_-slot]: http://www.aboutyun.com/thread-6800-1-1.html
[InputFormat_Split]: http://www.aboutyun.com/thread-6803-1-1.html
[hadoop 1]: http://www.aboutyun.com/thread-6804-1-1.html
[hadoop_namenode]: http://www.aboutyun.com/thread-6805-1-1.html
[https_issues.apache.org_jira_browse_HDFS-2379]: https://issues.apache.org/jira/browse/HDFS-2379%E8%AF%B4%E7%9A%84%E6%98%AF%E4%BB%80%E4%B9%88%E9%97%AE%E9%A2%98
[java]: http://cpro.baidu.com/cpro/ui/uijs.php?rs=1&u=http%3A%2F%2Fwww%2Eaboutyun%2Ecom%2Fthread%2D5241%2D1%2D1%2Ehtml&p=baidu&c=news&n=10&t=tpclicked3_hc&q=92051019_cpr&k=java&k0=java&kdi0=8&k1=block&kdi1=8&k2=eclipse&kdi2=8&sid=3e7836f0fdd3eb17&ch=0&tu=u1692056&jk=4e22d81f3c6fe134&cf=29&fv=12&stid=9&urlid=0&luki=1&seller_id=1&di=128
[block 1]: http://cpro.baidu.com/cpro/ui/uijs.php?rs=1&u=http%3A%2F%2Fwww%2Eaboutyun%2Ecom%2Fthread%2D5241%2D1%2D1%2Ehtml&p=baidu&c=news&n=10&t=tpclicked3_hc&q=92051019_cpr&k=block&k0=java&kdi0=8&k1=block&kdi1=8&k2=eclipse&kdi2=8&sid=3e7836f0fdd3eb17&ch=0&tu=u1692056&jk=4e22d81f3c6fe134&cf=29&fv=12&stid=9&urlid=0&luki=2&seller_id=1&di=128
[http_www.aboutyun.com_thread-5241-1-1.html]: http://www.aboutyun.com/thread-5241-1-1.html