————————————————————————————————————————————————————
面试题
第一套
1.hadoop运行原理
包括HDFS和Mapreduce两部分。
1）HDFS自动保存多个副本，移动计算。缺点是小文件存取占用namenode内存，写入只支持追加，不能随机修改。
它存储的逻辑空间称为block，文件的权限类似linux。整体架构分三种节点，NN,SNN,DN
NN 负责读写操作保存metadata(Ownership Permission blockinfo)
SNN 负责辅助NN合并fsimage和edits，减少nn启动时间
DN 负责存数据，每个数据（文件）分割成若干block，每个block默认3个副本。启动后像NN发送心跳保持联系
NN保存的metadata在hdfs启动后加载到计算机内存，除block位置信息的metadata保存在OS文件系统中的fsimage文件中，对metadata的操作日志保存在OS文件系统中的edits文件中。block位置信息是hdfs启动后由DN上报NN再加载到内存的。
HDFS的安全模式：直到NN完全加载完metadata之前的这段时间。期间不能写入文件，DN检查各个block完整性，并修复。
2）MapReduce
离线计算框架，过程分为split map shuffle reduce四个过程
架构节点有：Jobtracker TaskTracker
Split将文件分割，传输到mapper，mapper接收KV形式的数据，经过处理，再传到shuffle过程。
Shuffle先进行HashPartition或者自定义的partition，会有数据倾斜和reduce的负载均衡问题；再进行排序，默认按字典排序；为减少mapper输出数据，再根据key进行合并，相同key的数据value会被合并；最后分组形成（key,value{}）形式的数据，输出到下一阶段
Reduce输入的数据就变成了，key+迭代器形式的数据，再进行处理
2.MapReduce原理
逻辑上：
1、split
2、map
3、shuffle
4、reduce
四个过程
物理上：
JobTracker节点：JobTracker创建每一个Task（即MapTask和ReduceTask）
并将它们分发到各个TaskTracker服务中去执行。负责调度Job的每一个子任务task运行于TaskTracker上。
TaskTracker节点：运行在多个节点上的slaver服务。TaskTracker主动与JobTracker通信，接收作业，并负责直接执行每一个任务。TaskTracker都需要运行在HDFS的DataNode上
3.hdfs存储机制
1） client端发送写文件请求，namenode检查文件是否存在，如果已存在，直接返回错误信息，否则，发送给client一些可用namenode节点
2） client将文件分块，并行存储到不同节点上datanode上，发送完成后，client同时发送信息给namenode和datanode
3） namenode收到的client信息后，发送确信信息给datanode
4） datanode同时收到namenode和datanode的确认信息后，提交写操作。
4.用MapReduce找出存在公共好友的两个人
数据样本:
A:B,C
B:A,E
C:A,D
D:C
E:B
import java.io.IOException;
import java.util.ArrayList;
//import java.util.Collection;
//import java.util.Map.Entry;
//import java.util.HashMap;
import java.lang.Iterable;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
//import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.util.ToolRunner;
import org.apache.hadoop.util.Tool;
import org.apache.commons.lang.StringUtils;
public class FindUsers extends Configured implements Tool {
static class Map extends Mapper<LongWritable, Text, Text, Text> {
public void map(LongWritable key, Text val, Context context) throws IOException, InterruptedException {
String line = val.toString();
String user = line.split(":")[0];
String[] friends = line.split(":")[1].split(",");
String joined_friends = StringUtils.join(friends, ",");
for(String friend : friends) {
int result = friend.compareTo(user);
if(result > 0) {
context.write(new Text(user + "," + friend), new Text(joined_friends));
}
else if(result < 0) {
context.write(new Text(friend + "," + user), new Text(joined_friends));
}
}
}
}
static class Reduce extends Reducer<Text, Text, Text, Text> {
public void reduce(Text key, Iterable<Text> vals, Context context) throws IOException, InterruptedException {
String string_key = key.toString();
String[] users = string_key.split(",");
ArrayList<String> list = new ArrayList<String>();
int i = 0;
String state = "Off";
for(Text val : vals) {
i++;
String[] all_people = val.toString().split(",");
ArrayList<String> inner_list = new ArrayList<String>();
if(state.equals("Off")) {
for(String one_people: all_people) {
list.add(one_people);
state = "On";
continue;
}
}
if( state.equals("On")) {
for(String one_people: all_people) {
inner_list.add(one_people);
}
}
list.retainAll(inner_list);
}
if( ! users[0].equals(users[1])) {
for(String user : users) {
if(list.contains(user)) list.remove(user);
}
if(list.size() >= 1 && i >=2) {
context.write(new Text(StringUtils.join(users, ",")), new Text(StringUtils.join(list,",")));
}
}
}
}
@Override
public int run(String[] args) throws Exception {
Job job = Job.getInstance(getConf());
job.setJarByClass(getClass());
job.setMapperClass(Map.class);
job.setReducerClass(Reduce.class);
//job.setNumReduceTasks(0);
job.setMapOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
job.setInputFormatClass(TextInputFormat.class);
job.setOutputFormatClass(TextOutputFormat.class);
FileInputFormat.addInputPath(job, new Path(args[0]));
FileOutputFormat.setOutputPath(job, new Path(args[1]));
return job.waitForCompletion(true) ? 0 : 1;
}
public static void main(String[] args) throws Exception {
ToolRunner.run(new FindUsers(), args);
}
}
5.用mr设计一个分组排重计数算法
输入文件格式:二级域名,一级频道,二级频道,访问ip地址,访问者id
需求:按照二级域名,一级频道,二级频道分组,计算pageview数,计算独立ip数和独立访问者id数
6.hadoop中combiner的作用
当map生成的数据过大时，带宽就成了瓶颈，怎样精简压缩传给Reduce的数据，有不影响最终的结果呢。有一种方法就是使用Combiner，Combiner号称本地的Reduce，Reduce最终的输入，是Combiner的输出
第二套
1. 单例
5种写法，1、懒汉2、恶汉3、静态内部类4、枚举5、双重校验锁
1、
class LazySingleton{
private static LazySingleton singleton;
private LazySingleton(){
}
public static LazySingleton getInstance(){
if(singleton==null){
singleton=new LazySingleton();
}
return singleton;
}
}
2、
class HungrySingleton{
private static HungrySingleton singleton=new HungrySingleton();
private HungrySingleton(){}
public static HungrySingleton getInstance(){
return singleton;
}
}
3、
class InternalSingleton{
private static class SingletonHolder{
private final static InternalSingleton INSTANCE=new InternalSingleton();
}
private InternalSingleton(){}
public static InternalSingleton getInstance(){
return SingletonHolder.INSTANCE;
}
}
4、
enum EnumSingleton{
INSTANCE;
public void doSomeThing(){
}
}
5、
class LockSingleton{
private volatile static LockSingleton singleton;
private LockSingleton(){}
//详见：http://www.ibm.com/developerworks/cn/java/j-dcl.html
public static LockSingleton getInstance(){
if(singleton==null){
synchronized(LockSingleton.class){
if(singleton==null){
singleton=new LockSingleton();
}
}
}
return singleton;
}
}
2. Linkedlist和ArrayList的区别
ArrayList是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢。LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
3.http安全问题
1)重要信息:MD5,AES加密
2)不太重要的数据:用签名
3)登录态:
4.sparkStreaming和storm的区别
5.gc
自动监测对象是否超过作用域从而达到自动回收内存的机制，Java语言没有提供
释放已分配内存的显式操作方法。
第三套•乐视
1.design a singleton class in multi-threading environment.
2.How to find middle element of linkedlist in one pass.
3.Reverse singly linked list in java recursively.
4.Write a java program to implement Stack in java.
Public class MyStack{
Private ArrayList data = new ArrayList();
Public Boolean pop(){}
Public Boolean push(){}
}
1. scala 隐函数关键字
implicit
2. val x=y=1结果
1)x、y都是var，x变为Unit
2)都是val，报错
3.java内存模型
堆内存、栈内存、方法区
栈内存：保存局部变量
堆内存：存储数组和对象
方法区：代码区、字符串常量池、静态区
3. spark运行的job在哪里可以看到
4. HADOOP的一个job提交到resourcemanager之后，会生成什么容器来放这个job
第四套•优酷
1. java内存模型
2.gc
3.编译好的scala程序，运行时还需要scala环境吗
Scala的代码执行是用REPL过程，Read Execute Print Loop
4.object中有哪些方法
5.监测集群中的cpu，内存使用情况？
6、ArrayList中的Array长度超了是怎么增加的，一次增加多少？
第五套
linux的启动顺序
通电后读取ROM的BIOS程序进行硬件自检，自检成功后把计算机控制权交给BIOS中BOOTsequence中的下一个有效设备，读取该设备MBR找到操作系统，载入linux的bootloader，一般是grub。之后载入kernel，执行 /etc/rc.d/sysinit ，开启其他组件（/etc/modules.conf），执行运行级别，执行/etc/rc.d/rc.local ，执行/bin/login，最后shell启动。
使用过的开源框架介绍
Struts2
Spring
hibernate
mybatis
hadoop
hive
hbase
flume
sqoop
Zookeeper
Mahout
Kafka
Storm
Spark
擅长哪种技术
Hadoop。介绍
HIVE的优化
底层是MapReduce，所以又可以说是MapReduce优化。
1. 小文件都合并成大文件
2. Reducer数量在代码中介于节点数*reduceTask的最大数量的0.95倍到1.75倍
3. 写一个UDF函数，在建表的时候制定好分区
4. 配置文件中，打开在map端的合并
开发中遇到的问题
Hbase节点运行很慢，发现是Hfile过小，hbase频繁split。
修改了hfile大小。或者设置major compack设置为手动
Major compack设置为手动会出现什么问题
？
Zookeeper的二次开发
Flume 的实时和定时数据采集，项目和flume的解耦
Mogodb和hbase的区别
Mogodb是单机
Hbase是分布式？？
项目组多少人？人员分配？数据量？集群的配置？
第六套•优化相关
Hbase优化
1） 表设计
建表时就分区，rowkey设置定长（64字节），CF2到3个
Max Versio，Time to live，Compact&Split
2） 写表
多Htable并发写
Htable参数设置，手动flush，降低IO
WriteBuffer
批量写
多线程并发写
3） 读表
多Htable并发读
Htable参数设置
批量读
释放资源
缓存查询结果
MapReduce优化
1. 任务调度
I/O 方面：Hadoop 会尽量将 Map 任务分配给 InputSplit 所在的机器，以减少网
络 I/O 的消耗。
2.数据预处理与 InputSplit 的大小
合理地设置 block块大小是很重要的调节方式。除此之外，也可以通过合理地
设置 Map 任务的数量来调节 Map 任务的数据输入。
3. Map 和 Reduce 任务的数量
当 Reduce 任务的数量是任务槽的 1.75 倍时，执行速度快的机器可以获得更多
的 Reduce 任务，因此可以使负载更加均衡，以提高任务的处理速度。
4. Combine 函数
MapReduce 框架运行用户写的 combine 函数用于本地合并，这会大大减少网
络 I/O 操作的消耗
Oracle优化
1、建立视图
2、优化 sql 语句
3、分表、分库
4、存储过程
Spark优化
第七套•scala
scala 语言有什么特点，什么是函数式编程？有什么优点
2.scala 伴生对象有什么作用
3.scala 并发编程是怎么弄得，你对 actor 模型怎么理解有何优点
4.scala case class 有什么重要
5.scala akka 框架有没有接触过，有什么重要
6.scala 为什么设计 var 和 val
第八套•spark
SDD,DAG,Stage怎么理解？
宽依赖 窄依赖怎么理解？
Stage是基于什么原理分割task的？
血统的概念
任务的概念
容错方法
粗粒度和细粒度
Spark优越性
Spark为什么快
Transformation和action是什么？区别？举几个常用方法
SDD怎么理解
spark 作业提交流程是怎么样的，client和 cluster 有什么区别，各有什么作用
spark on yarn 作业执行流程，yarn-client 和 yarn cluster 有什么区别
spark streamning 工作流程是怎么样的，和 storm 比有什么区别
spark sql 你使用过没有，在哪个项目里面使用的
spark 机器学习和 spark 图计算接触过没，，能举例说明你用它做过什么吗？
spark sdd 是怎么容错的，基本原理是什么？
第九套•java
1．关于 string 的选择题
2．修饰符
3．两个整数相除，保存到百分位
4．写个封装，抽象，继承，多态的类集。
5．jsp 的作用域的描述。
6．如何得到 jsp 的参数。
7．写几个 SQL 语句。
第十套•美团(3-7)
1. 说说 hbase 的 API 都有哪些 filter?
2. 说说你用过的 storm?
3. 自己熟悉大数据的部分说一下？
4. hadoop 与 storm、spark 的比较？
5. 对一个字符串进行全排列？
6. 事务都有哪些特点？
7. hadoop 集群中的某个 block 不能 copy 数据到其他节点，怎么办？如果并发量大
了， 有多个 block不能 copy 数据，怎么办？
8. flum 是如何导入数据到 kafka?具体
9. 请使用 awk, sed 命令对文本文件中第二列和第三列取出来(58同城)
其他整理
1、 用户文件 2 个属性 10 万行，课程文件 2 个属性 2 万行，日志文件 1 个属性很
大，这些属性可以任意的组合查询，每秒的请求数是 10000 个，请如何最快的方式查
询出数据？
2、给你 2 个字符串，字符串最后一个字符可以循环到最前面，只要一个字符串中每
一个字符在另一个字符串都有就是相等的，请用你的方法比较是否相等？
3、任意使用MR或者Storm或者hive根据日志表，求20150501当天每个用户访问页面次数的前10的页面，日志表如下：
Userid pageid viste date
Aa 222 20150501
Aa 333 20150501
Aa 222 20150501
Aa 222 20150502
Bb 333 20150501
Cc 333 20150502
4、Hbase的major compact和minor compact的区别
5、A表有三个字段，id,name,age，id为主键，去除该表中name重复的数据，用mysql语法实现（千万级别查询量、考虑Sql语法的复杂性）
6、算法：TB级别数据排序
1）单机实现 2）分布式实现
7、static synchronized final volatile
8、concurrentHashMap的数据结构和应用场景
9、多线程的3种实现，说明他们的优缺点
10、JVM的内存模型，GC在何时何地，做了什么事情
11、用java实现LRU缓存
12、实现单例，要求：线程安全、锁的性能
13、目录拷贝功能：目录下上万文件需要拷贝备份，拷贝同时输出进度
14、jps命令作用
15、a和b两个文件各存放80亿URL，每个URL64字节，内存限制为4G，如何找出共同的URL
16、start-hbase.sh为起点hbase的启动流程
17、hbase的compact