MapReduce相关

1.MapReduce擅长处理大数据，它为什么具有这种能力

这可由MapReduce的设计思想发觉。MapReduce的思想就是“分而治之”。
1）Mapper负责“分”，即把复杂的任务分解为若干个“简单的任务”来处理。“简单的任务”包含三层含义：
一是数据或计算的规模相对原任务要大大缩小；二是就近计算原则，即任务会分配到存放着所需数据的节点上进行计算；三是这些小任务可以并行计算，彼此间几乎没有依赖关系。
2）Reducer负责对map阶段的结果进行汇总。至于需要多少个Reducer，用户可以根据具体问题，通过在mapred-site.xml配置文件里设置参数mapred.reduce.tasks的值，缺省值为1。

2.MapTask工作机制

（1）Read阶段：Map Task通过用户编写的RecordReader，从输入InputSplit中解析出一个个key/value。
（2）Map阶段：该节点主要是将解析出的key/value交给用户编写map()函数处理，并产生一系列新的key/value。
（3）Collect收集阶段：在用户编写map()函数中，当数据处理完成后，一般会调用OutputCollector.collect()输出结果。在该函数内部，它会将生成的key/value分区（调用Partitioner），并写入一个环形内存缓冲区中。
（4）Spill阶段：即“溢写”，当环形缓冲区满后，MapReduce会将数据写到本地磁盘上，生成一个临时文件。需要注意的是，将数据写入本地磁盘之前，先要对数据进行一次本地排序，并在必要时对数据进行合并、压缩等操作。
溢写阶段详情：
步骤1：利用快速排序算法对缓存区内的数据进行排序，排序方式是，先按照分区编号partition进行排序，然后按照key进行排序。这样，经过排序后，数据以分区为单位聚集在一起，且同一分区内所有数据按照key有序。
步骤2：按照分区编号由小到大依次将每个分区中的数据写入任务工作目录下的临时文件output/spillN.out（N表示当前溢写次数）中。如果用户设置了Combiner，则写入文件之前，对每个分区中的数据进行一次聚集操作目的是让尽可能少的数据写入到磁盘。
步骤3：将分区数据的元信息写到内存索引数据结构SpillRecord中，其中每个分区的元信息包括在临时文件中的偏移量、压缩前数据大小和压缩后数据大小。如果当前内存索引大小超过1MB，则将内存索引写到文件output/spillN.out.index中。
（5）Combine阶段：当所有数据处理完成后，MapTask对所有临时文件进行一次合并，以确保最终只会生成一个数据文件。
当所有数据处理完后，MapTask会将所有临时文件合并成一个大文件，并保存到文件output/file.out中，同时生成相应的索引文件output/file.out.index。
在进行文件合并过程中，MapTask以分区为单位进行合并。对于某个分区，它将采用多轮递归合并的方式。每轮合并io.sort.factor（默认100）个文件，并将产生的文件重新加入待合并列表中，对文件排序后，重复以上过程，直到最终得到一个大文件。
让每个MapTask最终只生成一个数据文件，可避免同时打开大量文件和同时读取大量小文件产生的随机读取带来的开销。

3.ReduceTask工作机制

（1）Copy阶段：ReduceTask从各个MapTask上远程拷贝一片数据，并针对某一片数据，如果其大小超过一定阈值，则写到磁盘上，否则直接放到内存中。
（2）Merge阶段：在远程拷贝数据的同时，ReduceTask启动了两个后台线程对内存和磁盘上的文件进行合并，以防止内存使用过多或磁盘上文件过多。
（3）Sort阶段：按照MapReduce语义，用户编写reduce()函数输入数据是按key进行聚集的一组数据。为了将key相同的数据聚在一起，Hadoop采用了基于排序的策略。由于各个MapTask已经实现对自己的处理结果进行了局部排序，因此，ReduceTask只需对所有数据进行一次归并排序即可。
（4）Reduce阶段：reduce()函数将计算结果写到HDFS上。

4.MapReduce工作原理

首先是 Mapreduce经过SplitInput 输入分片 决定map的个数在用Record记录 key value。
讲述一下mapreduce的流程（shuffle的sort，partitions，group）
宏观上分为以下三个阶段：
阶段一：input/map/partition/sort/spill

1. 将key/value/Partition写入到内存缓冲区中
2. 当缓冲区使用量达到一定阀值，将其spill到disk上，spill前，需要进行排序
3. 排序时先按照Partition进行排序，再按照key进行排序，默认排序算法是快速排序。
   注意： 在内存中进行排序时，数据本身不用移动，仅对索引排序即可

阶段二：mapper端的merge(归并排序)
注：有merge就伴随着排序

1.对生成的多个spill文件，进行归并排序
2.最终归并成一个大文件
注意：

1. 由于每一个spill文件都是按分区和key排序好的，所以归并完的文件也是按分区和key排序好的。
2. 在进行归并的时候，不是一次性的把所有的spill文件归并成一个大文件。而是部分spill文件归并成中间文件，然后中间文件和剩下的spill文件再进行归并。

阶段三：reducer端的merge/reduce/output

1. 当有新的MapTask事件完成时，拷贝线程从指定的机器上面拷贝数据
2. 当数据拷贝的时候，分两种情况，当数据量小的时候就会写入内存当中，当数据量大的时候就会写入硬盘当中
3. 来自不同的机器的多个数据文件，需要归并(归并排序)成一个文件.在拷贝文件过程中会进行文件归并操作.

如何决定一个job的map和reduce的数量?

1）map数量
splitSize=max{minSize,min{maxSize,blockSize}}
一个job的map阶段MapTask并行度（个数），由客户端提交job时的切片个数决定。默认切片大小=blocksize
2）reduce数量
reduce的数量job.setNumReduceTasks(x);x 为reduce的数量。不设置的话默认为 1。

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

FileInputFormat源码解析(input.getSplits(job))
（1）找到你数据存储的目录。
（2）开始遍历处理（规划切片）目录下的每一个文件
（3）遍历第一个文件ss.txt

• a）获取文件大小fs.sizeOf(ss.txt);
• b）计算切片大小
  computeSliteSize(Math.max(minSize,Math.min(maxSize,blocksize)))=blocksize=128M
• c）默认情况下，切片大小=blocksize
• d）开始切，形成第1个切片：ss.txt—0:128M 第2个切片ss.txt—128:256M
  第3个切片ss.txt—256M:300M（每次切片时，都要判断切完剩下的部分是否大于块的1.1倍，不大于1.1倍就划分一块切片）
• e）将切片信息写到一个切片规划文件中
• f）整个切片的核心过程在**getSplit()**方法中完成。
• g）数据切片只是在逻辑上对输入数据进行分片，并不会再磁盘上将其切分成分片进行存储。InputSplit只记录了分片的元数据信息，比如起始位置、长度以及所在的节点列表等。
• h）注意：block是HDFS上物理上存储的存储的数据，切片是对数据逻辑上的划分。

（4）提交切片规划文件到yarn上，yarn上的MrAppMaster就可以根据切片规划文件计算开启maptask个数。

FileInputFormat切片机制
job提交流程源码详解

waitForCompletion()
submit();
// 1建立连接
	connect();	
		// 1）创建提交job的代理
		new Cluster(getConfiguration());
			// （1）判断是本地yarn还是远程
			initialize(jobTrackAddr, conf); 
	// 2 提交job
submitter.submitJobInternal(Job.this, cluster)
	// 1）创建给集群提交数据的Stag路径
	Path jobStagingArea = JobSubmissionFiles.getStagingDir(cluster, conf);
	// 2）获取jobid ，并创建job路径
	JobID jobId = submitClient.getNewJobID();
	// 3）拷贝jar包到集群
copyAndConfigureFiles(job, submitJobDir);	
	rUploader.uploadFiles(job, jobSubmitDir);
// 4）计算切片，生成切片规划文件
writeSplits(job, submitJobDir);
	maps = writeNewSplits(job, jobSubmitDir);
		input.getSplits(job);
// 5）向Stag路径写xml配置文件
writeConf(conf, submitJobFile);
	conf.writeXml(out);
// 6）提交job,返回提交状态
status = submitClient.submitJob(jobId, submitJobDir.toString(), job.getCredentials());

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

1）相同点：
TextInputformat和KeyValueTextInputFormat都继承了FileInputFormat类，都是每一行作为一个记录；
2）区别：
TextInputformat将每一行在文件中的起始偏移量作为 key，每一行的内容作为value。默认以\n或回车键作为一行记录。
KeyValueTextInputFormat 适合处理输入数据的每一行是两列，并用 tab 分离的形式。

public static class MyMapper extends  
		Mapper<Text, Text, Text, LongWritable> {  
	final Text k2 = new Text();  
	final LongWritable v2 = new LongWritable();  

	protected void map(Text key, Text value,  
			Mapper<Text, Text, Text, LongWritable>.Context context)  
			throws InterruptedException, IOException {  
	//  final String line = value.toString();  
	//  final String[] splited = line.split("o");  
	//  for (String word : splited) {  
	//      k2.set(word);  
			k2.set(key);  
			v2.set(1);  
			context.write(k2, v2);  
	//  }  
	}  
}

6.自定义InputFormat流程

（1）自定义一个类继承FileInputFormat
（2）改写RecordReader，实现一次读取一个完整文件封装为KV

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

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

8.请描述mapReduce有几种排序及排序发生的阶段

1）排序的分类：

• （1）部分排序： MapReduce根据输入记录的键对数据集排序。保证输出的每个文件内部排序。
• （2）全排序：
  如何用Hadoop产生一个全局排序的文件？最简单的方法是使用一个分区。但该方法在处理大型文件时效率极低，因为一台机器必须处理所有输出文件，从而完全丧失了MapReduce所提供的并行架构。
  替代方案：首先创建一系列排好序的文件；其次，串联这些文件；最后，生成一个全局排序的文件。主要思路是使用一个分区来描述输出的全局排序。例如：可以为待分析文件创建3个分区，在第一分区中，记录的单词首字母a-g，第二分区记录单词首字母h-n,
  第三分区记录单词首字母o-z。
• （3）辅助排序：（GroupingComparator分组）
  Mapreduce框架在记录到达reducer之前按键对记录排序，但键所对应的值并没有被排序。甚至在不同的执行轮次中，这些值的排序也不固定，因为它们来自不同的map任务且这些map任务在不同轮次中完成时间各不相同。一般来说，大多数MapReduce程序会避免让reduce函数依赖于值的排序。但是，有时也需要通过特定的方法对键进行排序和分组等以实现对值的排序。
• （4）二次排序： 在自定义排序过程中，如果compareTo中的判断条件为两个即为二次排序。

2）自定义排序WritableComparable
bean对象实现WritableComparable接口重写compareTo方法，就可以实现排序

@Override
public int compareTo(FlowBean o) {
	// 倒序排列，从大到小
	return this.sumFlow > o.getSumFlow() ? -1 : 1;
}

3）排序发生的阶段：
（1）一个是在map side发生在spill前partition后。
（2）Mapper端的merge
（3）一个是在reduce side发生在copy后 reduce前，即reducer端的merge。

6.请描述mapReduce中combiner的作用是什么，一般使用情景，哪些情况不需要，及和reduce的区别？

1）Combiner的意义就是对每一个maptask的输出进行局部汇总，以减小网络传输量。
2）Combiner能够应用的前提是不能影响最终的业务逻辑，而且，Combiner的输出kv应该跟reducer的输入kv类型要对应起来。
3）Combiner和reducer的区别在于运行的位置。
Combiner是在每一个maptask所在的节点运行；
Reducer是接收全局所有Mapper的输出结果。

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

如果没有自定义的 partitioning，则默认的 partition 算法，即根据每一条数据的 key
的 hashcode 值摸运算（%）reduce 的数量，得到的数字就是“分区号“。
(也是通过该方法确定map的结果由哪一个reduce去做)

谈谈Hadoop序列化和反序列化及自定义bean对象实现序列化?

1）序列化和反序列化
序列化就是把内存中的对象，转换成字节序列（或其他数据传输协议）以便于存储（持久化）和网络传输。
反序列化就是将收到字节序列（或其他数据传输协议）或者是硬盘的持久化数据，转换成内存中的对象。
Java的序列化是一个重量级序列化框架（Serializable），一个对象被序列化后，会附带很多额外的信息（各种校验信息，header，继承体系等），不便于在网络中高效传输。所以，hadoop自己开发了一套序列化机制（Writable），精简、高效。

2）自定义bean对象要想序列化传输步骤及注意事项：。
（1）必须实现Writable接口
（2）反序列化时，需要反射调用空参构造函数，所以必须有空参构造
（3）重写序列化方法
（4）重写反序列化方法
（5）注意反序列化的顺序和序列化的顺序完全一致
（6）要想把结果显示在文件中，需要重写toString()，且用”\t”分开，方便后续用
（7）如果需要将自定义的bean放在key中传输，则还需要实现comparable接口，因为mapreduce框中的shuffle过程一定会对key进行排序

MapReduce 出现单点负载多大，怎么负载平衡？

可以用 Partitioner

MapReduce 怎么实现 TopN？

可以自定义groupingcomparator，对结果进行最大值排序，然后再reduce输出时，控制只输出前n个数。就达到了topn输出的目的。

GroupingComparator分组（辅助排序）
对Reduce阶段的数据根据某一个或几个字段进行分组。
分组排序步骤：
（1）自定义类继承WritableComparator
（2）重写compare()方法

@Override 
public int compare(WritableComparable a, WritableComparable b) {
      // 比较的业务逻辑
      return result;
}

（3）创建一个构造将比较对象的类传给父类

protected OrderGroupingComparator() {
      super(OrderBean.class, true);
}

Hadoop的缓存机制（Distributedcache）

分布式缓存一个最重要的应用就是在进行join操作的时候，如果一个表很大，另一个表很小，我们就可以将这个小表进行广播处理，即每个计算节点上都存一份，然后进行map端的连接操作，经过我的实验验证，这种情况下处理效率大大高于一般的reduce端join，广播处理就运用到了分布式缓存的技术。

DistributedCache（分布式缓存）将拷贝缓存的文件到Slave节点在任何Job在节点上执行之前，文件在每个Job中只会被拷贝一次，缓存的归档文件会被在Slave节点中解压缩。将本地文件复制到HDFS中去，接着Client会通过addCacheFile() 和addCacheArchive()方法告诉DistributedCache在HDFS中的位置。当文件存放到文地时，JobClient同样获得DistributedCache来创建符号链接，其形式为文件的URI加fragment标识。当用户需要获得缓存中所有有效文件的列表时，JobConf 的方法 getLocalCacheFiles() 和getLocalArchives()都返回一个指向本地文件路径对象数组。

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

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

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

1）可以输出到多个目录中，采用自定义OutputFormat。
2）实现步骤：
（1）自定义outputformat，
（2）改写recordwriter，具体改写输出数据的方法write()

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

1）数据量很小。
2）繁杂的小文件。
3）索引是更好的存取机制的时候。
4）事务处理。
5）只有一台机器的时候。

ETL是哪三个单词的缩写
Extraction-Transformation-Loading的缩写，中文名称为数据提取、转换和加载。

MapReduce实操

给你一个1G的数据文件。分别有id,name,mark,source四个字段，按照mark分组，id排序，手写一个MapReduce?其中有几个Mapper?
1）MapReduce实现
（1）在map端对id进行排序
（2）在reduce端对mark进行分组（自定义分组排序，然后main方法中设置reduce端的分组job.setGroupingComparatorClass(OrderGroupingComparator.class);）
2）几个mapper
（1）1024m/128m=8块

mapreduce 跑的慢的原因

Mapreduce 程序效率的瓶颈在于两点：
1）计算机性能
CPU、内存、磁盘健康、网络
2）I/O 操作
（1）数据倾斜
（2）map和reduce数设置不合理
（3）reduce等待过久
（4）小文件过多
（5）大量的不可分块的超大文件
（6）spill次数过多
（7）merge次数过多等。

mapreduce 优化方法

1）数据输入：

• （1）合并小文件：在执行mr任务前将小文件进行合并，大量的小文件会产生大量的map任务，增大map任务装载次数，而任务的装载比较耗时，从而导致mr 运行较慢。
• （2）采用ConbinFileInputFormat来作为输入，解决输入端大量小文件场景。

2）map阶段：

• （1）减少spill次数：通过调整io.sort.mb及sort.spill.percent参数值，增大触发spill的内存上限，减少spill次数，从而减少磁盘
  IO。
• （2）减少merge次数：通过调整io.sort.factor参数，增大merge的文件数目，减少merge的次数，从而缩短mr处理时间。
• （3）在 map 之后先进行combine处理，减少 I/O。

3）reduce阶段：

• （1）合理设置map和reduce数：两个都不能设置太少，也不能设置太多。太少，会导致task等待，延长处理时间；太多，会导致map、reduce任务间竞争资源，造成处理超时等错误。
• （2）设置map、reduce共存：调整slowstart.completedmaps参数，使map运行到一定程度后，reduce也开始运行，减少reduce的等待时间。
• （3）规避使用reduce side join，因为Reduce在用于连接数据集的时候将会产生大量的网络消耗。
• （4）合理设置reduc端的buffer，默认情况下，数据达到一个阈值的时候，buffer中的数据就会写入磁盘，然后reduce会从磁盘中获得所有的数据。也就是说，buffer和reduce是没有直接关联的，中间多个一个写磁盘->读磁盘的过程，既然有这个弊端，那么就可以通过参数来配置，使得buffer中的一部分数据可以直接输送到reduce，从而减少IO开销：mapred.job.reduce.input.buffer.percent，默认为0.0。当值大于0的时候，会保留指定比例的内存读buffer中的数据直接拿给reduce使用。这样一来，设置buffer需要内存，读取数据需要内存，reduce计算也要内存，所以要根据作业的运行情况进行调整。

4）IO传输：

• （1）采用数据压缩的方式，减少网络IO的的时间。安装Snappy和LZOP压缩编码器。
• （2）使用SequenceFile二进制文件

5）数据倾斜问题：
（1）数据倾斜现象
数据频率倾斜——某一个区域的数据量要远远大于其他区域。
数据大小倾斜——部分记录的大小远远大于平均值。
（2）如何收集倾斜数据
在reduce方法中加入记录map输出键的详细情况的功能。

public static final String MAX_VALUES = "skew.maxvalues"; 
private int maxValueThreshold; 
 
@Override
public void configure(JobConf job) { 
     maxValueThreshold = job.getInt(MAX_VALUES, 100); 
} 
@Override
public void reduce(Text key, Iterator<Text> values,
                     OutputCollector<Text, Text> output, 
                     Reporter reporter) throws IOException {
     int i = 0;
     while (values.hasNext()) {
         values.next();
         i++;
     }

     if (++i > maxValueThreshold) {
         log.info("Received " + i + " values for key " + key);
     }
}

（3）减少数据倾斜的方法

• 方法1：抽样和范围分区
  可以通过对原始数据进行抽样得到的结果集来预设分区边界值。
• 方法2：自定义分区
  另一个抽样和范围分区的替代方案是基于输出键的背景知识进行自定义分区。例如，如果map输出键的单词来源于一本书。其中大部分必然是省略词（stopword）。那么就可以将自定义分区将这部分省略词发送给固定的一部分reduce实例。而将其他的都发送给剩余的reduce实例。
• 方法3：Combine
  使用Combine可以大量地减小数据频率倾斜和数据大小倾斜。在可能的情况下，combine的目的就是聚合并精简数据。
• 方法4：参数调优
  （1）资源相关参数
  （a）以下参数是在用户自己的mr应用程序中配置就可以生效（mapred-default.xml）
  
  （b）应该在yarn启动之前就配置在服务器的配置文件中才能生效（yarn-default.xml）
  
  （c）shuffle性能优化的关键参数，应在yarn启动之前就配置好（mapred-default.xml）
  
  （2）容错相关参数(mapreduce性能优化)