2.修改ip
3.修改host主机名
4.配置ssh 免密登陆
5.关闭防火墙
6.安装ＪＤＫ
7.解压hadoop安装包
8.配置hadoop的核心配置文件 hadoop-env.sh? core-site.xml? mapred-site.xml yarn-site.xml hdfs-site.xml
9.配置hadoop 的环境变量
10 .格式化hadoop namenode-format
二 .列出hadoop 集群中的都分别需要启动哪些进程 它们分别是作用是什么？
namenode :负责管理HDFS中文件的元数据，响应客户端请求，管理datanode 上文件block的均衡，维持副本数量
secondname: 主要负责checkpoint 操作 也可以做冷备 对一定范围内数据做快照性备份
datanode : 存储数据块 负责客户对数据块的io请求
jobtracker :管路任务 ，并将任务分配给tasktracker
tasktracker: 执行jobtrancker 分配的任务
resource manager? nodemanager journalnode? zookeeper? zkfc
三 简述mapreduce的运行原理
先将文件进行分割后，进行map操作，后面进行shuffle操作，分为map端shuffle和reduce端shuffle，map输出结果放在缓冲区，当缓存区到达一定阈值时，将其中数据spill（也就是溢写）到磁盘，然后进行partition, sort, combine操作，这样多次spill后，磁盘上就会有多个文件，merge操作将这些文件合并成一个文件，reduce端shuffle从map节点拉取数据文件，如果在内存中放得下，就直接放在内存中，每个map对应一块数据，当内存占用量达到一定程度时，启动内存时merge，把内存中的数据输出到磁盘的一个文件上。如果在内存中放不下的话，就直接写到磁盘上。一个map数据对应一个文件，当文件数量达到一定阀值时，开始启动磁盘文件merge，把这些文件合并到一个文件中。最后，把内存中的文件和磁盘上的文件进行全局merge，形成一个最终端文件，做为reduce的输入文件。当然merge过程中会进行sort,combine操作。
四 hive中内部外部表的区别
内部表：数据存储在Hive的数据仓库目录下，删除表时，除了删除元数据，还会删除实际表文件。
外部表：数据并不存储在Hive的数据仓库目录下，删除表时，只是删除元数据，并不删除实际表文件。
五 mapreduce中的combiner 和partition的区别
? Combiner就是在map端先进行一次reduce操作，减少map端到reduce端的数据传输量，节省网络带宽，提高执行效率。
Partition就是将map输出按key分区，送到不同的reduce上去并行执行，提高效率。
六 面试问答：
1、讲项目经验：
问的很细，给纸，笔，让画公司hadoop的项目架构,说几条业务数据，然后经过平台后，出来成什么样子；
2、java方面：
io输入输出流里有哪些常用的类，还有webService,线程相关的知识；
3、linux：
问到jps命令，kill命令，问awk,sed是干什么用的、还有hadoop的一些常用命令；
4、hadoop：
讲hadoop1中map,shuffle,reduce的过程，其中问到了map端和reduce端溢写的细节；
也问了一些，外部表，还有就是hive的物理模型跟传统数据库的不同。
七 新手问答：
1、工资多少，工作几年了,有java基础吗,大学学什么
** 13k,做javaweb将近三年，2014年4月开始学习hadoop,现在已经工作一个多月了，有java基础，大学是计算机系
2、flume,kafka,storm是怎么学的，有没有做优化
** 看官方文档，先搭环境， 然后用java写代码调用它们的接口，熟悉api不过，如果有视频资源的话，还是建议尽量看一下
3、现在用hadoop1还是2
**hadoop2
4、面试时说做hadoop多久了
** 我说的将近两年，面试时一定要说有hadoop经验
5、storm,python之前都会吗，还是进公司后自学的
**这些都是到公司后，自学的
6、你用的hadoop是收费 的还是免费的
**目前 是用的是免费的
7、自己搭过集群吗，一开始压力大吗
**集群是自己搭的，压力很大，不过车到山前必有路
8、广告作弊用mapreduce计算吗
** 用的storm，实时处理
9、普通局域网的机子可以搭建么
** 可以，当时我先在自己机器上测试，用的自己电脑上的虚拟机，后来公司买的去服务器
10、flume的知识有什么高深的东西
**我觉得没有什么东西是高深，只是我们没有涉入，只要用的多，多测试，它只是一个软件而已
11、你看源码吗， 现在？
**会看源码，但是我觉得不要死扣在源码，我们主要是应用，如果自己有精力，也可以分块研究一下
12、公司现在有多少台服务器？
**有10台，我用其中四台做了storm,kafka,flume，另外四台做hadoop ,hive,还有两台用做机器学习用
13、没有java能做hadoop么
**不能吧，必须要会java
14、面试时会不会让默写代码
**没有遇到过（不同的公司不一样）
15、自己学，遇到问题都自己解决吗？
目前遇到的问题，自己都能解决，如果不能的话，会救助同事吧
16、你们数据库用hbase?
目前还没用，现在主要用mongdb,mysql,redis（hive、hbase的公司不少）
17、大专不好找工作吗？
也没有，我有个同事，也是大专，但是她找工作时说自己是本科（因为那职位要求本科），后来面试通过后，又给人事打电话说，我其实是大专，但是为了得到这次面试机会，我说自己是本科。。。后来人事说这个没关系。。。那个公司就是×××，她现在已经在那里上班了（这个属于特殊情况，如果比较严的公司，拒绝的可能性是非常大的，除非实力强劲，大专找到工作是很正常的事情，
**这里只是公供大家参考，希望去其糟粕，取其精华
18、现在hadoop什么水平了，基本的框架 都会用的程度 吗？
** 是的，我现在基本框架都会用，都搭集群环境，包括调用的api也都很熟悉
19、hadoop方向不错我现在15k，考虑要不要转
**我觉得这个要看你现在的行业以后的发展，如果有瓶颈，我觉得可以考虑转
20、英文杂样，能看懂官方文档吗？
**看文档的问题不大，写和说还不行，我正在做计划，看怎么学
21、你对自己在it行业啥想法呢，会一直在大数据这方面吗？
**目前 我的想法是以后准备做数据挖掘，机器学习工程师
22、python要掌握到什么程度？
**在互联网方面，python,shell都是少不了的工具，我觉得我们主要精通一门，python的话，能看懂，能修改别人代码就行。现在的话，我还是比较推崇python，比shell强大，比java简洁。
23、3周是自己单独学，还是工作之外学？
学习的过程，我一般都是晚上学，很痴迷，也可能是因为想赶紧转，脱离当前公司的苦海，哈哈
24、人家说集群什么的都没有搭建，这样的工作你当时没犹豫就接了吗，这么有自信？
**当时我也很担心，不过进去的时候，也有说，让我别压力太大，如果有问题，他们会想办法找人帮我解决，所以我就豁出去
25、shell掌握到什么程度是，工作用到的难不难
**我觉得shell 的话，主要把awk,sed学好，当然基础也要学好，比如网络配置、基本操作
八 宽表你什么理解？
宽表指的是行少列多，如果一行数据量过大，可能造成一个HFile放不下。但宽表有行级原子性的优势。高表指的是行多列少，Hbase只能按行分片，因此高表更有优势。具体还是要根据业务场景综合考虑。
2） 最好不要定义过多的ColumnFamily，一般来说， 一张表一个ColumnFamily就好。因为Flushing和压缩是基于Region的。当一个ColumnFamily所存储的数据达到Flushing阀值时，该表中的其他ColumnFamily可能没存储多少数据，也要跟着进行Flushing操作，这将会带来很多不必要的IO消耗。ColumFamily越多，对性能的影响也就越大。此外，同一个表中不同的ColumnFamily存储的数据量差别也不要太大，不然有些数据会分散在太多的Region上，会影响检索效率。
九 Hbase rowkey设计原则
总的原则：综合考虑业务场景，及hbase的存储访问特点。
几个简单的原则：rowkey唯一，长度一致，能短则短。
然后考虑几个问题：
1）读取方便？
i. 尽可能的把检索条件存储于rowkey中。
ii. 同时访问的数据，rowkey尽量连接，即可以利用scan指定start和end rowkey直接访问。
2） 提高写效率？
i. 评估业务场景，根据数据分布情况进行预分区，提高并发度。
ii. 有些情况下，可以加入散列值，使写分散到各regionserver，避免单点过载。
十 . mapreduce?的?join?方法有哪些？
http://database.51cto.com/art/201410/454277.htm(里面的例子很好理解)
https://my.oschina.net/leejun2005/blog/95186
如有两个文件File1和File2，文件内容如下：
File1: （学生编码，学生名字，性别）
zs 张三 男
...
File2: （学生编码，选修课程，得分）
zs c1 80
zs c2 90
...
1） reduce join
适用于两张表都是大表
在map阶段，输出，在value中标记数据是来自File1和File2，在reduce阶段，将key的value按照来源是File1还是File2分成两组，做集合乘积。
缺点：
i.? map阶段没有对数据瘦身，shuffle的网络传输和排序性能很低。
ii.? reduce端对2个集合做乘积计算，很耗内存，容易导致OOM。
示例：
在map阶段：map函数同时读入两个文件File1和File2，对每一条数据打一个标签，用来区分数据来源于File1还是File2。连接字段做为key，其他字段及标志做为value。
如
在shuffle阶段:? 会按key分组，连接字段为key，各个map的的输出结果形成list做为value。
如
在reduce阶段:? 对同一个key， 按标志位，将value分成左表和右表，然后进行笛卡尔连接输出。
如 左表 = { "张三 男" }
右表 = {? "c1 80",? "c2 90"? }
然后两个for循环实现笛卡尔连接输出：
张三 男 c1 80
张三 男 c2 90
2） map join
适合一张小表，一张大表。
小数据文件全部加载到内存，大数据文件作为map的输入文件，在内存中和小数据文件进行连接，按key分组输出。减小shuffle阶段的排序和网络传输消耗。
示例：
假设File1为小表，File2为大表。
i.? 将小表文件File1放到该作业的DistributedCache中。
ii.? 在setup函数中，将File1从DistributedCache中读入内存中，如hash map中。如：
{zs, "张三 男"}
iii.? 在map函数中，扫描File2，判断File2的key在不在hasp map中，如果在，直接输出（
key + hash map中该key的value +? File2中其他字段） 如：
zm 张三 男? c1 80
3）semi join
reduce join的一个变种。将File1中参与join的key单独抽取出来，存入File3。通过Distributed Cache分发到相关节点，然后将其取出放到内存中，如hash set中。在map阶段扫描连接表，将key不在set中的记录过滤掉，将那些参与join的记录打上标签通过shuffle传输到reduce端进行操作，后面的过程和reduce join是一样的。
4）reduce join + boomfilter
如果semi join 抽取出来的key在内存中还放不下，则考虑将key放入boomfilter。通过boomfilter过滤掉不需要参与join的记录，将那些参与join的记录打上标签通过shuffle传输到reduce端进行操作，后面的过程和reduce join是一样的。boomfilter是通过二进制位（0101这些）记录数据，所以占用空间比较小。
十一 MR数据倾斜原因和解决方案
数据倾斜就是数据key分布不均匀，导致分发到不同的reduce上，个别reduce任务特别重，导致其他reduce都完成，而这些个别的reduce迟迟不完成的情况。
http://blog.sina.com.cn/s/blog_9402246001013kxf.html
http://www.cnblogs.com/datacloud/p/3601624.html
原因如下：
1） key分布不均匀
2） 业务数据本身的特征
解决方案：
假设A、B两张表关联，A中存在数据倾斜的key
1）先对A表进行采样，将造成数据倾斜的key的记录存入一个临时表tmp1。
2）一般情况下，造成数据倾斜的key不会太多，所以tmp1会是一个小表。所以可以将tmp1和B表进行map join，生成tmp2，再把tmp2分发到distribute file cache。
3）map读入A表和B表，假如记录来自A表，则判断key是否在tmp2中，如果是，输出到本地文件a，如果不是，则生成对，假如记录来自B表，生成对，进入reduce阶段。
4）将文件a和步骤3中reduce输出文件合并起来写到hdfs。
通俗的说法：
1）map端数据倾斜，一般是输入文件太多且大小不一造成的，可以考虑合并文件。
2）reduce端数据倾斜，一般是默认的分区器问题，可以考虑自定义分区， 根据数据中key特性及分布情况自定义分区，使之尽可能均匀地分配到reduce。
3）设置Combine, 聚合精简数据。
4 ) 两张表join， 如果造成数据倾斜的key记录占全量数据比例较少的话，可以考虑将数据分为倾斜和非倾斜部分，这样倾斜部分会是小文件，可以使用map join处理，非倾斜部分则可以按正常reduce处理，最后合并起来即可。
如果使用hive统计，可以通过以下办法解决：
1) 调节hive配置参数：
i. hive.map.aggr = true? --map端部分聚合 相当于Combiner
ii. hive.groupby.skewindata = true? --有数据倾斜时，查询计划生成两个mr job，第一个job先进行key随机分配处理，先缩小数据量。第二个job再进行真正的group by key数理。
2) SQL调节
i. 大小表join
使用map join让小表先进内存，在map端完成reduce。
ii. 大表join大表
如果是空值造成数据倾斜，那么把空值变成一个字符串加上随机数，把这部分倾斜的数据分发到不同的reduce上。
iii. count distinct 大量相同特殊值 （如空值）
空值可以不用处理，直接最后count结果加1即可。或者空值单独拿出来处理，最后再union回去。
iv. 不同数据类型关联
默认的hash操作会按其中一种类型的值进行分配，导致别一种类型全部分发到同一个reduce中。把两个关联的类型转换成相同类型。
1NF：字段不可分割。? org_id只能存机构编码，不能存机构编码+用户编码
2NF：主键不可冗余。? org_id+kpi_code 做为主键可以。 org_id+org_name+kpi_code做为主键不妥。
3NF：非主键不可依赖。org_id，kpi_code，kpi_value做为一张表可以，org_id,? org_name, kpi_code,? kpi_value做为一张表不妥，因为依赖到非主键org_name。
其实OLTP可以完全遵守3NF，但OLAP只要做到2NF就可以了。
十二 hadoop?运转的原理?
通过namenode管理文件系统的命名空间，维护文件系统树中的所有文件和文件夹的元数据，由datanode存储实际数据，并向namenode汇报数据存储情况。即通过hdfs实现数据存储，通过mr实现数据计算处理。
十三 mapreduce?的原理?
一个根本思想就是“分而治之”，将一个大任务分解成多个小任务，map并行执行后，reduce合并结果。
十四 说说mapreduce?是怎么来运转的?
先将文件进行分割后，进行map操作，后面进行shuffle操作，分为map端shuffle和reduce端shuffle，map输出结果放在缓冲区，当缓存区到达一定阈值时，将其中数据spill（也就是溢写）到磁盘，然后进行partition, sort, combine操作，这样多次spill后，磁盘上就会有多个文件，merge操作将这些文件合并成一个文件，reduce端shuffle从map节点拉取数据文件，如果在内存中放得下，就直接放在内存中，每个map对应一块数据，当内存占用量达到一定程度时，启动内存时merge，把内存中的数据输出到磁盘的一个文件上。如果在内存中放不下的话，就直接写到磁盘上。一个map数据对应一个文件，当文件数量达到一定阀值时，开始启动磁盘文件merge，把这些文件合并到一个文件中。最后，把内存中的文件和磁盘上的文件进行全局merge，形成一个最终端文件，做为reduce的输入文件。当然merge过程中会进行sort,combine操作。
十五 HDFS?存储的机制?
namenode负责维护所有数据目录及文件的元数据，datanode负责实际数据存储。
客户端向hfds写数据，首先会将数据分块，与namenode通信，namenode告知客户端将数据写入datanode的地址，第一个datanode写完后，将数据同步给第2个datanode，依次类推，直到所有备份节点写完为止，然后进入下一个数据块的写操作。
在有启用机架感知的情况下，存储策略为本地一份，同机架内其它某一节点上一份，不同机架的某一节点上一份。
十六 mapreduce?中?Combiner?和?Partition?的作用
Combiner就是在map端先进行一次reduce操作，减少map端到reduce端的数据传输量，节省网络带宽，提高执行效率。
Partition就是将map输出按key分区，送到不同的reduce上去并行执行，提高效率。
十七 Hive?元数据保存的方法有哪些，各有什么特点？
1）、内嵌模式：将元数据保存在本地内嵌的derby数据库中，内嵌的derby数据库每次只能访问一个数据文件，也就意味着它不支持多会话连接。
2）. 本地模式：将元数据保存在本地独立的数据库中（一般是mysql），这可以支持多会话连接。
3）. 远程模式：把元数据保存在远程独立的mysql数据库中，避免每个客户端都去安装mysql数据库。
十八 hadoop机架感知
http://blog.csdn.net/l1028386804/article/details/51935169
topology.script.file.name
value指定一个可执行程序，通常是一个shell脚本，该脚本接受一个参数（ip），输出一个值（机架位置）。
可以将ip，主机名，机架位置配置在一个配置文件中。然后脚本读取该配置文件，去解析传入ip对应的机架位置，并输出即可。当然也可以用java类实现。
hdfs存储策略是本地存储一份，同机架内其他节点存储一份，不同机架某一节点存储一份，当执行计算时，发现本地数据损坏，可以从同一机架相邻节点拿到数据，速度肯定比跨机架来得快。同时，如果整个机架的网络出现异常，也能保证能从其他机架拿到数据。 要实现这个存储策略，就需要机架感知。
十九 hdfs?的数据压缩算法
http://www.tuicool.com/articles/eIfAJbM
压缩格式：gzip,? bzip2,? lzo
压缩算法：deflate[d?‘fle?t],? bzip2，lzo
从压缩效果来讲：bzip2 > gzip > lzo
从压缩速度来讲：lzo > gzip > bizp2
另外bizp2，lzo都支持文件分割，gzip不支持。
所有压缩算法都是时间和空间的权衡，在选择哪种压缩格式时，我们应该根据自身的业务需要来选择。
二十 hadoop?的调度器有哪些，工作原理？
http://www.mamicode.com/info-detail-1097801.html
http://www.cnblogs.com/xing901022/p/6174178.html
https://my.oschina.net/ssrs2202/blog/494729?p={{currentPage+1}}
http://www.tuicool.com/articles/M3ayEj
http://lxw1234.com/archives/2015/10/536.htm
FIFO调度器，只有一个队列，按先进先出的原则为job分配资源。
Capacity调度器，可以设置多个队列，并为每个队列设置资源占比，比如有三个队列，资源占比可以设置为30%，30%，40%。队列之间支持共享资源，当某个队列的资源不用时，可以共享给其他有需要的队列。当集群繁忙时，一旦有些任务完成释放资源形成空闲资源，优先分配给资源利用率低的队列，最终达到按“队列容量”分配资源的效果。队列里面的Job按FIFO规则选择优先顺序。
当然，可以设置队列的最大资源使用量，这样可以保证每个队列都不会占用整体集群的资源。
Fair调度器，可以设置多个队列，并为每个队列设置最小份额，权重等指标，比如整个集群有100G内存，有三个队列，最小份额分别设置为40G,30G,20G，权重分别设置为2，3，4（按照谁愿意分享更多，谁获得更多的原则，即最小份额跟权重成反比关系）。队列之间支持资源共享，当某个队列的资源不用时，可以共享给其他有需要的队列。当集群繁忙时，一旦有些任务完成释放资源形成空闲资源，优先分配给“饥饿程度”（已使用资源量跟最小份额之间的差距程度）较高的队列，慢慢地，大家就会进入都不“饥饿”的状态，这时按已使用资源量/权重 谁小分配给谁，最终达到按最小份额和权重“公平”分配资源的效果。队列里面的Job可按FIFO或Fair（Fair判断指标有：job已使用资源量与实际需要资源量的差距，提交时间）选择优先顺序。
还有Capacity和Fair调度器都支持资源抢占。
二十一 hive?中的压缩格式?RCFile、TextFile、SequenceFile?各有什么区别？
http://blog.csdn.net/yfkiss/article/details/7787742
TextFile：Hive默认格式，不作压缩，磁盘及网络开销较大。可以结合Gzip, Bzip2使用，但使用这种方式，hive不会对数据进行切分，从而无法对数据进行并行操作。
SequenceFile:? SequenceFile 是Hadoop API提供支持的一种二进制文件，具有使用方便，可分割，可压缩的特点，支持三种压缩选择：NONE, RECORD, BLOCK。RECORD压缩率低，一般建议使用BLOCK压缩。
RCFILE:? RCFILE是一种行列存储相结合的的存储方式。首先，将数据按行分块，保证同一个record在一个块上，避免读一个记录需要读取多个block。其次，块数据列式存储，有利于数据压缩。
总结：相比TEXTFILE和SEQUENCEFILE，RCFILE由于列式存储方式，数据加载时性能消耗较大，但是具有较好的压缩比和查询响应。数据仓库的特点是一次写入，多次读取，因此，整体来看，RCFILE相比两它两种格式，具有较明显的优势。
二十二 Hive中的内部表，外部表，分区表、桶表有什么区别和作用？
内部表：数据存储在Hive的数据仓库目录下，删除表时，除了删除元数据，还会删除实际表文件。
外部表：数据并不存储在Hive的数据仓库目录下，删除表时，只是删除元数据，并不删除实际表文件。
分区表：跟RDMS的分区概念类似，将一张表的数据按照分区规则分成多个目录存储。这样可以通过指定分区来提高查询速度。
桶表：在表或分区的基础上，按某一列的值将记录进行分桶存放，即分文件存放，也就是将大表变成小表的意思，这样，涉及到Join操作时，可以在桶与桶间关联即可，大大减小Join的数据量，提高执行效率。
二十三 kafka的message包括哪些信息
一个Kafka的Message由一个固定长度的header和一个变长的消息体body组成header部分由一个字节的magic(文件格式)和四个字节的CRC32(用于判断body消息体是否正常)构成。当magic的值为1的时候，会在magic和crc32之间多一个字节的数据：attributes(保存一些相关属性，比如是否压缩、压缩格式等等)；如果magic的值为0，那么不存在attributes属性
body是由N个字节构成的一个消息体，包含了具体的key/value消息
二十四 怎么查看kafka的offset
0.9版本以上，可以用最新的Consumer client 客户端，有consumer.seekToEnd() / consumer.position() 可以用于得到当前最新的offset：
二十五 hadoop的shuffle过程
Map端的shuffle
Map端会处理输入数据并产生中间结果，这个中间结果会写到本地磁盘，而不是HDFS。每个Map的输出会先写到内存缓冲区中，当写入的数据达到设定的阈值时，系统将会启动一个线程将缓冲区的数据写到磁盘，这个过程叫做spill。
在spill写入之前，会先进行二次排序，首先根据数据所属的partition进行排序，然后每个partition中的数据再按key来排序。partition的目是将记录划分到不同的Reducer上去，以期望能够达到负载均衡，以后的Reducer就会根据partition来读取自己对应的数据。接着运行combiner(如果设置了的话)，combiner的本质也是一个Reducer，其目的是对将要写入到磁盘上的文件先进行一次处理，这样，写入到磁盘的数据量就会减少。最后将数据写到本地磁盘产生spill文件(spill文件保存在{mapred.local.dir}指定的目录中，Map任务结束后就会被删除)。
最后，每个Map任务可能产生多个spill文件，在每个Map任务完成前，会通过多路归并算法将这些spill文件归并成一个文件。至此，Map的shuffle过程就结束了。
Reduce端的shuffle
Reduce端的shuffle主要包括三个阶段，copy、sort(merge)和reduce。
首先要将Map端产生的输出文件拷贝到Reduce端，但每个Reducer如何知道自己应该处理哪些数据呢？因为Map端进行partition的时候，实际上就相当于指定了每个Reducer要处理的数据(partition就对应了Reducer)，所以Reducer在拷贝数据的时候只需拷贝与自己对应的partition中的数据即可。每个Reducer会处理一个或者多个partition，但需要先将自己对应的partition中的数据从每个Map的输出结果中拷贝过来。
接下来就是sort阶段，也成为merge阶段，因为这个阶段的主要工作是执行了归并排序。从Map端拷贝到Reduce端的数据都是有序的，所以很适合归并排序。最终在Reduce端生成一个较大的文件作为Reduce的输入。
最后就是Reduce过程了，在这个过程中产生了最终的输出结果，并将其写到HDFS上。
二十六 spark集群运算的模式
Spark 有很多种模式，最简单就是单机本地模式，还有单机伪分布式模式，复杂的则运行在集群中，目前能很好的运行在 Yarn和 Mesos 中，当然 Spark 还有自带的 Standalone 模式，对于大多数情况 Standalone 模式就足够了，如果企业已经有 Yarn 或者 Mesos 环境，也是很方便部署的。
standalone(集群模式)：典型的Mater/slave模式，不过也能看出Master是有单点故障的；Spark支持ZooKeeper来实现 HA
on yarn(集群模式)： 运行在 yarn 资源管理器框架之上，由 yarn 负责资源管理，Spark 负责任务调度和计算
on mesos(集群模式)： 运行在 mesos 资源管理器框架之上，由 mesos 负责资源管理，Spark 负责任务调度和计算
on cloud(集群模式)：比如 AWS 的 EC2，使用这个模式能很方便的访问 Amazon的 S3;Spark 支持多种分布式存储系统：HDFS 和 S3
二十七 HDFS读写数据的过程
读：
1、跟namenode通信查询元数据，找到文件块所在的datanode服务器
2、挑选一台datanode（就近原则，然后随机）服务器，请求建立socket流
3、datanode开始发送数据（从磁盘里面读取数据放入流，以packet为单位来做校验）
4、客户端以packet为单位接收，现在本地缓存，然后写入目标文件
写：
1、根namenode通信请求上传文件，namenode检查目标文件是否已存在，父目录是否存在
2、namenode返回是否可以上传
3、client请求第一个 block该传输到哪些datanode服务器上
4、namenode返回3个datanode服务器ABC
5、client请求3台dn中的一台A上传数据（本质上是一个RPC调用，建立pipeline），A收到请求会继续调用B，然后B调用C，将真个pipeline建立完成，逐级返回客户端
6、client开始往A上传第一个block（先从磁盘读取数据放到一个本地内存缓存），以packet为单位，A收到一个packet就会传给B，B传给C；A每传一个packet会放入一个应答队列等待应答
7、当一个block传输完成之后，client再次请求namenode上传第二个block的服务器。
二十八 RDD中reduceBykey与groupByKey哪个性能好，为什么
reduceByKey：reduceByKey会在结果发送至reducer之前会对每个mapper在本地进行merge，有点类似于在MapReduce中的combiner。这样做的好处在于，在map端进行一次reduce之后，数据量会大幅度减小，从而减小传输，保证reduce端能够更快的进行结果计算。
groupByKey：groupByKey会对每一个RDD中的value值进行聚合形成一个序列(Iterator)，此操作发生在reduce端，所以势必会将所有的数据通过网络进行传输，造成不必要的浪费。同时如果数据量十分大，可能还会造成OutOfMemoryError。
通过以上对比可以发现在进行大量数据的reduce操作时候建议使用reduceByKey。不仅可以提高速度，还是可以防止使用groupByKey造成的内存溢出问题。
二十九 spark sql怎么取数据的差集
好像不支持
spark2.0的了解
更简单：ANSI SQL与更合理的API
速度更快：用Spark作为编译器
更智能：Structured Streaming
三十 rdd 怎么分区宽依赖和窄依赖
宽依赖：父RDD的分区被子RDD的多个分区使用 例如 groupByKey、reduceByKey、sortByKey等操作会产生宽依赖，会产生shuffle
窄依赖：父RDD的每个分区都只被子RDD的一个分区使用 例如map、filter、union等操作会产生窄依赖
三十一spark streaming 读取kafka数据的两种方式
这两种方式分别是：
Receiver-base
使用Kafka的高层次Consumer API来实现。receiver从Kafka中获取的数据都存储在Spark Executor的内存中，然后Spark Streaming启动的job会去处理那些数据。然而，在默认的配置下，这种方式可能会因为底层的失败而丢失数据。如果要启用高可靠机制，让数据零丢失，就必须启用Spark Streaming的预写日志机制（Write Ahead Log，WAL）。该机制会同步地将接收到的Kafka数据写入分布式文件系统（比如HDFS）上的预写日志中。所以，即使底层节点出现了失败，也可以使用预写日志中的数据进行恢复。
Direct
Spark1.3中引入Direct方式，用来替代掉使用Receiver接收数据，这种方式会周期性地查询Kafka，获得每个topic+partition的最新的offset，从而定义每个batch的offset的范围。当处理数据的job启动时，就会使用Kafka的简单consumer api来获取Kafka指定offset范围的数据。
三十二 kafka的数据存在内存还是磁盘
Kafka最核心的思想是使用磁盘，而不是使用内存，可能所有人都会认为，内存的速度一定比磁盘快，我也不例外。在看了Kafka的设计思想，查阅了相应资料再加上自己的测试后，发现磁盘的顺序读写速度和内存持平。
而且Linux对于磁盘的读写优化也比较多，包括read-ahead和write-behind，磁盘缓存等。如果在内存做这些操作的时候，一个是JAVA对象的内存开销很大，另一个是随着堆内存数据的增多，JAVA的GC时间会变得很长，使用磁盘操作有以下几个好处：
磁盘缓存由Linux系统维护，减少了程序员的不少工作。
磁盘顺序读写速度超过内存随机读写。
JVM的GC效率低，内存占用大。使用磁盘可以避免这一问题。
系统冷启动后，磁盘缓存依然可用。
三十三 怎么解决kafka的数据丢失
producer端：
宏观上看保证数据的可靠安全性，肯定是依据分区数做好数据备份，设立副本数。
broker端：
topic设置多分区，分区自适应所在机器，为了让各分区均匀分布在所在的broker中，分区数要大于broker数。
分区是kafka进行并行读写的单位，是提升kafka速度的关键。
Consumer端
consumer端丢失消息的情形比较简单：如果在消息处理完成前就提交了offset，那么就有可能造成数据的丢失。由于Kafka consumer默认是自动提交位移的，所以在后台提交位移前一定要保证消息被正常处理了，因此不建议采用很重的处理逻辑，如果处理耗时很长，则建议把逻辑放到另一个线程中去做。为了避免数据丢失，现给出两点建议：
enable.auto.commit=false 关闭自动提交位移
在消息被完整处理之后再手动提交位移
三十四 给定a、b两个文件，各存放50亿个url，每个url各占64字节，内存限制是4G，让你找出a、b文件共同的url?
假如每个url大小为10bytes，那么可以估计每个文件的大小为50G×64=320G，远远大于内存限制的4G，所以不可能将其完全加载到内存中处理，可以采用分治的思想来解决。
Step1：遍历文件a，对每个url求取hash(url)%1000，然后根据所取得的值将url分别存储到1000个小文件(记为a0,a1,...,a999，每个小文件约300M);
Step2:遍历文件b，采取和a相同的方式将url分别存储到1000个小文件(记为b0,b1,...,b999);
巧妙之处：这样处理后，所有可能相同的url都被保存在对应的小文件(a0vsb0,a1vsb1,...,a999vsb999)中，不对应的小文件不可能有相同的url。然后我们只要求出这个1000对小文件中相同的url即可。
Step3：求每对小文件ai和bi中相同的url时，可以把ai的url存储到hash_set/hash_map中。然后遍历bi的每个url，看其是否在刚才构建的hash_set中，如果是，那么就是共同的url，存到文件里面就可以了。
草图如下(左边分解A，右边分解B，中间求解相同url)：
三十五 .有一个1G大小的一个文件，里面每一行是一个词，词的大小不超过16字节，内存限制大小是1M，要求返回频数最高的100个词。
Step1：顺序读文件中，对于每个词x，取hash(x)%5000，然后按照该值存到5000个小文件(记为f0,f1,...,f4999)中，这样每个文件大概是200k左右，如果其中的有的文件超过了1M大小，还可以按照类似的方法继续往下分，直到分解得到的小文件的大小都不超过1M;
Step2：对每个小文件，统计每个文件中出现的词以及相应的频率(可以采用trie树/hash_map等)，并取出出现频率最大的100个词(可以用含100个结点的最小堆)，并把100词及相应的频率存入文件，这样又得到了5000个文件;
Step3：把这5000个文件进行归并(类似与归并排序);
草图如下(分割大问题，求解小问题，归并)：
三十六 .现有海量日志数据保存在一个超级大的文件中，该文件无法直接读入内存，要求从中提取某天出访问百度次数最多的那个IP。
Step1：从这一天的日志数据中把访问百度的IP取出来，逐个写入到一个大文件中;
Step2：注意到IP是32位的，最多有2^32个IP。同样可以采用映射的方法，比如模1000，把整个大文件映射为1000个小文件;
Step3：找出每个小文中出现频率最大的IP(可以采用hash_map进行频率统计，然后再找出频率最大的几个)及相应的频率;
Step4：在这1000个最大的IP中，找出那个频率最大的IP，即为所求。
草图如下：
三十七 LVS和HAProxy相比，它的缺点是什么?
之前，的确是用LVS进行过MySQL集群的负载均衡，对HAProxy也有过了解，但是将这两者放在眼前进行比较，还真没试着了解过。面试中出现了这么一题，面试官给予的答案是LVS的配置相当繁琐，后来查找了相关资料，对这两种负载均衡方案有了更进一步的了解。LVS的负载均衡性能之强悍已经达到硬件负载均衡的F5的百分之60了，而HAproxy的负载均衡和Nginx负载均衡，均为硬件负载均衡的百分之十左右。由此可见，配置复杂，相应的效果也是显而易见的。在查找资料的过程中，试着将LVS的10种调度算法了解了一下，看似数量挺多的10种算法其实在不同的算法之间，有些只是有着一些细微的差别。在这10种调度算法中，静态调度算法有四种，动态调度算法有6种。
静态调度算法：
①RR轮询调度算法
这种调度算法不考虑服务器的状态，所以是无状态的，同时也不考虑每个服务器的性能，比如我有1-N台服务器，来N个请求了，第一个请求给第一台，第二个请求给第二台，，，第N个请求给第N台服务器，就酱紫。
②加权轮询
这种调度算法是考虑到服务器的性能的，你可以根据不同服务器的性能，加上权重进行分配相应的请求。
③基于目的地址的hash散列
这种调度算法和基于源地址的hash散列异曲同工，都是为了维持一个session，基于目的地址的hash散列，将记住同一请求的目的地址，将这类请求发往同一台目的服务器。简而言之，就是发往这个目的地址的请求都发往同一台服务器。而基于源地址的hash散列，就是来自同一源地址的请求都发往同一台服务器。
④基于源地址的hash散列
上述已讲，不再赘述。
动态调度
①最少连接调度算法
这种调度算法会记录响应请求的服务器上所建立的连接数，每接收到一个请求会相应的将该服务器的所建立连接数加1，同时将新来的请求分配到当前连接数最少的那台机器上。
②加权最少连接调度算法
这种调度算法在最少连接调度算法的基础上考虑到服务器的性能。当然，做这样子的考虑是有其合理性存在的，如果是同一规格的服务器，那么建立的连接数越多，必然越增加其负载，那么仅仅根据最少连接数的调度算法，必然可以实现合理的负载均衡。但如果，服务器的性能不一样呢?比如我有一台服务器，最多只能处理10个连接，现在建立了3个，还有一台服务器最多能处理1000条连接，现在建立了5个，如果单纯地按照上述的最少连接调度算法，妥妥的前者嘛，但前者已经建立了百分之三十的连接了，而后者连百分之一的连接还没有建立，试问，这合理吗?显然不合理。所以加上权重，才算合理。相应的公式也相当简单：active*256/weight。
③最短期望调度算法
这种算法，是避免出现上述加权最少连接调度算法中的一种特殊情况，导致即使加上权重，调度器也无差别对待了，举个栗子：
假设有三台服务器ABC，其当前所建立的连接数相应地为1,2,3，而权重也是1,2,3。那么如果按照加权最少连接调度算法的话，算出来是这样子的：
A:1256/1=256
B:2256/2=256
C:3256/3=256
我们会发现，即便加上权重，A、B、C，经过计算还是一样的，这样子调度器会无差别的在A、B、C中任选一台，将请求发过去。
而最短期望将active256/weight的算法改进为(active+1)256/weight
那么还是之前的例子：
A:(1+1)256/1=2/1256=2256
B:(2+1)256/2=3/2256=1.5256
C:(3+1)256、3=4/3256≈1.3256
显然C
④永不排队算法
将请求发给当前连接数为0的服务器上。
⑤基于局部的最少连接调度算法
这种调度算法应用于Cache系统，维持一个请求到一台服务器的映射，其实我们仔细想想哈，之前做的一系列最少连接相关的调度算法。考虑到的是服务器的状态与性能，但是一次请求并不是单向的，就像有一个从未合作过的大牛，他很闲，你让他去解决一个之前碰到过的一个问题，未必有找一个之前已经跟你合作过哪怕现在不怎么闲的臭皮匠效果好哦~，所以基于局部的最少连接调度算法，维持的这种映射的作用是，如果来了一个请求，相对应的映射的那台服务器，没有超载，ok交给老伙伴完事吧，俺放心，如果那台服务器不存在，或者是超载的状态且有其他服务器工作在一半的负载状态，则按最少连接调度算法在集群其余的服务器中找一台将请求分配给它。
⑥基于复制的局部最少连接调度算法
这种调度算法同样应用于cache系统，但它维持的不是到一台服务器的映射而是到一组服务器的映射，当有新的请求到来，根据最小连接原则，从该映射的服务器组中选择一台服务器，如果它没有超载则交给它去处理这个请求，如果发现它超载，则从服务器组外的集群中，按最少连接原则拉一台机器加入服务器组，并且在服务器组有一段时间未修改后，将最忙的那台服务器从服务器组中剔除。
三十八 .Sqoop用起来感觉怎样?
说实话，Sqoop在导入数据的速度上确实十分感人，通过进一步了解，发现Sqoop1和Sqoop2在架构上还是有明显不同的，无论是从数据类型上还是从安全权限，密码暴露方面，Sqoop2都有了明显的改进，同时同一些其他的异构数据同步工具比较,如淘宝的DataX或者Kettle相比，Sqoop无论是从导入数据的效率上还是从支持插件的丰富程度上，Sqoop还是相当不错滴!!
三十九 ZooKeeper的角色以及相应的Zookepper工作原理?
果然，人的记忆力是有衰减曲线的，当面试官抛出这个问题后，前者角色，我只答出了两种(leader和follower)，后者原理压根就模糊至忘记了。所以恶补了一下，涉及到Zookeeper的角色大概有如下四种：leader、learner(follower)、observer、client。其中leader主要用来决策和调度，follower和observer的区别仅仅在于后者没有写的职能，但都有将client请求提交给leader的职能，而observer的出现是为了应对当投票压力过大这种情形的，client就是用来发起请求的。而Zookeeper所用的分布式一致性算法包括leader的选举其实和-原始部落的获得神器为酋长，或者得玉玺者为皇帝类似，谁id最小，谁为leader，会根据你所配置的相应的文件在相应的节点机下生成id，然后相应的节点会通过getchildren()这个函数获取之前设置的节点下生成的id，谁最小，谁是leader。并且如果万一这个leader挂掉了或者堕落了，则由次小的顶上。而且在配置相应的zookeeper文件的时候回有类似于如下字样的信息：Server.x=AAAA:BBBB:CCCC。其中的x即为你的节点号哈，AAAA对应你所部属zookeeper所在的ip地址，BBBB为接收client请求的端口，CCCC为重新选举leader端口。
四十 .HBase的Insert与Update的区别?
这个题目是就着最近的一次项目问的，当时实现的与hbase交互的三个方法分别为insert、delete、update。由于那个项目是对接的一个项目，对接的小伙伴和我协商了下，不将update合并为insert，如果合并的话，按那个项目本身，其实通过insert执行overwrite相当于间接地Update，本质上，或者说在展现上是没什么区别的包括所调用的put。但那仅仅是就着那个项目的程序而言，如果基于HBaseshell层面。将同一rowkey的数据插入HBase，其实虽然展现一条，但是相应的timestamp是不一样的，而且最大的版本数可以通过配置文件进行相应地设置。
四十一 请简述大数据的结果展现方式。
1)报表形式
基于数据挖掘得出的数据报表，包括数据表格、矩阵、图形和自定义格式的报表等，使用方便、设计灵活。
2)图形化展现
提供曲线、饼图、堆积图、仪表盘、鱼骨分析图等图形形式宏观展现模型数据的分布情况，从而便于进行决策。
3)KPI展现
提供表格式绩效一览表并可自定义绩效查看方式，如数据表格或走势图，企业管理者可根据可度量的目标快速评估进度。
4)查询展现
按数据查询条件和查询内容，以数据表格来汇总查询结果，提供明细查询功能，并可在查询的数据表格基础上进行上钻、下钻、旋转等操作。
四十二 例举身边的大数据。
i.QQ，微博等社交软件产生的数据
ii.天猫，京东等电子商务产生的数据
iii.互联网上的各种数据
四十三 简述大数据的数据管理方式。
答：对于图像、视频、URL、地理位置等类型多样的数据，难以用传统的结构化方式描述，因此需要使用由多维表组成的面向列存储的数据管理系统来组织和管理数据。也就是说，将数据按行排序，按列存储，将相同字段的数据作为一个列族来聚合存储。不同的列族对应数据的不同属性，这些属性可以根据需求动态增加，通过这样的分布式实时列式数据库对数据统一进行结构化存储和管理，避免了传统数据存储方式下的关联查询。
四十四 什么是大数据?
答：大数据是指无法在容许的时间内用常规软件工具对其内容进行抓取、管理和处理的数据。
四十五 海量日志数据，提取出某日访问百度次数最多的那个IP。
首先是这一天，并且是访问百度的日志中的IP取出来，逐个写入到一个大文件中。注意到IP是32位的，最多有个2^32个IP。同样可以采用映射的方法，比如模1000，把整个大文件映射为1000个小文件，再找出每个小文中出现频率最大的IP(可以采用hash_map进行频率统计，然后再找出频率最大的几个)及相应的频率。然后再在这1000个最大的IP中，找出那个频率最大的IP，即为所求。
或者如下阐述(雪域之鹰)：
算法思想：分而治之+Hash
1)IP地址最多有2^32=4G种取值情况，所以不能完全加载到内存中处理;
2)可以考虑采用“分而治之”的思想，按照IP地址的Hash(IP)%1024值，把海量IP日志分别存储到1024个小文件中。这样，每个小文件最多包含4MB个IP地址;
3)对于每一个小文件，可以构建一个IP为key，出现次数为value的Hashmap，同时记录当前出现次数最多的那个IP地址;
4)可以得到1024个小文件中的出现次数最多的IP，再依据常规的排序算法得到总体上出现次数最多的IP;
四十六 .搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。
假设目前有一千万个记录(这些查询串的重复度比较高，虽然总数是1千万，但如果除去重复后，不超过3百万个。一个查询串的重复度越高，说明查询它的用户越多，也就是越热门。)，请你统计最热门的10个查询串，要求使用的内存不能超过1G。
典型的TopK算法，还是在这篇文章里头有所阐述，详情请参见：十一、从头到尾彻底解析Hash表算法。
文中，给出的最终算法是：
第一步、先对这批海量数据预处理，在O(N)的时间内用Hash表完成统计(之前写成了排序，特此订正。July、2011.04.27);
第二步、借助堆这个数据结构，找出TopK，时间复杂度为N‘logK。
即，借助堆结构，我们可以在log量级的时间内查找和调整/移动。因此，维护一个K(该题目中是10)大小的小根堆，然后遍历300万的Query，分别和根元素进行对比所以，我们最终的时间复杂度是：O(N)+N’*O(logK)，(N为1000万，N’为300万)。ok，更多，详情，请参考原文。
或者：采用trie树，关键字域存该查询串出现的次数，没有出现为0。最后用10个元素的最小推来对出现频率进行排序。
四十七 有一个1G大小的一个文件，里面每一行是一个词，词的大小不超过16字节，内存限制大小是1M。返回频数最高的100个词。
方案：顺序读文件中，对于每个词x，取hash(x)%5000，然后按照该值存到5000个小文件(记为x0,x1,…x4999)中。这样每个文件大概是200k左右。
如果其中的有的文件超过了1M大小，还可以按照类似的方法继续往下分，直到分解得到的小文件的大小都不超过1M。
对每个小文件，统计每个文件中出现的词以及相应的频率(可以采用trie树/hash_map等)，并取出出现频率最大的100个词(可以用含100个结点的最小堆)，并把100个词及相应的频率存入文件，这样又得到了5000个文件。下一步就是把这5000个文件进行归并(类似与归并排序)的过程了。
四十八 .有10个文件，每个文件1G，每个文件的每一行存放的都是用户的query，每个文件的query都可能重复。要求你按照query的频度排序。
还是典型的TOPK算法，解决方案如下：
方案1：
顺序读取10个文件，按照hash(query)%10的结果将query写入到另外10个文件(记为)中。这样新生成的文件每个的大小大约也1G(假设hash函数是随机的)。
找一台内存在2G左右的机器，依次对用hash_map(query,query_count)来统计每个query出现的次数。利用快速/堆/归并排序按照出现次数进行排序。将排序好的query和对应的query_cout输出到文件中。这样得到了10个排好序的文件(记为)。
对这10个文件进行归并排序(内排序与外排序相结合)。
方案2：
一般query的总量是有限的，只是重复的次数比较多而已，可能对于所有的query，一次性就可以加入到内存了。这样，我们就可以采用trie树/hash_map等直接来统计每个query出现的次数，然后按出现次数做快速/堆/归并排序就可以了。
方案3：
与方案1类似，但在做完hash，分成多个文件后，可以交给多个文件来处理，采用分布式的架构来处理(比如MapReduce)，最后再进行合并。
四十九 .给定a、b两个文件，各存放50亿个url，每个url各占64字节，内存限制是4G，让你找出a、b文件共同的url?
方案1：可以估计每个文件安的大小为5G×64=320G，远远大于内存限制的4G。所以不可能将其完全加载到内存中处理。考虑采取分而治之的方法。
遍历文件a，对每个url求取hash(url)%1000，然后根据所取得的值将url分别存储到1000个小文件(记为a0,a1,…,a999)中。这样每个小文件的大约为300M。
遍历文件b，采取和a相同的方式将url分别存储到1000小文件(记为b0,b1,…,b999)。这样处理后，所有可能相同的url都在对应的小文件(a0vsb0,a1vsb1,…,a999vsb999)中，不对应的小文件不可能有相同的url。然后我们只要求出1000对小文件中相同的url即可。
求每对小文件中相同的url时，可以把其中一个小文件的url存储到hash_set中。然后遍历另一个小文件的每个url，看其是否在刚才构建的hash_set中，如果是，那么就是共同的url，存到文件里面就可以了。
方案2：如果允许有一定的错误率，可以使用Bloomfilter，4G内存大概可以表示340亿bit。将其中一个文件中的url使用Bloomfilter映射为这340亿bit，然后挨个读取另外一个文件的url，检查是否与Bloomfilter，如果是，那么该url应该是共同的url(注意会有一定的错误率)。
Bloomfilter日后会在本BLOG内详细阐述。
五十 .在2.5亿个整数中找出不重复的整数，注，内存不足以容纳这2.5亿个整数。
方案1：采用2-Bitmap(每个数分配2bit，00表示不存在，01表示出现一次，10表示多次，11无意义)进行，共需内存2^32*2bit=1GB内存，还可以接受。然后扫描这2.5亿个整数，查看Bitmap中相对应位，如果是00变01，01变10，10保持不变。所描完事后，查看bitmap，把对应位是01的整数输出即可。
方案2：也可采用与第1题类似的方法，进行划分小文件的方法。然后在小文件中找出不重复的整数，并排序。然后再进行归并，注意去除重复的元素。
五十一 .腾讯面试题：给40亿个不重复的unsignedint的整数，没排过序的，然后再给一个数，如何快速判断这个数是否在那40亿个数当中?
与上第6题类似，我的第一反应时快速排序+二分查找。以下是其它更好的方法：
方案1：oo，申请512M的内存，一个bit位代表一个unsignedint值。读入40亿个数，设置相应的bit位，读入要查询的数，查看相应bit位是否为1，为1表示存在，为0表示不存在。
dizengrong：
方案2：这个问题在《编程珠玑》里有很好的描述，大家可以参考下面的思路，探讨一下：
又因为2^32为40亿多，所以给定一个数可能在，也可能不在其中;
这里我们把40亿个数中的每一个用32位的二进制来表示
假设这40亿个数开始放在一个文件中。
然后将这40亿个数分成两类:
1.最高位为0
2.最高位为1
并将这两类分别写入到两个文件中，其中一个文件中数的个数<=20亿，而另一个>=20亿(这相当于折半了);
与要查找的数的最高位比较并接着进入相应的文件再查找
再然后把这个文件为又分成两类:
1.次最高位为0
2.次最高位为1
并将这两类分别写入到两个文件中，其中一个文件中数的个数<=10亿，而另一个>=10亿(这相当于折半了);
与要查找的数的次最高位比较并接着进入相应的文件再查找。
…….
以此类推，就可以找到了,而且时间复杂度为O(logn)，方案2完。
附：这里，再简单介绍下，位图方法：
使用位图法判断×××数组是否存在重复
判断集合中存在重复是常见编程任务之一，当集合中数据量比较大时我们通常希望少进行几次扫描，这时双重循环法就不可取了。
位图法比较适合于这种情况，它的做法是按照集合中最大元素max创建一个长度为max+1的新数组，然后再次扫描原数组，遇到几就给新数组的第几位置上1，如遇到5就给新数组的第六个元素置1，这样下次再遇到5想置位时发现新数组的第六个元素已经是1了，这说明这次的数据肯定和以前的数据存在着重复。这种给新数组初始化时置零其后置一的做法类似于位图的处理方法故称位图法。它的运算次数最坏的情况为2N。如果已知数组的最大值即能事先给新数组定长的话效率还能提高一倍。
五十二.怎么在海量数据中找出重复次数最多的一个?
方案1：先做hash，然后求模映射为小文件，求出每个小文件中重复次数最多的一个，并记录重复次数。然后找出上一步求出的数据中重复次数最多的一个就是所求(具体参考前面的题)。
五十三 上千万或上亿数据(有重复)，统计其中出现次数最多的钱N个数据。
方案1：上千万或上亿的数据，现在的机器的内存应该能存下。所以考虑采用hash_map/搜索二叉树/红黑树等来进行统计次数。然后就是取出前N个出现次数最多的数据了，可以用第2题提到的堆机制完成。
五十四 一个文本文件，大约有一万行，每行一个词，要求统计出其中最频繁出现的前10个词，请给出思想，给出时间复杂度分析。
方案1：这题是考虑时间效率。用trie树统计每个词出现的次数，时间复杂度是O(nle)(le表示单词的平准长度)。然后是找出出现最频繁的前10个词，可以用堆来实现，前面的题中已经讲到了，时间复杂度是O(nlg10)。所以总的时间复杂度，是O(nle)与O(nlg10)中较大的哪一个。
五十五100w个数中找出最大的100个数。
方案1：在前面的题中，我们已经提到了，用一个含100个元素的最小堆完成。复杂度为O(100w*lg100)。
方案2：采用快速排序的思想，每次分割之后只考虑比轴大的一部分，知道比轴大的一部分在比100多的时候，采用传统排序算法排序，取前100个。复杂度为O(100w*100)。
方案3：采用局部淘汰法。选取前100个元素，并排序，记为序列L。然后一次扫描剩余的元素x，与排好序的100个元素中最小的元素比，如果比这个最小的要大，那么把这个最小的元素删除，并把x利用插入排序的思想，插入到序列L中。依次循环，知道扫描了所有的元素。复杂度为O(100w*100)。
五十六 十个海量数据处理方法大总结
ok，看了上面这么多的面试题，是否有点头晕。是的，需要一个总结。接下来，本文将简单总结下一些处理海量数据问题的常见方法，而日后，本BLOG内会具体阐述这些方法。
一、Bloomfilter
适用范围：可以用来实现数据字典，进行数据的判重，或者集合求交集
五十七 基本原理及要点：
对于原理来说很简单，位数组+k个独立hash函数。将hash函数对应的值的位数组置1，查找时如果发现所有hash函数对应位都是1说明存在，很明显这个过程并不保证查找的结果是100%正确的。同时也不支持删除一个已经插入的关键字，因为该关键字对应的位会牵动到其他的关键字。所以一个简单的改进就是countingBloomfilter，用一个counter数组代替位数组，就可以支持删除了。
还有一个比较重要的问题，如何根据输入元素个数n，确定位数组m的大小及hash函数个数。当hash函数个数k=(ln2)(m/n)时错误率最小。在错误率不大于E的情况下，m至少要等于nlg(1/E)才能表示任意n个元素的集合。但m还应该更大些，因为还要保证bit数组里至少一半为0，则m应该>=nlg(1/E)*lge大概就是nlg(1/E)1.44倍(lg表示以2为底的对数)。
举个例子我们假设错误率为0.01，则此时m应大概是n的13倍。这样k大概是8个。
注意这里m与n的单位不同，m是bit为单位，而n则是以元素个数为单位(准确的说是不同元素的个数)。通常单个元素的长度都是有很多bit的。所以使用bloomfilter内存上通常都是节省的。
扩展：
Bloomfilter将集合中的元素映射到位数组中，用k(k为哈希函数个数)个映射位是否全1表示元素在不在这个集合中。Countingbloomfilter(CBF)将位数组中的每一位扩展为一个counter，从而支持了元素的删除操作。SpectralBloomFilter(SBF)将其与集合元素的出现次数关联。SBF采用counter中的最小值来近似表示元素的出现频率。
问题实例：给你A,B两个文件，各存放50亿条URL，每条URL占用64字节，内存限制是4G，让你找出A,B文件共同的URL。如果是三个乃至n个文件呢?
根据这个问题我们来计算下内存的占用，4G=2^32大概是40亿*8大概是340亿，n=50亿，如果按出错率0.01算需要的大概是650亿个bit。现在可用的是340亿，相差并不多，这样可能会使出错率上升些。另外如果这些urlip是一一对应的，就可以转换成ip，则大大简单了。
五十八 Hashing
适用范围：快速查找，删除的基本数据结构，通常需要总数据量可以放入内存
基本原理及要点：
hash函数选择，针对字符串，整数，排列，具体相应的hash方法。
碰撞处理，一种是openhashing，也称为拉链法;另一种就是closedhashing，也称开地址法，openedaddressing。
扩展：
d-lefthashing中的d是多个的意思，我们先简化这个问题，看一看2-lefthashing。2-lefthashing指的是将一个哈希表分成长度相等的两半，分别叫做T1和T2，给T1和T2分别配备一个哈希函数，h1和h2。在存储一个新的key时，同时用两个哈希函数进行计算，得出两个地址h1[key]和h2[key]。这时需要检查T1中的h1[key]位置和T2中的h2[key]位置，哪一个位置已经存储的(有碰撞的)key比较多，然后将新key存储在负载少的位置。如果两边一样多，比如两个位置都为空或者都存储了一个key，就把新key存储在左边的T1子表中，2-left也由此而来。在查找一个key时，必须进行两次hash，同时查找两个位置。
问题实例：
1).海量日志数据，提取出某日访问百度次数最多的那个IP。
IP的数目还是有限的，最多2^32个，所以可以考虑使用hash将ip直接存入内存，然后进行统计。
五十九 bit-map
适用范围：可进行数据的快速查找，判重，删除，一般来说数据范围是int的10倍以下
基本原理及要点：使用bit数组来表示某些元素是否存在，比如8位电话号码
扩展：bloomfilter可以看做是对bit-map的扩展
问题实例：
1)已知某个文件内包含一些电话号码，每个号码为8位数字，统计不同号码的个数。
8位最多99999999，大概需要99m个bit，大概10几m字节的内存即可。
2)2.5亿个整数中找出不重复的整数的个数，内存空间不足以容纳这2.5亿个整数。
将bit-map扩展一下，用2bit表示一个数即可，0表示未出现，1表示出现一次，2表示出现2次及以上。或者我们不用2bit来进行表示，我们用两个bit-map即可模拟实现这个2bit-map。
六十 堆
适用范围：海量数据前n大，并且n比较小，堆可以放入内存
基本原理及要点：最大堆求前n小，最小堆求前n大。方法，比如求前n小，我们比较当前元素与最大堆里的最大元素，如果它小于最大元素，则应该替换那个最大元素。这样最后得到的n个元素就是最小的n个。适合大数据量，求前n小，n的大小比较小的情况，这样可以扫描一遍即可得到所有的前n元素，效率很高。
扩展：双堆，一个最大堆与一个最小堆结合，可以用来维护中位数。
问题实例：
1)100w个数中找最大的前100个数。
用一个100个元素大小的最小堆即可。
六十一 双层桶划分—-其实本质上就是【分而治之】的思想，重在“分”的技巧上!
适用范围：第k大，中位数，不重复或重复的数字
基本原理及要点：因为元素范围很大，不能利用直接寻址表，所以通过多次划分，逐步确定范围，然后最后在一个可以接受的范围内进行。可以通过多次缩小，双层只是一个例子。
扩展：
问题实例：
1).2.5亿个整数中找出不重复的整数的个数，内存空间不足以容纳这2.5亿个整数。
有点像鸽巢原理，整数个数为2^32,也就是，我们可以将这2^32个数，划分为2^8个区域(比如用单个文件代表一个区域)，然后将数据分离到不同的区域，然后不同的区域在利用bitmap就可以直接解决了。也就是说只要有足够的磁盘空间，就可以很方便的解决。
2).5亿个int找它们的中位数。
这个例子比上面那个更明显。首先我们将int划分为2^16个区域，然后读取数据统计落到各个区域里的数的个数，之后我们根据统计结果就可以判断中位数落到那个区域，同时知道这个区域中的第几大数刚好是中位数。然后第二次扫描我们只统计落在这个区域中的那些数就可以了。
实际上，如果不是int是int64，我们可以经过3次这样的划分即可降低到可以接受的程度。即可以先将int64分成2^24个区域，然后确定区域的第几大数，在将该区域分成2^20个子区域，然后确定是子区域的第几大数，然后子区域里的数的个数只有2^20，就可以直接利用directaddrtable进行统计了。
六十二 数据库索引
适用范围：大数据量的增删改查
基本原理及要点：利用数据的设计实现方法，对海量数据的增删改查进行处理。
六十三 倒排索引(Invertedindex)
适用范围：搜索引擎，关键字查询
基本原理及要点：为何叫倒排索引?一种索引方法，被用来存储在全文搜索下某个单词在一个文档或者一组文档中的存储位置的映射。
以英文为例，下面是要被索引的文本：
T0=“itiswhatitis”
T1=“whatisit”
T2=“itisabanana”
我们就能得到下面的反向文件索引：
“a”:{2}
“banana”:{2}
“is”:{0,1,2}
“it”:{0,1,2}
“what”:{0,1}
检索的条件”what”,”is”和”it”将对应集合的交集。
正向索引开发出来用来存储每个文档的单词的列表。正向索引的查询往往满足每个文档有序频繁的全文查询和每个单词在校验文档中的验证这样的查询。在正向索引中，文档占据了中心的位置，每个文档指向了一个它所包含的索引项的序列。也就是说文档指向了它包含的那些单词，而反向索引则是单词指向了包含它的文档，很容易看到这个反向的关系。
扩展：
问题实例：文档检索系统，查询那些文件包含了某单词，比如常见的学术论文的关键字搜索。
六十四 外排序
适用范围：大数据的排序，去重
基本原理及要点：外排序的归并方法，置换选择败者树原理，最优归并树
扩展：
问题实例：
1).有一个1G大小的一个文件，里面每一行是一个词，词的大小不超过16个字节，内存限制大小是1M。返回频数最高的100个词。
这个数据具有很明显的特点，词的大小为16个字节，但是内存只有1m做hash有些不够，所以可以用来排序。内存可以当输入缓冲区使用。
六十五trie树
适用范围：数据量大，重复多，但是数据种类小可以放入内存
基本原理及要点：实现方式，节点孩子的表示方式
扩展：压缩实现。
问题实例：
1).有10个文件，每个文件1G，每个文件的每一行都存放的是用户的query，每个文件的query都可能重复。要你按照query的频度排序。
2).1000万字符串，其中有些是相同的(重复),需要把重复的全部去掉，保留没有重复的字符串。请问怎么设计和实现?
3).寻找热门查询：查询串的重复度比较高，虽然总数是1千万，但如果除去重复后，不超过3百万个，每个不超过255字节。
六十六 分布式处理mapreduce
适用范围：数据量大，但是数据种类小可以放入内存
基本原理及要点：将数据交给不同的机器去处理，数据划分，结果归约。
扩展：
问题实例：
1).ThecanonicalexampleapplicationofMapReduceisaprocesstocounttheappearancesof
eachdifferentwordinasetofdocuments:
2).海量数据分布在100台电脑中，想个办法高效统计出这批数据的TOP10。
3).一共有N个机器，每个机器上有N个数。每个机器最多存O(N)个数并对它们操作。如何找到N^2个数的中数(median)?
六十七 经典问题分析
上千万or亿数据(有重复)，统计其中出现次数最多的前N个数据,分两种情况：可一次读入内存，不可一次读入。
可用思路：trie树+堆，数据库索引，划分子集分别统计，hash，分布式计算，近似统计，外排序
所谓的是否能一次读入内存，实际上应该指去除重复后的数据量。如果去重后数据可以放入内存，我们可以为数据建立字典，比如通过map，hashmap，trie，然后直接进行统计即可。当然在更新每条数据的出现次数的时候，我们可以利用一个堆来维护出现次数最多的前N个数据，当然这样导致维护次数增加，不如完全统计后在求前N大效率高。
如果数据无法放入内存。一方面我们可以考虑上面的字典方法能否被改进以适应这种情形，可以做的改变就是将字典存放到硬盘上，而不是内存，这可以参考数据库的存储方法。
当然还有更好的方法，就是可以采用分布式计算，基本上就是map-reduce过程，首先可以根据数据值或者把数据hash(md5)后的值，将数据按照范围划分到不同的机子，最好可以让数据划分后可以一次读入内存，这样不同的机子负责处理各种的数值范围，实际上就是map。得到结果后，各个机子只需拿出各自的出现次数最多的前N个数据，然后汇总，选出所有的数据中出现次数最多的前N个数据，这实际上就是reduce过程。
实际上可能想直接将数据均分到不同的机子上进行处理，这样是无法得到正确的解的。因为一个数据可能被均分到不同的机子上，而另一个则可能完全聚集到一个机子上，同时还可能存在具有相同数目的数据。比如我们要找出现次数最多的前100个，我们将1000万的数据分布到10台机器上，找到每台出现次数最多的前100个，归并之后这样不能保证找到真正的第100个，因为比如出现次数最多的第100个可能有1万个，但是它被分到了10台机子，这样在每台上只有1千个，假设这些机子排名在1000个之前的那些都是单独分布在一台机子上的，比如有1001个，这样本来具有1万个的这个就会被淘汰，即使我们让每台机子选出出现次数最多的1000个再归并，仍然会出错，因为可能存在大量个数为1001个的发生聚集。因此不能将数据随便均分到不同机子上，而是要根据hash后的值将它们映射到不同的机子上处理，让不同的机器处理一个数值范围。
而外排序的方法会消耗大量的IO，效率不会很高。而上面的分布式方法，也可以用于单机版本，也就是将总的数据根据值的范围，划分成多个不同的子文件，然后逐个处理。处理完毕之后再对这些单词的及其出现频率进行一个归并。实际上就可以利用一个外排序的归并过程。
另外还可以考虑近似计算，也就是我们可以通过结合自然语言属性，只将那些真正实际中出现最多的那些词作为一个字典，使得这个规模可以放入内存。
六十八 使用mr，spark,sparksql编写wordcount程序
【Spark版本】
valconf=newSparkConf().setAppName("wd").setMaster("local[1]")
valsc=newSparkContext(conf,2)
//加载
vallines=sc.textFile("tructField("name",DataTypes.StringType,true)")
valparis=lines.flatMap(line=>line.split("^A"))
valwords=paris.map((_,1))
valresult=words.reduceByKey(+).sortBy(x=>x._1,false)
//打印
result.foreach(
wds=>{
println("单词："+wds._1+"个数："+wds._2)
}
)
sc.stop()
【sparksql版本】
valconf=newSparkConf().setAppName("sqlWd").setMaster("local[1]")
valsc=newSparkContext(conf)
valsqlContext=newSQLContext(sc)
//加载
vallines=sqlContext.textFile("E:idea15createRecommederdatawords.txt")
valwords=lines.flatMap(x=>x.split("")).map(y=>Row(y))
valstructType=StructType(Array(StructField("name",DataTypes.StringType,true)))
valdf=sqlContext.createDataFrame(rows,structType)
df.registerTempTable("t_word_count")
sqlContext.udf.register("num_word",(name:String)=>1)
sqlContext.sql("selectname,num_word(name)fromt_word_count").groupBy(df.col("name")).count().show()
sc.stop()
六十九 2hive的使用，内外部表的区别，分区作用，UDF和Hive优化
(1)hive使用：仓库、工具
(2)hive内外部表：内部表数据永久删除，外部表数据删除后、其他人依然可以访问
(3)分区作用：防止数据倾斜
(4)UDF函数：用户自定义的函数(主要解决格式，计算问题)，需要继承UDF类
java代码实现
classTestUDFHiveextendsUDF{
publicStringevalute(Stringstr){
try{
return"hello"+str
}catch(Exceptione){
returnstr+"error"
}
}
}
(5)Hive优化：看做mapreduce处理
a排序优化：sortby效率高于orderby
b分区：使用静态分区(statu_date="20160516",location="beijin")，每个分区对应hdfs上的一个目录
c减少job和task数量：使用表链接操作
d解决groupby数据倾斜问题：设置hive.groupby.skewindata=true，那么hive会自动负载均衡
e小文件合并成大文件：表连接操作
f使用UDF或UDAF函数：hive中UDTF编写和使用(转) - ggjucheng - 博客园
3Hbase的rk设计，Hbase优化
aowkey:hbase三维存储中的关键(rowkey：行键，columnKey(family+quilaty)：列键，timestamp：时间戳)
owkey字典排序、越短越好
使用id+时间：9527+20160517使用hash散列：dsakjkdfuwdsf+9527+20160518
应用中，rowkey一般10~100bytes,8字节的整数倍，有利于提高操作系统性能
bHbase优化
分区：RegionSplit()方法NUMREGIONS=9
column不超过3个
硬盘配置，便于regionServer管理和数据备份及恢复
分配合适的内存给regionserver
其他：
hbase查询
(1)get
(2)scan
使用startRow和endRow限制
4Linux常用操作
aawk：
awk-F:BEGIN{print"nameip"}{print$1$7}END{print"结束"}/etc/passwd
last|head-5|awkBEGIN{print"nameip"}{print$1$3}END{print"结束了"}
bsed
七十 5java线程2种方式实现、设计模式、链表操作、排序
(1)2种线程实现
aThread类继承
TestCLth=newTestCL()//类继承Thread
th.start()
b实现Runnable接口
Threadth=newThread(newRunnable(){
publicvoidrun(){
//实现
}
})
th.start()
(2)设计模式，分为4类
a创建模式：如工厂模式、单例模式
b结构模式：代理模式
c行为模式：观察者模式
d线程池模式
6【最熟悉的一个项目简介、架构图、使用的技术、你负责哪块】
7cdh集群监控
(1)数据库监控(2)主机监控(3)服务监控(4)活动监控
8计算机网络工作原理
将分散的机器通过数据通信原理连接起来，实现共享!
9hadoop生态系统
hdfsmapreducehivehbasezookeeperlume
hdfs原理及各个模块的功能mapreduce原理mapreduce优化数据倾斜
11系统维护：hadoop升级datanode节点
12【讲解项目要点：数据量、多少人、分工、运行时间、项目使用机器、算法、技术】
13【学会向对方提问】
14jvm运行机制及内存原理
运行：
I加载.class文件
II管理并且分配内存
III垃圾回收
内存原理：
IJVM装载环境和配置
II装载JVM.dll并初始化JVM.dll
IV处理class类
15hdfs、yarn参数调优
mapreduce.job.jvm.num.tasks
默认为1，设置为-1，重用jvm
16Hbase、Hive、impala、zookeeper、Storm、spark原理和使用方法、使用其架构图讲解
七十一、如何为一个hadoop任务设置mappers的数量
答案：
使用job.setNumMapTask(intn)手动分割，这是不靠谱的
官方文档：“Note:Thisisonlyahinttotheframework”说明这个方法只是提示作用，不起决定性作用
实际上要用公式计算：
Max(min.split，min(max.split，block))就设置分片的最大最下值computeSplitSize()设置
七十二 有可能使hadoop任务输出到多个目录中么?如果可以，怎么做?
答案：在1.X版本后使用MultipleOutputs.java类实现
源码：
MultipleOutputs.addNamedOutput(conf,"text2",TextOutputFormat.class,Long.class,String.class);
MultipleOutputs.addNamedOutput(conf,"text3",TextOutputFormat.class,Long.class,String.class);
发音：Multiple[‘m?lt?pl]--》许多的
七十三 如何为一个hadoop任务设置要创建的reducer的数量
答案：job.setNumReduceTask(intn)
或者调整hdfs-site.xml中的mapred.tasktracker.reduce.tasks.maximum默认参数值
七十四 在hadoop中定义的主要公用InputFormats中，哪一个是默认值：
(A)TextInputFormat
(B)KeyValueInputFormat
(C)SequenceFileInputFormat
答案：A
七十五 两个类TextInputFormat和KeyValueTextInputFormat的区别?
答案：
?FileInputFormat的子类：
TextInputFormat(默认类型，键是LongWritable类型，值为Text类型，key为当前行在文件中的偏移量，value为当前行本身);
?KeyValueTextInputFormat(适合文件自带key，value的情况，只要指定分隔符即可，比较实用，默认是分割);
源码：
StringsepStr=job.get("mapreduce.input.keyvaluelinerecordreader.key.value.separator","");
注意：在自定义输入格式时，继承FileInputFormat父类
七十六 在一个运行的hadoop任务中，什么是InputSpilt?
答案：InputSplit是MapReduce对文件进行处理和运算的输入单位，只是一个逻辑概念，每个InputSplit并没有对文件实际的切割，只是记录了要处理的数据的位置(包括文件的path和hosts)和长度(由start和length决定)，默认情况下与block一样大。
拓展：需要在定义InputSplit后，展开讲解mapreduce的原理
七十七 Hadoop框架中，文件拆分是怎么被调用的?
答案：JobTracker，创建一个InputFormat的实例，调用它的getSplits()方法，把输入目录的文件拆分成FileSplist作为Mappertask的输入，生成Mappertask加入Queue。
源码中体现了拆分的数量
longgoalSize=totalSize/(numSplits==0?1:numSplits);
longminSize=Math.max(job.getLong(org.apache.hadoop.mapreduce.lib.input.
FileInputFormat.SPLIT_MINSIZE,1),minSplitSize);//minSplitSize默认是1
七十八 分别举例什么情况下使用combiner,什么情况下不会使用?
答案：Combiner适用于对记录汇总的场景(如求和)，但是，求平均数的场景就不能使用Combiner了
七十九、Hadoop中job和Tasks之间的区别是什么?
答案：
job是工作的入口，负责控制、追踪、管理任务，也是一个进程
包含maptask和reducetask
Tasks是map和reduce里面的步骤，主要用于完成任务，也是线程
八十 Hadoop中通过拆分任务到多个节点运行来实现并行计算，但是某些节点运行较慢会拖慢整个任务的运行，hadoop采用何种机制应对这种情况?
答案：结果查看监控日志，得知产生这种现象的原因是数据倾斜问题
解决：
(1)调整拆分mapper的数量(partition数量)
(2)增加jvm
(3)适当地将reduce的数量变大
八十一 流API中的什么特性带来可以使mapreduce任务可以以不同语言(如perlubyawk等)实现的灵活性?
答案：用可执行文件作为Mapper和Reducer，接受的都是标准输入，输出的都是标准输出
八十二 参考下面的M/R系统的场景：
--HDFS块大小为64MB
--输入类型为FileInputFormat
--有3个文件的大小分别是：64k65MB127MB
Hadoop框架会把这些文件拆分为多少块?
答案：
64k------->一个block
65MB---->两个文件：64MB是一个block，1MB是一个block
127MB--->两个文件：64MB是一个block,63MB是一个block
八十三 Hadoop中的RecordReader的作用是什么?
答案：属于split和mapper之间的一个过程
将inputsplit输出的行为一个转换记录，成为key-value的记录形式提供给mapper
八十四 Map阶段结束后，Hadoop框架会处理：Partitioning,shuffle和sort,在这个阶段都会发生了什么?
答案：
MR一共有四个阶段，splitmapshuffreduce在执行完map之后，可以对map的输出结果进行分区，
分区：这块分片确定到哪个reduce去计算(汇总)
排序：在每个分区中进行排序，默认是按照字典顺序。
Group：在排序之后进行分组
八十五 如果没有定义partitioner,那么数据在被送达reducer前是如何被分区的?
答案：
Partitioner是在map函数执行context.write()时被调用。
用户可以通过实现自定义的?Partitioner来控制哪个key被分配给哪个?Reducer。
查看源码知道：
如果没有定义partitioner，那么会走默认的分区Hashpartitioner
publicclassHashPartitionerextendsPartitioner{
/*Use{@linkObject#hashCode()}topartition./
publicintgetPartition(Kkey,Vvalue,intnumReduceTasks){
return(key.hashCode()&Integer.MAX_VALUE)%numReduceTasks;
}
}
八十六 什么是Combiner?
答案：这是一个hadoop优化性能的步骤，它发生在map与reduce之间
目的：解决了数据倾斜的问题，减轻网络压力，实际上时减少了maper的输出
源码信息如下：
publicvoidreduce(Textkey,Iteratorvalues,
OutputCollectoroutput,Reporterreporter)
throwsIOException{
LongWritablemaxValue=null;
while(values.hasNext()){
LongWritablevalue=values.next();
if(maxValue==null){
maxValue=value;
}elseif(value.compareTo(maxValue)>0){
maxValue=value;
}
}
output.collect(key,maxValue);
}
在collect实现类中，有这样一段方法
publicsynchronizedvoidcollect(Kkey,Vvalue)
throwsIOException{
outCounter.increment(1);
writer.append(key,value);
if((outCounter.getValue()%progressBar)==0){
progressable.progress();
八十七 下面哪个程序负责HDFS数据存储。答案C datanode
a)NameNode
b)Jobtracker
c)Datanode
d)secondaryNameNode
e)tasktracker
八十八HDfS中的block默认保存几份?答案A默认3分
a)3份
b)2份
c)1份
d)不确定
八十九 下列哪个程序通常与NameNode在一个节点启动?答案D
a)SecondaryNameNode
b)DataNode
c)TaskTracker
d)Jobtracke
此题分析：
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整体上可以分为这么几条执行线索：obclient，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上。
九十. Hadoop作者 答案：C Doug cutting
a)Martin Fowler
b)Kent Beck
c)Doug cutting
九十一 . HDFS默认Block Size答案：B
a)32MB
b)64MB
c)128MB
(因为版本更换较快，这里答案只供参考)
九十二.下列哪项通常是集群的最主要瓶颈：答案：C磁盘
a)CPU
b)网络
c)磁盘IO
d)内存
该题解析：
首先集群的目的是为了节省成本，用廉价的pc机，取代小型机及大型机。小型机和大型机有什么特点?
1.cpu处理能力强
2.内存够大
所以集群的瓶颈不可能是a和d
3.网络是一种稀缺资源，但是并不是瓶颈。
4.由于大数据面临海量数据，读写数据都需要io，然后还要冗余数据，hadoop一般备3份数据，所以IO就会打折扣。
九十三.关于SecondaryNameNode哪项是正确的?答案C
a)它是NameNode的热备
b)它对内存没有要求
c)它的目的是帮助NameNode合并编辑日志，减少NameNode启动时间
d)SecondaryNameNode应与NameNode部署到一个节点。
多选题：
九十四 下列哪项可以作为集群的管理?答案：ABD
a)Puppet
b)Pdsh
c)Cloudera Manager
d)Zookeeper
九十五 .配置机架感知的下面哪项正确：答案ABC
a)如果一个机架出问题，不会影响数据读写
b)写入数据的时候会写到不同机架的DataNode中
c)MapReduce会根据机架获取离自己比较近的网络数据
九十六 Client端上传文件的时候下列哪项正确?答案B
a)数据经过NameNode传递给DataNode
b)Client端将文件切分为Block，依次上传
c)Client只上传数据到一台DataNode，然后由NameNode负责Block复制工作
该题分析：
Client向NameNode发起文件写入的请求。
NameNode根据文件大小和文件块配置情况，返回给Client它所管理部分DataNode的信息。
Client将文件划分为多个Block，根据DataNode的地址信息，按顺序写入到每一个DataNode块中。
11.下列哪个是Hadoop运行的模式：答案ABC
a)单机版
b)伪分布式
c)分布式
九十七. Cloudera提供哪几种安装CDH的方法?答案：ABCD
a)Cloudera manager
b)Tarball
c)Yum
d)Rpm
判断题：
九十八 Ganglia不仅可以进行监控，也可以进行告警。(正确)
分析：此题的目的是考Ganglia的了解。严格意义上来讲是正确。ganglia作为一款最常用的Linux环境中的监控软件，它擅长的的是从节点中按照用户的需求以较低的代价采集数据。但是ganglia在预警以及发生事件后通知用户上并不擅长。最新的ganglia已经有了部分这方面的功能。但是更擅长做警告的还有Nagios。Nagios，就是一款精于预警、通知的软件。通过将Ganglia和Nagios组合起来，把Ganglia采集的数据作为Nagios的数据源，然后利用Nagios来发送预警通知，可以完美的实现一整套监控管理的系统。
九十九. Block Size是不可以修改的。(错误)
分析：它是可以被修改的Hadoop的基础配置文件是hadoop-default.xml，默认建立一个Job的时候会建立Job的Config，Config首先读入hadoop-default.xml的配置，然后再读入hadoop-site.xml的配置(这个文件初始的时候配置为空)，hadoop-site.xml中主要配置需要覆盖的hadoop-default.xml的系统级配置。
一百. Nagios不可以监控Hadoop集群，因为它不提供Hadoop支持。(错误)
分析：Nagios是集群监控工具，而且是云计算三大利器之一
16.如果NameNode意外终止，SecondaryNameNode会接替它使集群继续工作。(错误)
分析：SecondaryNameNode是帮助恢复，而不是替代，如何恢复，可以查看.
Cloudera CDH是需要付费使用的。(错误)
分析：第一套付费产品是Cloudera Enterpris，Cloudera Enterprise在美国加州举行的Hadoop大会(Hadoop Summit)上公开，以若干私有管理、监控、运作工具加强Hadoop的功能。收费采取合约订购方式，价格随用的Hadoop叢集大小变动。
Hadoop是Java开发的，所以MapReduce只支持Java语言编写。(错误)
分析：rhadoop是用R语言开发的，MapReduce是一个框架，可以理解是一种思想，可以使用其他语言开发。
Hadoop支持数据的随机读写。(错)
分析：lucene是支持随机读写的，而hdfs只支持随机读。但是HBase可以来补救。HBase提供随机读写，来解决Hadoop不能处理的问题。HBase自底层设计开始即聚焦于各种可伸缩性问题：表可以很“高”，有数十亿个数据行;也可以很“宽”，有数百万个列;水平分区并在上千个普通商用机节点上自动复制。表的模式是物理存储的直接反映，使系统有可能提高高效的数据结构的序列化、存储和检索。
NameNode负责管理metadata，client端每次读写请求，它都会从磁盘中读取或则会写入metadata信息并反馈client端。(错误)
此题分析：
NameNode不需要从磁盘读取metadata，所有数据都在内存中，硬盘上的只是序列化的结果，只有每次namenode启动的时候才会读取。
1)文件写入
Client向NameNode发起文件写入的请求。
NameNode根据文件大小和文件块配置情况，返回给Client它所管理部分DataNode的信息。
Client将文件划分为多个Block，根据DataNode的地址信息，按顺序写入到每一个DataNode块中。
2)文件读取
Client向NameNode发起文件读取的请求。
NameNode本地磁盘保存了Block的位置信息。(个人认为正确，欢迎提出其它意见)
分析：DataNode是文件存储的基本单元，它将Block存储在本地文件系统中，保存了Block的Meta-data，同时周期性地将所有存在的Block信息发送给NameNode。NameNode返回文件存储的DataNode的信息。
Client读取文件信息。
DataNode通过长连接与NameNode保持通信。( )
这个有分歧：具体正在找这方面的有利资料。下面提供资料可参考。
首先明确一下概念：
(1).长连接
Client方与Server方先建立通讯连接，连接建立后不断开，然后再进行报文发送和接收。这种方式下由于通讯连接一直存在，此种方式常用于点对点通讯。
(2).短连接
Client方与Server每进行一次报文收发交易时才进行通讯连接，交易完毕后立即断开连接。此种方式常用于一点对多点通讯，比如多个Client连接一个Server.
Hadoop自身具有严格的权限管理和安全措施保障集群正常运行。(错误)
分析：hadoop只能阻止好人犯错，但是不能阻止坏人干坏事
Slave节点要存储数据，所以它的磁盘越大越好。(错误)
分析：一旦Slave节点宕机，数据恢复是一个难题
hadoop dfsadmin –report命令用于检测HDFS损坏块。(错误)
111.集群内每个节点都应该配RAID，这样避免单磁盘损坏，影响整个节点运行。(错误)
分析：首先明白什么是RAID，可以参考百科磁盘阵列。这句话错误的地方在于太绝对，具体情况具体分析。题目不是重点，知识才是最重要的。因为hadoop本身就具有冗余能力，所以如果不是很严格不需要都配备RAID。具体参考第二题。
112.因为HDFS有多个副本，所以NameNode是不存在单点问题的。(错误)
113.每个map槽就是一个线程。(错误)
分析：首先我们知道什么是map槽,map槽->map slotmap slot只是一个逻辑值( org.apache.hadoop.mapred.TaskTracker.TaskLauncher.numFreeSlots )，而不是对应着一个线程或者进程
Mapreduce的input split就是一个block。(错误)
NameNode的Web UI端口是50030，它通过jetty启动的Web服务。(错误)
Hadoop环境变量中的HADOOP_HEAPSIZE用于设置所有Hadoop守护线程的内存。它默认是200 GB。(错误)
分析：hadoop为各个守护进程(namenode,secondarynamenode,jobtracker,datanode,tasktracker)统一分配的内存在hadoop-env.sh中设置，参数为HADOOP_HEAPSIZE，默认为1000M。
收集了这些希望对大家有所帮助，大家可关注我的微信zhanglindashuju有更多精彩内容
原文地址：http://blog.51cto.com/13722730/2118752
