117道有关大数据面试题解析，但愿对你有所帮助

一 .简述如何安装配置apache 的一个开源的hadoop

1. 使用root帐户登录

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

11. 启动节点start-all.sh

二 .列出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上去并行执行，提升效率。

六 面试问答：

一、讲项目经验： 问的很细，给纸，笔，让画公司hadoop的项目架构,说几条业务数据，而后通过平台后，出来成什么样子； 二、java方面： io输入输出流里有哪些经常使用的类，还有webService,线程相关的知识； 三、linux： 问到jps命令，kill命令，问awk,sed是干什么用的、还有hadoop的一些经常使用命令； 四、hadoop： 讲hadoop1中map,shuffle,reduce的过程，其中问到了map端和reduce端溢写的细节； 也问了一些，外部表，还有就是hive的物理模型跟传统数据库的不一样。

七 新手问答： 一、工资多少，工做几年了,有java基础吗,大学学什么 ** 13k,作javaweb将近三年，2014年4月开始学习hadoop,如今已经工做一个多月了，有java基础，大学是计算机系

二、flume,kafka,storm是怎么学的，有没有作优化 ** 看官方文档，先搭环境， 而后用java写代码调用它们的接口，熟悉api不过，若是有视频资源的话，仍是建议尽可能看一下

三、如今用hadoop1仍是2 **hadoop2

四、面试时说作hadoop多久了 ** 我说的将近两年，面试时必定要说有hadoop经验

五、storm,python以前都会吗，仍是进公司后自学的 **这些都是到公司后，自学的

六、你用的hadoop是收费 的仍是免费的 **目前 是用的是免费的

七、本身搭过集群吗，一开始压力大吗 **集群是本身搭的，压力很大，不过车到山前必有路

八、广告做弊用mapreduce计算吗 ** 用的storm，实时处理

九、普通局域网的机子能够搭建么 ** 能够，当时我先在本身机器上测试，用的本身电脑上的虚拟机，后来公司买的去服务器

十、flume的知识有什么高深的东西 **我以为没有什么东西是高深，只是咱们没有涉入，只要用的多，多测试，它只是一个软件而已

十一、你看源码吗， 如今？ **会看源码，可是我以为不要死扣在源码，咱们主要是应用，若是本身有精力，也能够分块研究一下

十二、公司如今有多少台服务器？ **有10台，我用其中四台作了storm,kafka,flume，另外四台作hadoop ,hive,还有两台用作机器学习用

1三、没有java能作hadoop么 **不能吧，必需要会java

1四、面试时会不会让默写代码 **没有遇到过（不一样的公司不同）

1五、本身学，遇到问题都本身解决吗？ **目前遇到的问题，本身都能解决，若是不能的话，会救助同事吧 1六、大家数据库用hbase? **目前还没用，如今主要用mongdb,mysql,redis（hive、hbase的公司很多）

1七、大专很差找工做吗？ 也没有，我有个同事，也是大专，可是她找工做时说本身是本科（由于那职位要求本科），后来面试经过后，又给人事打电话说，我实际上是大专，可是为了获得此次面试机会，我说本身是本科。。。后来人事说这个不要紧。。。那个公司就是×××，她如今已经在那里上班了（这个属于特殊状况，若是比较严的公司，拒绝的可能性是很是大的，除非实力强劲，大专找到工做是很正常的事情， **这里只是公供你们参考，但愿去其糟粕，取其精华

1八、如今hadoop什么水平了，基本的框架 都会用的程度 吗？ ** 是的，我如今基本框架都会用，都搭集群环境，包括调用的api也都很熟悉

1九、hadoop方向不错我如今15k，考虑要不要转 **我以为这个要看你如今的行业之后的发展，若是有瓶颈，我以为能够考虑转

20、英文杂样，能看懂官方文档吗？ **看文档的问题不大，写和说还不行，我正在作计划，看怎么学

2一、你对本身在it行业啥想法呢，会一直在大数据这方面吗？ **目前 个人想法是之后准备作数据挖掘，机器学习工程师

2二、python要掌握到什么程度？ **在互联网方面，python,shell都是少不了的工具，我以为咱们主要精通一门，python的话，能看懂，能修改别人代码就行。如今的话，我仍是比较推崇python，比shell强大，比java简洁。

**2三、3周是本身单独学，仍是工做以外学？ ** 学习的过程，我通常都是晚上学，很痴迷，也多是由于想赶忙转，脱离当前公司的苦海，哈哈

2四、人家说集群什么的都没有搭建，这样的工做你当时没犹豫就接了吗，这么有自信？ **当时我也很担忧，不过进去的时候，也有说，让我别压力太大，若是有问题，他们会想办法找人帮我解决，因此我就豁出去

2五、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中。把两个关联的类型转换成相同类型。

5. RDMS数据库三范式

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读写数据的过程

读：

一、跟namenode通讯查询元数据，找到文件块所在的datanode服务器

二、挑选一台datanode（就近原则，而后随机）服务器，请求创建socket流

三、datanode开始发送数据（从磁盘里面读取数据放入流，以packet为单位来作校验）

四、客户端以packet为单位接收，如今本地缓存，而后写入目标文件

写：

一、根namenode通讯请求上传文件，namenode检查目标文件是否已存在，父目录是否存在

二、namenode返回是否能够上传

三、client请求第一个 block该传输到哪些datanode服务器上

四、namenode返回3个datanode服务器ABC

五、client请求3台dn中的一台A上传数据（本质上是一个RPC调用，创建pipeline），A收到请求会继续调用B，而后B调用C，将真个pipeline创建完成，逐级返回客户端

六、client开始往A上传第一个block（先从磁盘读取数据放到一个本地内存缓存），以packet为单位，A收到一个packet就会传给B，B传给C；A每传一个packet会放入一个应答队列等待应答

七、当一个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)25六、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算法，仍是在这篇文章里头有所阐述，详情请参见：11、从头至尾完全解析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内会具体阐述这些方法。

  1、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原理和使用方法、使用其架构图讲解

  

  七11、如何为一个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了

七十9、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是帮助恢复，而不是替代，如何恢复，能够查看.

101. Cloudera CDH是须要付费使用的。(错误) 分析：第一套付费产品是Cloudera Enterpris，Cloudera Enterprise在美国加州举行的Hadoop大会(Hadoop Summit)上公开，以若干私有管理、监控、运做工具增强Hadoop的功能。收费采起合约订购方式，价格随用的Hadoop叢集大小变更。

102. Hadoop是Java开发的，因此MapReduce只支持Java语言编写。(错误) 分析：rhadoop是用R语言开发的，MapReduce是一个框架，能够理解是一种思想，能够使用其余语言开发。

103. Hadoop支持数据的随机读写。(错) 分析：lucene是支持随机读写的，而hdfs只支持随机读。可是HBase能够来补救。HBase提供随机读写，来解决Hadoop不能处理的问题。HBase自底层设计开始即聚焦于各类可伸缩性问题：表能够很“高”，有数十亿个数据行;也能够很“宽”，有数百万个列;水平分区并在上千个普通商用机节点上自动复制。表的模式是物理存储的直接反映，使系统有可能提升高效的数据结构的序列化、存储和检索。

104. NameNode负责管理metadata，client端每次读写请求，它都会从磁盘中读取或则会写入metadata信息并反馈client端。(错误) 此题分析： NameNode不须要从磁盘读取metadata，全部数据都在内存中，硬盘上的只是序列化的结果，只有每次namenode启动的时候才会读取。 1)文件写入 Client向NameNode发起文件写入的请求。 NameNode根据文件大小和文件块配置状况，返回给Client它所管理部分DataNode的信息。 Client将文件划分为多个Block，根据DataNode的地址信息，按顺序写入到每个DataNode块中。 2)文件读取 Client向NameNode发起文件读取的请求。

105. NameNode本地磁盘保存了Block的位置信息。(我的认为正确，欢迎提出其它意见) 分析：DataNode是文件存储的基本单元，它将Block存储在本地文件系统中，保存了Block的Meta-data，同时周期性地将全部存在的Block信息发送给NameNode。NameNode返回文件存储的DataNode的信息。 Client读取文件信息。

106. DataNode经过长链接与NameNode保持通讯。( ) 这个有分歧：具体正在找这方面的有利资料。下面提供资料可参考。 首先明确一下概念： (1).长链接 Client方与Server方先创建通信链接，链接创建后不断开，而后再进行报文发送和接收。这种方式下因为通信链接一直存在，此种方式经常使用于点对点通信。 (2).短链接 Client方与Server每进行一次报文收发交易时才进行通信链接，交易完毕后当即断开链接。此种方式经常使用于一点对多点通信，好比多个Client链接一个Server.

107. Hadoop自身具备严格的权限管理和安全措施保障集群正常运行。(错误) 分析：hadoop只能阻止好人犯错，可是不能阻止坏人干坏事

108. Slave节点要存储数据，因此它的磁盘越大越好。(错误) 分析：一旦Slave节点宕机，数据恢复是一个难题

109. hadoop dfsadmin –report命令用于检测HDFS损坏块。(错误)

110. Hadoop默认调度器策略为FIFO(正确)

111.集群内每一个节点都应该配RAID，这样避免单磁盘损坏，影响整个节点运行。(错误) 分析：首先明白什么是RAID，能够参考百科磁盘阵列。这句话错误的地方在于太绝对，具体状况具体分析。题目不是重点，知识才是最重要的。由于hadoop自己就具备冗余能力，因此若是不是很严格不须要都配备RAID。具体参考第二题。

112.由于HDFS有多个副本，因此NameNode是不存在单点问题的。(错误)

113.每一个map槽就是一个线程。(错误) 分析：首先咱们知道什么是map槽,map槽->map slotmap slot只是一个逻辑值( org.apache.hadoop.mapred.TaskTracker.TaskLauncher.numFreeSlots )，而不是对应着一个线程或者进程

114. Mapreduce的input split就是一个block。(错误)

115. NameNode的Web UI端口是50030，它经过jetty启动的Web服务。(错误)

116. Hadoop环境变量中的HADOOP_HEAPSIZE用于设置全部Hadoop守护线程的内存。它默认是200 GB。(错误) 分析：hadoop为各个守护进程(namenode,secondarynamenode,jobtracker,datanode,tasktracker)统一分配的内存在hadoop-env.sh中设置，参数为HADOOP_HEAPSIZE，默认为1000M。

117. DataNode首次加入cluster的时候，若是log中报告不兼容文件版本，那须要NameNode执行“Hadoop amenode -format”操做格式化磁盘。(错误) 分析： 首先明白介绍，什么ClusterID ClusterID。添加了一个新的标识符ClusterID用于标识集群中全部的节点。当格式化一个Namenode，须要提供这个标识符或者自动生成。这个ID能够被用来格式化加入集群的其余Namenode。

收集了这些但愿对你们有所帮助，你们可关注个人微信zhanglindashuju有更多精彩内容和大数据免费视频观看哦！