MapReduce是啥？ 详解

MapReduce定义

Mapreduce是一个分布式运算程序的编程框架，是用户开发“基于hadoop的数据分析应用”的核心框架。

Mapreduce核心功能

是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个hadoop集群上。

MapReduce优缺点

优点：
MapReduce 易于编程- -它简单的实现一些接口
良好的扩展性- -简单的增加机器来扩展它的计算能力
高容错性- -一台机器挂了，它可以把上面的计算任务自动转移到另外一个节点上运行
适合PB级以上海量数据的离线处理- -它适合离线处理而不适合在线处理，延迟比较高
缺点：
不擅长做实时计算 - -延迟比较高，很难在毫秒或者秒级内返回结果
流式计算- -流式计算的输入数据是动态的，而MapReduce的输入数据集是静态的。这是因为MapReduce自身的设计特点决定了数据源必须是静态的。
DAG（有向图）计算- -多个应用程序存在依赖关系，后一个应用程序的输入为前一个的输出。在这种情况下，MapReduce并不是不能做，而是使用后，每个MapReduce作业的输出结果都会写入到磁盘，会造成大量的磁盘IO，导致性能非常的低下。

MapReduce核心思想

1）分布式的运算程序往往需要分成至少2个阶段。
2）第一个阶段的maptask并发实例，完全并行运行，互不相干。
3）第二个阶段的reduce task并发实例互不相干，但是他们的数据依赖于上一个阶段的所有maptask并发实例的输出。
4）MapReduce编程模型只能包含一个map阶段和一个reduce阶段，如果用户的业务逻辑非常复杂，那就只能多个mapreduce程序，串行运行。

MapReduce进程（MR）

一个完整的mapreduce程序在分布式运行时有三类实例进程：
1）MrAppMaster：负责整个程序的过程调度及状态协调。
2）MapTask：负责map阶段的整个数据处理流程。
3）ReduceTask：负责reduce阶段的整个数据处理流程。

MapReduce编程

用户编写的程序分成三个部分：Mapper、Reducer和Driver。
1．Mapper阶段
（1）用户自定义的Mapper要继承自己的父类
（2）Mapper的输入数据是KV对的形式（KV的类型可自定义）
（3）Mapper中的业务逻辑写在map()方法中
（4）Mapper的输出数据是KV对的形式（KV的类型可自定义）
（5）map()方法（maptask进程）对**每一个<K,V>**调用一次

public class xxxMapper extends Mapper<LongWritable, Text, Text, IntWritable>{
	@Override
	protected void map(LongWritable key, Text value, Context context)
			throws IOException, InterruptedException {
			业务逻辑...
	}
}

2．Reducer阶段
（1）用户自定义的Reducer要继承自己的父类
（2）Reducer的输入数据类型对应Mapper的输出数据类型，也是KV
（3）Reducer的业务逻辑写在reduce()方法中
（4）Reducetask进程对每一组相同k的<k,v>组调用一次reduce()方法

public class xxxReducer extends Reducer<Text, IntWritable, Text, IntWritable>{
	@Override
	protected void reduce(Text key, Iterable<IntWritable> value,
			Context context) throws IOException, InterruptedException {
			业务逻辑...
	}
}

3．Driver阶段(关联Mapper和Reducer，并且提交任务到集群)
相当于yarn集群的客户端，用于提交我们整个程序到yarn集群，提交的是封装了mapreduce程序相关运行参数的job对象

public class xxxDriver {

	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {

		// 1 获取配置信息以及封装任务
		Configuration configuration = new Configuration();
		Job job = Job.getInstance(configuration);

		// 2 设置jar加载路径
		job.setJarByClass(xxxDriver.class);

		// 3 设置map和reduce类
		job.setMapperClass(xxxMapper.class);
		job.setReducerClass(xxxReducer.class);

		// 4 设置map输出
		job.setMapOutputKeyClass(Text.class);
		job.setMapOutputValueClass(IntWritable.class);

		// 5 设置Reduce输出
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(IntWritable.class);
		
		// 6 设置输入和输出路径
		FileInputFormat.setInputPaths(job, new Path(args[0]));
		FileOutputFormat.setOutputPath(job, new Path(args[1]));

		// 7 提交
		job.waitForCompletion(true);
	}
}

jar在linux上运行

（1）将程序打成jar包，然后拷贝到hadoop集群中
（2）启动hadoop集群
（3）执行程序

[hadoop@hadoop101 ~]$ hadoop jar wc.jar xxx.jar

MapReduce框架原理

第一阶段map
1.map task读取HDFS文件。每个block，启动一个map task。
每个map task按照行读取一个block中的内容，对每一行执行map函数
2.map函数对输入的数据进行拆分split，得到一个数组，组成一个键值对
3.分1个区，对应1个reduce task
4.对每个分区中的数据，按照key进行分组并排序
5.[选做]在map段执行小reduce,输出<key,times>

第二阶段reduce
1.每个分区对应一个reduce task，这个reduce task会读取相同分区的map输出；
reduce task对接收到的所有map输出，进行排序分组
例：<hello,{1,1}><me,{1}><you,{1}>
2.执行reduce 操作,对一个分组中的value进行累加
例：<hello,2><me,1><you,1>
3.每个分区输出到一个HDFS文件中

Shuffle机制

Mapreduce确保每个reducer的输入都是按key排序的。系统执行排序的过程（即将mapper输出作为输入传给reducer）称为shuffle

Partition分区

分区：把数据扎堆存放

自定义Partitioner步骤

（1）自定义类继承Partitioner，重写getPartition()方法

public class xxxPartitioner extends Partitioner<Text, FlowBean> {

	@Override
	public int getPartition(Text key, FlowBean value, int numPartitions) {
		if(...){
			partition = 0;
		}else if{
			partition = 1;
			.
			.
			.
		}else{
		    partition = n;
		}
		return partition;
}

（2）在job驱动中，设置自定义partitioner：

job.setPartitionerClass(CustomPartitioner.class);

（3）自定义partition后，要根据自定义partitioner的逻辑设置相应数量的reduce task 在job驱动中

job.setNumReduceTasks(5);

reduceTask的个数决定了有几个文件！！
如果reduceTask的数量> getPartition的结果数，则会多产生几个空的输出文件part-r-000xx；
如果1<reduceTask的数量<getPartition的结果数，则有一部分分区数据无处安放，会Exception；
如果reduceTask的数量=1，则不管mapTask端输出多少个分区文件，最终结果都交给这一个reduceTask，最终也就只会产生一个结果文件 part-r-00000；

WritableComparable排序

Map Task和Reduce Task均会对数据（按照key）进行排序
默认排序是按照字典顺序排序。
对于Map Task，它会将处理的结果暂时放到一个缓冲区中，当缓冲区使用率达到一定阈值后，再对缓冲区中的数据进行一次排序，并将这些有序数据写到磁盘上，而当数据处理完毕后，它会对磁盘上所有文件进行一次合并，以将这些文件合并成一个大的有序文件。
对于Reduce Task，它从每个Map Task上远程拷贝相应的数据文件，如果文件大小超过一定阈值，则放到磁盘上，否则放到内存中。如果磁盘上文件数目达到一定阈值，则进行一次合并以生成一个更大文件；如果内存中文件大小或者数目超过一定阈值，则进行一次合并后将数据写到磁盘上。当所有数据拷贝完毕后，Reduce Task统一对内存和磁盘上的所有数据进行一次合并。
每个阶段的默认排序

自定义排序WritableComparable

bean对象实现WritableComparable接口重写compareTo方法，就可以实现排序

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

Combiner合并

1）combiner是MR程序中Mapper和Reducer之外的一种组件。
2）combiner组件的父类就是Reducer。
3）combiner和reducer的区别在于运行的位置：
Combiner是在每一个maptask所在的节点运行;
Reducer是接收全局所有Mapper的输出结果；
4）combiner的意义就是对每一个maptask的输出进行局部汇总，以减小网络传输量。
5）combiner能够应用的前提是不能影响最终的业务逻辑，而且，combiner的输出kv应该跟reducer的输入kv类型要对应起来。
例子：
Mapper
Maptask1:
3 5 7 ->(3+5+7)/3=5
Maptask2:
2 6 ->(2+6)/2=4
Reducer
(3+5+7+2+6)/5=23/5 不等于 (5+4)/2=9/2
这种情况下不能使用
6）自定义Combiner实现步骤：
（1）自定义一个combiner继承Reducer，重写reduce方法

public class xxxCombiner extends Reducer<Text, IntWritable, Text,
IntWritable>{
	@Override
	protected void reduce(Text key, Iterable<IntWritable> values,
			Context context) throws IOException, InterruptedException {
		for(IntWritable v :values){
			...
		}
        // 写出
		context.write(key, new IntWritable(?));
	}
}

（2）在job驱动类中设置：

job.setCombinerClass(xxxCombiner.class);

MapTask工作机制

（1）Read阶段：Map Task通过用户编写的RecordReader，从输入InputSplit中解析出一个个key/value。
（2）Map阶段：该节点主要是将解析出的key/value交给用户编写map()函数处理，并产生一系列新的key/value。
（3）Collect收集阶段：在用户编写map()函数中，当数据处理完成后，一般会调用context.write，context.write底层 OutputCollector.collect()输出结果。在该函数内部，它会将生成的key/value分区（调用Partitioner），并写入一个环形内存缓冲区中。
（4）Spill阶段：即“溢写”，当环形缓冲区满后，MapReduce会将数据写到本地磁盘上，生成一个临时文件。需要注意的是，将数据写入本地磁盘之前，先要对数据进行一次本地排序，并在必要时对数据进行合并等操作。
（5）Combine阶段：当所有数据处理完成后，MapTask对所有临时文件进行一次合并，以确保最终只会生成一个数据文件。
在进行文件合并过程中，MapTask以分区为单位进行合并。对于某个分区，它将采用多轮递归合并的方式。每轮合并io.sort.factor（默认100）个文件，并将产生的文件重新加入待合并列表中，对文件排序后，重复以上过程，直到最终得到一个大文件。

ReduceTask工作机制

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

MapReduce Join关联

Map join(合并)
使用场景
一张表十分小、一张表很大。
解决
在map端缓存多张表，提前处理业务逻辑，这样增加map端业务，减少reduce端数据的压力，尽可能的减少数据倾斜。
具体办法
（1）在mapper的setup阶段，将文件读取到缓存集合中。
（2）在驱动函数中加载缓存。
job.addCacheFile(new URI(“file:/e:/mapjoincache/pd.txt”));// 缓存普通文件到task运行节点

Reduce join（合并）
使用场景
多表
原理
Map端的主要工作：为来自不同表（文件）的key/value对打标签以区别不同来源的记录。然后用连接字段作为key，其余部分和新加的标志作为value，最后进行输出。
Reduce端的主要工作：在reduce端以连接字段作为key的分组已经完成，我们只需要在每一个分组当中将那些来源于不同文件的记录（在map阶段已经打标志）分开，最后进行合并就ok了。