Mapreduce运行机制(1)
https://www.cnblogs.com/sharpxiajun/p/3151395.html
一、Mapreduce简介:
1、Mapreduce是一个计算框架,表现形式是有个输入(input),Mapreduce操作这个输入(input),通过本身定义好的计算模型,得到一个输出(output),这输出就是我们所需要的结果。
2、我们要学习的是这个计算模型的运行规则。
在运行一个Mapreduce计算任务的时候,任务分为两个阶段:map阶段和reduce阶段,每个阶段都是用键值对(key/value)作为输入(input)和输出(output)。
程序员要做的就是定义好这两个阶段的函数:map函数和reduce函数。
3、map(分)主要将复杂任务分解为若干个简单任务进行并行处理,这些任务之间没有依赖关系。reduce(合)对map阶段的结果进行全局汇总。
4、Mapreduce运行在yarn集群:
- ResourceManager:指派任务
- NodeManager:执行任务
(hadoop 2.x)
来自:https://blog.csdn.net/mrlevo520/article/details/76781186
1、ResourceManager接受client提出的处理任务,ResourceManager启动一个Applications Manager进程来管理这个任务
2、Applications Manager将任务分发给yarn集群的一个从节点Node Manager,然后启动一个程序MR APPMstr来管理这个任务
3、这个MR APPMaster程序主要向Appcations Manager申请资源,如所需内存、CPU
4、Resource Scheduler将资源下发给MR APPMaster
5、MR APPMaster拿到资源后将资源分派给各个Node Manager
6、Node Manager拿到资源后启动对应的Map Task或者Reduce Task
7、Map Task或者Reduce Task产生的结果汇总给MR APPMaster
8、MR APPMaster把结果上报给Applications Manager。
二、Mapreduce简单代码解析
package org.apache.hadoop.examples; import java.io.IOException; import java.util.StringTokenizer; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.Job; import org.apache.hadoop.mapreduce.Mapper; import org.apache.hadoop.mapreduce.Reducer; import org.apache.hadoop.mapreduce.lib.input.FileInputFormat; import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat; import org.apache.hadoop.util.GenericOptionsParser; import org.apache.hadoop.util.Tool; // Mapreduce类中需要继承Configured类以及实现Tool接口,Tool接口需要实现其run方法。 public class WordCount extends Configured implements Tool { public int run(String[] args) throws Exception{ //创建一个任务对象 //不能这样写,new Configuration()是重新新建一个配置对象,但是同一个任务中应该使用同一个Configuration() //Job.getInstance(conf:new Configuration(),JobName:“wordcount”) // 继承父类Configured的main函数里的conf对象可以通过super.getConf()函数获得。 Job job = Job.getInstance(super.getConf(),"wordcount"); //构建一个job,在mapreduce框架里一个Mapreduce任务叫作业也叫job,具体的map和reduce运算是task,构建一个job,构建时有两个参数,一个是conf,一个是job名称。 //第一步:设置读取文件的类:K1和V1 job.setInputFormatClass(TextInputFormat.class); TextInputFormat.addInputPath(job,new Path("输入的数据所在路经otherArgs[0]"); //第二步:设置Mapper类 job.setJarByClass(WordCount.class); // 装载程序员编写的计算程序,如程序类名为WordCount。虽然我们编写mapreduce程序只需要实现map函数和reduce函数,但是实际开发我们要实现三个类,第三个类是为了配置mapreduce如何运行map和reduce函数,准确的说就是构建一个mapreduce能执行的job了,例如WordCount类。 job.setMapperClass(TokenizerMapper.class); //【3】第三行和第五行就是装载map函数和reduce函数实现类了,这里多了个第四行,这个是装载Combiner类,这个我后面讲mapreduce运行机制时候会讲述,其实本例去掉第四行也没有关系,但是使用了第四行理论上运行效率会更好。 //设置Map阶段的输出类型:K2和V2的类型 job.setMapOutputKeyClass(Text.class); job.setMapOutputValueClass(Text.class); job.setCombinerClass(IntSumReducer.class); //【4】 //第三步:设置Reducer类 job.setReducerClass(IntSumReducer.class); //【5】 //这个是定义Reducer输出的key/value的类型,也就是最终存储在hdfs上结果文件的key/value的类型。 job.setOutputKeyClass(Text.class); job.setOutputValueClass(IntWritable.class); //第四步:构建输出类 job.setOutputFormatClass(TextOutputFormat.class); //第五步:构建输出的数据文件,最后一行如果job运行成功了,我们的程序就会正常退出。TextInputFormat和TextOutputFormat是很有学问的 TextOutputFormat.setOutputPath(job, new Path("输出路经otherArgs[1]“)); System.exit(job.waitForCompletion(true) ? 0 : 1); } //main函数的调用 public static void main(String[] args) throws Exception { //运行Mapreduce程序之前需要初始化Configuration,这个类是读取Mapreduce系统配置信息, //这些信息包括HDFS还有Mapreduce,即安装Hadoop时的配置文件:core-site.xml,hdfs-site.xml和mapred-site.xml等等文件里的信息。 // 这样做的原因是:开发Mapreduce时仅仅在map函数和reduce函数里编写实际的业务逻辑,其他工作都是交给Mapreduce框架操作的,这需要我们告诉它怎么操作,如hdfs在哪,Mapreduce的jobstracker在哪,这些信息就在conf包下的配置文件里。 Configuration conf = new Configuration(); //启动一个任务,run函数中的第一个参数是配置对象conf,第二个参数可以是该执行类对象,第三个参数是参数args。 //返回值为0或1,0表示执行成功,非0为失败。 int run = ToolRunner.run(conf,new WordCount(), args) System.exit(run); } //修改Mapper类,集成Mapper基类 /* ## Mapper基类的变量泛型 ## 这里的K1为Object类型 ## 这里的V1为String, Mapreduce对应的为Text类型。 ## K2为Text类型 ## V2为IntWritable类型,在java中为Int,但是Mapreduce自己定义了一种泛型,效率会更高,即IntWritable。 */ public static class TokenizerMapper extends Mapper<Object, Text, Text, IntWritable>{ private final static IntWritable one = new IntWritable(1); //context.write(word,one)方法里的word和one需要是IntWritable和Text类型,所以要先new一个对象。 private Text word = new Text(); // 前面IntWritable key, Text value就是输入的key和value, //Context context这是可以记录输入的key和value,例如:context.write(word, one);此外context还会记录map运算的状态。 public void map(Object key, Text value, Context context ) throws IOException, InterruptedException { StringTokenizer itr = new StringTokenizer(value.toString()); while (itr.hasMoreTokens()) { word.set(itr.nextToken()); //将值赋给word对象 context.write(word, one); } } } // 修改Reducer类,继承Reducer类 //reduce的输入key-value为<K2,V2>, <K2,V2>为<hello,(1,1,1)>形式,即文本中hello出现3次。 //reduce的输出key-value为<K3,V3> public static class IntSumReducer extends Reducer<Text,IntWritable,Text,IntWritable> { private IntWritable result = new IntWritable(); // 对于reduce函数的输入也是一个key/value形式,不过它的value是一个迭代器的形式,即reduce的输入是一个key对应一个集合value,reduce的context和map的context作用一致。 public void reduce(Text key, Iterable<IntWritable> values, Context context ) throws IOException, InterruptedException { int sum = 0; for (IntWritable val : values) { sum += val.get(); } result.set(sum); context.write(key, result); } } }
三、Mapreduce运行机制
1、从实体角度来看:
(1)设计的实体:
首先讲讲物理实体,参入mapreduce作业执行涉及4个独立的实体:
- 客户端(client):编写mapreduce程序,配置作业,提交作业,这就是程序员完成的工作;
- JobTracker:初始化作业,分配作业,与TaskTracker通信,协调整个作业的执行;
- TaskTracker:TaskTracker是JobTracker和Task之间的桥梁。TaskTracker与JobTracker和Task之间采用了RPC协议进行通信。保持与JobTracker的通信,在分配的数据片段上执行Map或Reduce任务,TaskTracker和JobTracker的不同有个很重要的方面,就是在执行任务时候TaskTracker可以有n多个,JobTracker则只会有一个(JobTracker只能有一个就和hdfs里namenode一样存在单点故障,我会在后面的mapreduce的相关问题里讲到这个问题的)
- Hdfs:保存作业的数据、配置信息等等,最后的结果也是保存在hdfs上面
(2)运行过程:
配置job:首先是客户端要编写好mapreduce程序,配置好mapreduce的作业也就是job,
提交job:接下来就是提交job了,提交job是提交到JobTracker上的,这个时候JobTracker就会构建这个job,具体就是分配一个新的job任务的ID值,接下来它会做检查操作,这个检查就是确定输出目录是否存在,如果存在那么job就不能正常运行下去,JobTracker会抛出错误给客户端,接下来还要检查输入目录是否存在,如果不存在同样抛出错误,如果存在JobTracker会根据输入计算输入分片(Input Split),如果分片计算不出来也会抛出错误,至于输入分片我后面会做讲解的,这些都做好了JobTracker就会配置Job需要的资源了。
初始化job:分配好资源后,JobTracker就会初始化作业,初始化主要做的是将Job放入一个内部的队列,让配置好的作业调度器能调度到这个作业,作业调度器会初始化这个job,初始化就是创建一个正在运行的job对象(封装任务和记录信息),以便JobTracker跟踪job的状态和进程
任务分配:初始化完毕后,作业调度器会获取输入分片信息(input split),每个分片创建一个map任务。接下来就是任务分配了,这个时候tasktracker会运行一个简单的循环机制定期发送心跳给jobtracker,心跳间隔是5秒,程序员可以配置这个时间,心跳就是jobtracker和tasktracker沟通的桥梁,通过心跳,jobtracker可以监控tasktracker是否存活,也可以获取tasktracker处理的状态和问题,同时tasktracker也可以通过心跳里的返回值获取jobtracker给它的操作指令。
执行任务:任务分配好后就是执行任务了。在任务执行时候jobtracker可以通过心跳机制监控tasktracker的状态和进度,同时也能计算出整个job的状态和进度,而tasktracker也可以本地监控自己的状态和进度。当jobtracker获得了最后一个完成指定任务的tasktracker操作成功的通知时候,jobtracker会把整个job状态置为成功,然后当客户端查询job运行状态时候(注意:这个是异步操作),客户端会查到job完成的通知的。如果job中途失败,mapreduce也会有相应机制处理,一般而言如果不是程序员程序本身有bug,mapreduce错误处理机制都能保证提交的job能正常完成。
(hadoop 1.x)
摘自:https://blog.csdn.net/mrlevo520/article/details/76781186
1、在客户端启动一个作业。拿个比方说,我提交了一个hive程序
客户端(Client):编写mapreduce程序,配置作业,提交作业,这就是程序员完成的工作;
2、向JobTracker请求一个Job ID,就像你排队买车一样,你不得摇个号啊,没有这个号你就不能买车(执行任务)。
- JobTracker:JobTracker是一个后台服务进程,启动之后,会一直监听并接收来自各个TaskTracker发送的心跳信息,包括资源使用情况和任务运行情况等信息。
- 作业控制:在hadoop中每个应用程序被表示成一个作业,每个作业又被分成多个任务,JobTracker的作业控制模块则负责作业的分解和状态监控。
- 状态监控:主要包括TaskTracker状态监控、作业状态监控和任务状态监控。主要作用:容错和为任务调度提供决策依据。
- JobTracker只有一个,他负责了任务的信息采集整理,你就把它当做包工头把,这个和采用Master/Slave结构中的Master保持一致
- JobTracker 对应于 NameNode
- 一般情况应该把JobTracker部署在单独的机器上
3、将运行作业所需要的资源文件复制到HDFS上,包括MapReduce程序打包的JAR文件、配置文件和客户端计算所得的输入划分信息。这些文件都存放在JobTracker专门为该作业创建的文件夹中。文件夹名为该作业的Job ID。JAR文件默认会有10个副本(mapred.submit.replication属性控制);输入划分信息(Split)告诉了JobTracker应该为这个作业启动多少个map任务等信息。
- HDFS:保存作业的数据、配置信息等等,最后的结果也是保存在hdfs上面
- NameNode: 管理文件目录结构,接受用户的操作请求,管理数据节点(DataNode)
- DataNode:是HDFS中真正存储数据的
- Block:是hdfs读写数据的基本单位,默认64MB大小,就是说如果你有130MB数据,那就要分成三个block,两个存放64MB,最后一个存放2MB数据,虽然最后一个block块是64MB,但实际上占用空间为2MB
- Sencondary NameNode:它的目的是帮助 NameNode 合并编辑日志,减少 NameNode 启动时间,在文件系统中设置一个检查点来帮助NameNode更好的工作。它不是要取代掉NameNode也不是NameNode的备份。可参考[Secondary NameNode:它究竟有什么作用?
4、JobTracker接收到作业后,将其放在一个作业队列里(一般来说,公司部门都与自己的队列,默认的调度方法是FIFO,也就是first in first out-队列),等待作业调度器对其进行调度,当作业调度器根据自己的调度算法调度到该作业时,会根据输入划分信息(Split)为每个划分创建一个map任务,并将map任务分配给TaskTracker执行。对于map和reduce任务,TaskTracker根据主机核的数量和内存的大小有固定数量的map槽和reduce槽。这里需要强调的是:map任务不是随随便便地分配给某个TaskTracker的,这里有个概念叫:数据本地化(Data-Local)。意思是:将map任务分配给含有该map处理的数据块的TaskTracker上,同时将程序JAR包复制到该TaskTracker上来运行,这叫“运算移动,数据不移动”。而分配reduce任务时并不考虑数据本地化。
- TaskTracker:TaskTracker是JobTracker和Task之间的桥梁。TaskTracker与JobTracker和Task之间采用了RPC协议进行通信。
- 从JobTracker接收并执行各种命令:运行任务、提交任务、杀死任务等
- 将本地节点上各个任务的状态通过心跳周期性汇报给JobTracker,节点健康情况、资源使用情况,任务执行进度、任务运行状态等,比如说map task我做完啦,你什么时候让reduce task过来拉数据啊
- TaskTracker是运行在多个节点上的slaver服务。TaskTracker主动与JobTracker通信,接收作业,并负责直接执行每一个任务。
- TaskTracker都需要运行在HDFS的DataNode上
5、TaskTracker每隔一段时间会给JobTracker发送一个心跳,告诉JobTracker它依然在运行,同时心跳中还携带着很多的信息,比如当前map任务完成的进度等信息。当JobTracker收到作业的最后一个任务完成信息时,便把该作业设置成“成功”。当JobClient查询状态时,它将得知任务已完成,便显示一条消息给用户。
2、从逻辑实体来看Mapreduce的运行机制:
这些按照时间顺序包括:输入(input )、分片(split)、map阶段、combiner阶段、shuffle阶段和reduce阶段。
1、输入(input):数据存储位置,类似于hdfs的分布式存储
2、切片(split):因为map task只读split,split基本上和hdfs的基本存储块block同样大小。split是逻辑分片,一个split默认对应一个map(可理解成map的单位块,进入map的时候须是这样的格式),如只收硬币的地铁站,只能投1元硬币,投5毛不行。是map task只读的单位,存储的并非数据本身,而是一个分片长度和一个记录数据的位置的数组
在进行map计算之前,mapreduce会根据输入文件计算输入分片(input split),每个输入分片(input split)针对一个map任务,输入分片(input split)存储的并非数据本身,而是一个分片长度和一个记录数据的位置的数组,输入分片(input split)往往和hdfs的block(块)关系很密切,假如我们设定hdfs的块的大小是64mb,如果我们输入有三个文件,大小分别是3mb、65mb和127mb,那么mapreduce会把3mb文件分为一个输入分片(input split),65mb则是两个输入分片(input split)而127mb也是两个输入分片(input split),换句话说我们如果在map计算前做输入分片调整,例如合并小文件,那么就会有5个map任务将执行,而且每个map执行的数据大小不均,这个也是mapreduce优化计算的一个关键点。
3、map阶段:就是程序员编写好的map函数了,因此map函数效率相对好控制,而且一般map操作都是本地化操作也就是在数据存储节点上进行;
4、combiner阶段:combiner阶段是程序员可以选择的,combiner其实也是一种reduce操作,因此我们看见WordCount类里是用reduce进行加载的。
Combiner是一个本地化的reduce操作,它是map运算的后续操作,主要是在map计算出中间文件前做一个简单的合并重复key值的操作,
例如我们对文件里的单词频率做统计,map计算时候如果碰到一个hadoop的单词就会记录为1,但是这篇文章里hadoop可能会出现n多次,那么map输出文件冗余就会很多,因此在reduce计算前对相同的key做一个合并操作,那么文件会变小,这样就提高了宽带的传输效率,毕竟hadoop计算力宽带资源往往是计算的瓶颈也是最为宝贵的资源,但是combiner操作是有风险的,使用它的原则是combiner的输入不会影响到reduce计算的最终输入,
例如:如果计算只是求总数,最大值,最小值可以使用combiner,但是做平均值计算使用combiner的话,最终的reduce计算结果就会出错。
5、shuffle阶段:将map的输出作为reduce的输入的过程就是shuffle了,这个是mapreduce优化的重点地方。这里我不讲怎么优化shuffle阶段,讲讲shuffle阶段的原理,因为大部分的书籍里都没讲清楚shuffle阶段。
shuffle阶段解决什么问题?
在Hadoop这样的集群环境中,大部分map task与reduce task的执行是在不同的节点上。当然很多情况下Reduce执行时需要跨节点去拉取其它节点上的map task结果。如果集群正在运行的job有很多,那么task的正常执行对集群内部的网络资源消耗会很严重。这种网络消耗是正常的,我们不能限制,能做的就是最大化地减少不必要的消耗。还有在节点内,相比于内存,磁盘IO对job完成时间的影响也是可观的。从最基本的要求来说,我们对Shuffle过程的期望可以有:
-
- 完整地从map task端拉取数据到reduce 端。
- 在跨节点拉取数据时,尽可能地减少对带宽的不必要消耗。
- 减少磁盘IO对task执行的影响。
Shuffle一开始就是map阶段做输出操作,一般mapreduce计算的都是海量数据,map输出时候不可能把所有文件都放到内存操作,因此map写入磁盘的过程十分的复杂,更何况map输出时候要对结果进行排序,内存开销是很大的,
map在做输出时候会在内存里开启一个环形内存缓冲区,这个缓冲区专门用来输出的,默认大小是100mb,并且在配置文件里为这个缓冲区设定了一个阀值,默认是0.80(这个大小和阀值都是可以在配置文件里进行配置的),
同时map还会为输出操作启动一个守护线程,如果缓冲区的内存达到了阀值的80%时候,这个守护线程就会把内容写到磁盘上,这个过程叫spill,
另外的20%内存可以继续写入要写进磁盘的数据,写入磁盘和写入内存操作是互不干扰的,
如果缓存区被撑满了,那么map就会阻塞写入内存的操作,让写入磁盘操作完成后再继续执行写入内存操作,前面我讲到写入磁盘前会有个排序操作,这个是在写入磁盘操作时候进行,不是在写入内存时候进行的,如果我们定义了combiner函数,那么排序前还会执行combiner操作。
每次spill操作也就是写入磁盘操作时候就会写一个溢出文件,也就是说在做map输出有几次spill就会产生多少个溢出文件,等map输出全部做完后,map会合并这些输出文件。
这个过程里还会有一个Partitioner操作,对于这个操作很多人都很迷糊,其实Partitioner操作和map阶段的输入分片(Input split)很像,一个Partitioner对应一个reduce作业,如果我们mapreduce操作只有一个reduce操作,那么Partitioner就只有一个,如果我们有多个reduce操作,那么Partitioner对应的就会有多个,Partitioner因此就是reduce的输入分片,这个程序员可以编程控制,主要是根据实际key和value的值,根据实际业务类型或者为了更好的reduce负载均衡要求进行,这是提高reduce效率的一个关键所在。
到了reduce阶段就是合并map输出文件了,Partitioner会找到对应的map输出文件,然后进行复制操作,复制操作时reduce会开启几个复制线程,这些线程默认个数是5个,程序员也可以在配置文件更改复制线程的个数,这个复制过程和map写入磁盘过程类似,也有阀值和内存大小,阀值一样可以在配置文件里配置,而内存大小是直接使用reduce的tasktracker的内存大小,复制时候reduce还会进行排序操作和合并文件操作,这些操作完了就会进行reduce计算了。
6、reduce阶段:和map函数一样也是程序员编写的,最终结果是存储在hdfs上的。
Mapreduce相关问题:
- jobtracker的单点故障:jobtracker和hdfs的namenode一样也存在单点故障,单点故障一直是hadoop被人诟病的大问题,为什么hadoop的做的文件系统和mapreduce计算框架都是高容错的,但是最重要的管理节点的故障机制却如此不好,我认为主要是namenode和jobtracker在实际运行中都是在内存操作,而做到内存的容错就比较复杂了,只有当内存数据被持久化后容错才好做,namenode和jobtracker都可以备份自己持久化的文件,但是这个持久化都会有延迟,因此真的出故障,任然不能整体恢复,另外hadoop框架里包含zookeeper框架,zookeeper可以结合jobtracker,用几台机器同时部署jobtracker,保证一台出故障,有一台马上能补充上,不过这种方式也没法恢复正在跑的mapreduce任务。
- 做mapreduce计算时候,输出一般是一个文件夹,而且该文件夹是不能存在,我在出面试题时候提到了这个问题,而且这个检查做的很早,当我们提交job时候就会进行,mapreduce之所以这么设计是保证数据可靠性,如果输出目录存在reduce就搞不清楚你到底是要追加还是覆盖,不管是追加和覆盖操作都会有可能导致最终结果出问题,mapreduce是做海量数据计算,一个生产计算的成本很高,例如一个job完全执行完可能要几个小时,因此一切影响错误的情况mapreduce是零容忍的。
- Mapreduce还有一个InputFormat和OutputFormat,我们在编写map函数时候发现map方法的参数是之间操作行数据,没有牵涉到InputFormat,这些事情在我们new Path时候mapreduce计算框架帮我们做好了,而OutputFormat也是reduce帮我们做好了,我们使用什么样的输入文件,就要调用什么样的InputFormat,InputFormat是和我们输入的文件类型相关的,mapreduce里常用的InputFormat有FileInputFormat普通文本文件,SequenceFileInputFormat是指hadoop的序列化文件,另外还有KeyValueTextInputFormat。OutputFormat就是我们想最终存储到hdfs系统上的文件格式了,这个根据你需要定义了,hadoop有支持很多文件格式,这里不一一列举,想知道百度下就看到了。
三、编程规范
Map阶段2个步骤
1、设置InputFormat类,(InputFormat类是用来读取源文件的数据),获取数据后将数据切分为Key-Value对(K1-V1),输入第二步,[这里的K1常为行偏移量]
2、自定义Map逻辑,将第一步的结果转换成另外的Key-Value对(K2-V2),输出结果。
Shuffle阶段4个步骤
3、对输出的Key-Value对(K2-V2)进行分区,[数据量过大需对其进行分类]
4、对不同分区的数据按照相同的Key排序
5、(可选)对分组过的数据初步归约,降低数据的网络拷贝
6、对数据进行分组,相同Key的Value放入一个集合中
Reduce阶段2个步骤
7、对多个Map任务的结果进行排序以及合并,编写Reduce函数实现自己的逻辑,对输入的Key-Value进行处理,转为新的Key-Value(K3-V3)输出
8、设置OutputFormat处理并保存Reduce输出的Key-Value数据,[OutputFormat为输出数据的设置]
来自https://blog.csdn.net/mrlevo520/article/details/76781186
四、Mapper阶段运行机制
原文链接:https://blog.csdn.net/mrlevo520/java/article/details/76781186
1、Map处理阶段
InputSplit:输入数据来源于HDFS的block,当然在MapReduce概念中,map task只读取Split,也就是是我们所说的分片。在进行map计算之前,mapreduce会根据输入文件计算输入分片(input split),每个输入分片(input split)针对一个map任务。
Block是HDFS的基本存储单元,上文也有写,Block默认大小是64MB
Split是map task只读的单位,存储的并非数据本身,而是一个分片长度和一个记录数据的位置的数组
Split与block的对应关系可能是多对一,默认是一对一
Running map task: 就是程序员编写好的map函数了,因此map函数效率相对好控制,而且一般map操作都是本地化操作也就是在数据存储节点上进行,这也就是上问所提到的 数据本地化!数据本地化(Data-Local):意思是将map任务分配给含有该map处理的数据块的TaskTracker上,同时将程序JAR包复制到该TaskTracker上来运行,这叫“运算移动,数据不移动”。而分配reduce任务时并不考虑数据本地化。
2、Map的shuffle阶段
- 分区partition:
partition是分割map每个节点的结果,按照key分别映射给不同的reduce,也是可以自定义的。这里其实可以理解归类。我们对于错综复杂的数据归类。比如在动物园里有牛羊鸡鸭鹅,他们都是混在一起的,但是到了晚上他们就各自牛回牛棚,羊回羊圈,鸡回鸡窝。partition的作用就是把这些数据归类。只不过在写程序的时候,mapreduce使用哈希HashPartitioner帮我们归类了。默认是hash(key)%R(Reduce task的数量)哈希函数分散到各个reducer去
简单的hash做分配,就比如说我map task输出键值对(1,1),(2,1),(3,1), 我有三个reducer,假设我写个hash是除3取余的值为分配到的reducer位置(其实是要将key先变hash code再除的,我这里简略),那么(1,1)被分配到第一个reduce,(2,1)被分配到第二个reduce,(3,1)被分配到第三个reduce,同理再来个(4,1)被分配到第一个reduce,HashPartitioner的目的就是合理的分组策略将使得每个Reducer获得的计算负载差距不大,从而整体reduce的性能更加均衡。
没理解HashPartitioner的胖友,可以参考下这个MapReduce 编程 系列十 使用HashPartitioner来调节Reducer的计算负载
- 环形缓冲区和溢出spill:
map task输出结果首先会进入一个缓冲区内,这个缓冲区的大小是100MB,如果map task内容太大,是很容易撑爆内存的,所以会有一个守护进程,每当缓冲区到达上限80%的时候,就会启动一个Spill(溢写)进程,它的作用是把内存里的map task的结果写入到磁盘。这里值得注意的是,溢写程序是单独的一个进程,不会影响map task的继续输出(在写磁盘过程中,另外的20%内存可以继续写入数据,两种操作互不干扰,但如果在此期间缓冲区被填满,那么map就会阻塞写入内存的操作,让写入磁盘操作完成后再执行写入内存。)。
-
排序:当溢写线程启动后,需要对这80MB空间内的key做排序(Sort)。排序是MapReduce模型默认的行为,这里的排序也是对序列化的字节做的排序。shuffle排序可以参考这里
(1)在这个缓冲区内会有二次排序,先对partition分区排序,然后对同一个partition内的数据进行排序。
(2)很多人的误解在Map阶段,如果不使用Combiner便不会排序,这是错误的,不管你用不用Combiner,Map Task均会对产生的数据排序(如果没有Reduce Task,则不会排序, 实际上Map阶段的排序就是为了减轻Reduce端排序负载)
(3)数据按照partition值和key两个关键字升序排序,移动的只是索引数据,排序结果是Kvmeta中数据按照partition为单位聚集在一起,同一partition内的按照key有序。
- 归约(combiner):
Combiner:如果client设置过Combiner,那么现在就是使用Combiner的时候了。将有相同key的key/value对的value加起来,减少溢写到磁盘的数据量,combiner简单说就是map端的reduce!。Combiner会优化MapReduce的中间结果,所以它在整个模型中会多次使用。那哪些场景才能使用Combiner呢?从这里分析,Combiner的输出是Reducer的输入,Combiner绝不能改变最终的计算结果。所以从我的想法来看,Combiner只应该用于那种Reduce的输入key/value与输出key/value类型完全一致,且不影响最终结果的场景。比如累加,最大值等。但对于均值就会有影响;Combiner的使用一定得慎重,如果用好,它对job执行效率有帮助,反之会影响reduce的最终结果。
- 合并(Merge): 每次溢写会在磁盘上生成一个溢写文件,如果map的输出结果真的很大,有多次这样的溢写发生,磁盘上相应的就会有多个溢写文件存在。当map task真正完成时,内存缓冲区中的数据也全部溢写到磁盘中形成一个溢写文件。最终磁盘中会至少有一个这样的溢写文件存在(如果map的输出结果很少,当map执行完成时,只会产生一个溢写文件),因为最终的文件只有一个,所以需要将这些溢写文件归并到一起。
Merge是怎样的?比如“aaa”从某个map task读取过来时值是5,从另外一个map 读取时值是8,因为它们有相同的key,所以得merge成group。什么是group。对于“aaa”就是像这样的:{“aaa”, [5, 8, 2, …]},数组中的值就是从不同溢写文件中读取出来的,然后再把这些值放在一起。
归约(Combine)和归并(Merge)的区别:
两个键值对<“a”,1>和<“a”,1>,如果合并,会得到<“a”,2>,如果归并,会得到<“a”,<1,1>>,每个map都会有一个环形缓冲区,merge默认对此溢写文件进行合并,而combine则需要设置,设置后,同个key的value会相加
补充一下,combine这个如果设置了,会在两个地方被触发;
(1)第一次是在溢写磁盘前,缓冲区对key进行排序后,会触发一次;
(2)第二次是在merge最终将一堆溢写文件合并成单个文件时,也会触发一次,但在这里触发的时候需在 numSpills>mapreduce.map.combine.minspills(默认3) ,combiner时才执行;如果map输出规模较少,只存在一两个溢写的文件,那么不值得调用combine带来的开销。
- 排序:在shuffle阶段中map端涉及到的排序,在spill的过程中时,会对partition和key进行排序,确保partition内的key是有序的,这里用的是优化后的快排;
然后再溢写到小文件之后,针对这些小文件,最终需要merge到一个文件,这里也会出现一次排序,这里用的基本思想就是归并排序,其实是可以理解的,因为在溢写的文件块内,已经保证局部有序了,相当于只需要将局部有序的列表进行合并,形成一个全局有序的,这个让归并来做实在合适,甚至只需要做归并的后半部分!
至此,map端的所有工作都已结束,最终生成的这个文件也存放在TaskTracker够得着的某个本地目录内。每个reduce task不断地通过RPC从JobTracker那里获取map task是否完成的信息,如果reduce task得到通知,获知某台TaskTracker上的map task执行完成,Shuffle的后半段过程开始启动。
关于这个过程更详细的请见 MapReduce shuffle过程详解
配置参数:
五、Reducer阶段的运行机制
在Reduce端,shuffle主要分为复制Map输出、排序合并两个阶段。
- Copy:
Reduce会接收到不同map任务传来的数据,并且每个map传来的数据都是有序的。Reduce进程启动一些数据copy线程(Fetcher),通过HTTP方式请求map task所在的TaskTracker获取map task的输出文件。因为map task早已结束,这些文件就归TaskTracker管理在本地磁盘中。
(1)默认情况下,当整个MapReduce作业的所有已执行完成的Map Task任务数超过Map Task总数的5%后,JobTracker便会开始调度执行Reduce Task任务。然后Reduce Task任务默认启动mapred.reduce.parallel.copies(默认为5)个MapOutputCopier线程到已完成的Map Task任务节点上分别copy一份属于自己的数据。 这些copy的数据会首先保存的内存缓冲区中,当内冲缓冲区的使用率达到一定阀值后,则写到磁盘上。
(2)有人可能会问:分区中的数据怎么知道它对应的reduce是哪个呢?其实map任务一直和其父TaskTracker保持联系,而TaskTracker又一直和JobTracker保持心跳。所以JobTracker中保存了整个集群中的宏观信息。只要reduce任务向JobTracker获取对应的map输出位置就ok了。还有就是map端已经做完了partition,reduce根据partition标识符来拉自己需要的数据
- Merge sort:这里的merge如map端的merge动作,只是数组中存放的是不同map端copy来的数值。
Copy过来的数据会先放入内存缓冲区中,merge有三种形式:1)内存到内存 2)内存到磁盘 3)磁盘到磁盘。
(1)如果内存缓冲区中能放得下这次数据的话就直接把数据写到内存中,即内存到内存merge。默认不启用。
(2)Reduce要向每个Map去拖取数据,在内存中每个Map对应一块数据,当内存缓存区中存储的Map数据占用空间达到一定程度的时候,开始启动内存中merge,把内存中的数据merge输出到磁盘上一个文件中,即内存到磁盘merge。在将buffer中多个map输出合并写入磁盘之前,如果设置了Combiner,则会化简压缩合并的map输出。Reduce的内存缓冲区可通过mapred.job.shuffle.input.buffer.percent配置,默认是JVM的heap size的70%。内存到磁盘merge的启动门限可以通过mapred.job.shuffle.merge.percent配置,默认是66%。(这种merge方式一直在运行,直到没有map端的数据时才结束)
(3)当属于该reducer的map输出全部拷贝完成,则会在reducer上生成多个文件(如果拖取的所有map数据总量都没有内存缓冲区,则数据就只存在于内存中),这时开始执行合并操作,即磁盘到磁盘merge,Map的输出数据已经是有序的,Merge进行一次合并排序,所谓Reduce端的sort过程就是这个合并的过程。一般Reduce是一边copy一边sort,即copy和sort两个阶段是重叠而不是完全分开的。最终Reduce shuffle过程会输出一个整体有序的数据块。
- Sort 阶段:按照 MapReduce 语义,用户编写 reduce()函数输入数据是按 key 进行聚集的一组数据。为了将 key 相同的数据聚在一起,Hadoop 采用了基于排序的策略。由于各个 MapTask 已经实现对自己的处理结果进行了局部排序,因此,ReduceTask 只需对所有数据进行一次归并排序即可。
Reducer的输入文件(中间文件):不断地merge后,最后会生成一个“最终文件”。为什么加引号?因为这个文件可能存在于磁盘上,也可能存在于内存中。对我们来说,当然希望它存放于内存中,直接作为Reducer的输入,但默认情况下,这个文件是存放于磁盘中的。当Reducer的输入文件已定,整个Shuffle才最终结束。
- reduce阶段:和map函数一样也是程序员编写的,最终结果是存储在hdfs上的。