【MapReduce】MR执行过程中的关键源码学习总结

注意:

• 通过WordCount程序为例进行调试
• 是在本地模式进行的，所以N个MapTask 和 N个 ReduceTask没有并行的效果。
• 如果在集群上，N个 MapTask 和 N 个ReduceTask 是并行运行.

一、 Job提交的流程

方法层级：1 > 1) > (1) > <1> > ① > [1] > {1}

1. job.waitForCompletion(true); //在Driver中提交job
	1)sumbit() //提交
		(1)connect():
			<1>return new Cluster(getConfiguration());
				/*
				通过YarnClientProtocolProvider或LocalClientProtocolProvider  
				根据配置文件的参数信息获取当前job需要执行到本地还是Yarn
				最终:LocalClientProtocolProvider  ==> LocalJobRunner
			     */
				① initialize(jobTrackAddr, conf);  
		//提交job
		(2) return submitter.submitJobInternal(Job.this, cluster); 
		    // 检查job的输出路径。
		 	<1> .checkSpecs(job);
			<2> . Path jobStagingArea = JobSubmissionFiles.getStagingDir(cluster, conf); 
			//生成Job提交的临时目录：
			//D:\tmp\hadoop\mapred\staging\Administrator1777320722\.staging
			<3> . JobID jobId = submitClient.getNewJobID();  //为当前Job生成Id
			<4> . Path submitJobDir = new Path(jobStagingArea, jobId.toString()); 
			 //Job的提交路径d:/tmp/hadoop/mapred/staging/Administrator1777320722/.staging/job_local1777320722_0001
			<5> . copyAndConfigureFiles(job, submitJobDir);
				① rUploader.uploadResources(job, jobSubmitDir);
					[1] uploadResourcesInternal(job, submitJobDir);  
						{1}.submitJobDir = jtFs.makeQualified(submitJobDir); 
					    	//创建Job的提交路径
							mkdirs(jtFs, submitJobDir, mapredSysPerms);
			//生成切片信息 ，并返回切片的个数
			<6> . int maps = writeSplits(job, submitJobDir); 
			//通过切片的个数设置MapTask的个数
			<7> . conf.setInt(MRJobConfig.NUM_MAPS, maps); 
			//将当前Job相关的配置信息写到job提交路径下 
			<8> . writeConf(conf, submitJobFile);  
			//此时通过查看发现路径下有:  job.split  job.splitmetainfo  job.xml    xxx.jar
			//此时才真正提交Job
			<9> .status = submitClient.submitJob(jobId, submitJobDir.toString(), job.getCredentials());
			//等job执行完成后，删除Job的临时工作目录的内容
			<10> .  jtFs.delete(submitJobDir, true);

二、 MapTask的工作机制

1. 从Job提交流程代码解析里面的的(2)--><9> 进去 
    //构造真正执行的Job , LocalJobRunnber$Job
	Job job = new Job(JobID.downgrade(jobid), jobSubmitDir);  
2. LocalJobRunnber$Job 的run()方法
	1)TaskSplitMetaInfo[] taskSplitMetaInfos = SplitMetaInfoReader.readSplitMetaInfo(jobId, localFs, conf, systemJobDir);// 读取job.splitmetainfo
	2)int numReduceTasks = job.getNumReduceTasks();  // 获取ReduceTask个数
	3) // 根据切片的个数， 创建执行MapTask的 MapTaskRunnable
		List<RunnableWithThrowable> mapRunnables = getMapTaskRunnables(taskSplitMetaInfos, jobId, mapOutputFiles); 
	4)ExecutorService mapService = createMapExecutor();  // 创建线程池
	5)	runTasks(mapRunnables, mapService, "map");   //执行 MapTaskRunnable
	6)   因为Runnable提交给线程池执行，接下来会执行MapTaskRunnable的run方法。
	7)   执行 LocalJobRunner$Job$MapTaskRunnable 的run()方法.
		(1)  MapTask map = new MapTask(systemJobFile.toString(), mapId, taskId,info.getSplitIndex(), 1);   //创建MapTask对象
		(2)   map.run(localConf, Job.this);  //执行MapTask中的run方法
			<1> .runNewMapper(job, splitMetaInfo, umbilical, reporter); 
				①  org.apache.hadoop.mapreduce.TaskAttemptContext taskContext =  JobContextImpl
				②  org.apache.hadoop.mapreduce.Mapper<INKEY,INVALUE,OUTKEY,OUTVALUE> mapper =  WordConutMapper
				③  org.apache.hadoop.mapreduce.InputFormat<INKEY,INVALUE> inputFormat = TextInputFormat
				④  split = getSplitDetails(new Path(splitIndex.getSplitLocation()),
					splitIndex.getStartOffset();  
					 //重构切片对象
					 //切片对象的信息 : file:/D:/input/inputWord/JaneEyre.txt:0+36306679
				⑤org.apache.hadoop.mapreduce.RecordReader<INKEY,INVALUE> input = MapTask$NetTrackingRecordReader
				⑥output = new NewOutputCollector(taskContext, job, umbilical, reporter);  //构造缓冲区对象
					[1] collector = createSortingCollector(job, reporter);  //获取缓冲区对象
					MapTask$MapOutputBuffer
					{1} . collector.init(context);  //初始化缓冲区对象
						1>>.final float spillper = job.getFloat(JobContext.MAP_SORT_SPILL_PERCENT, (float)0.8);// 默认溢写百分比  0.8
						2>>.final int sortmb = job.getInt(MRJobConfig.IO_SORT_MB,MRJobConfig.DEFAULT_IO_SORT_MB);    // 默认缓冲区大小  100M
						3>>.sorter = ReflectionUtils.newInstance(job.getClass(MRJobConfig.MAP_SORT_CLASS, QuickSort.class,IndexedSorter.class), job);
						// 排序对象。排序使用的是快排，并且只是基于索引排序。
						4>> . // k/v serialization   // kv序列化
						5>> . // output counters     // 计数器
						6>> . // compression         //  压缩
						7>> . // combiner            //  combiner
				⑦  mapper.run(mapperContext);// 执行WordCountMapper中的run方法。 实际执行的是WordCountMapper继承的Mapper中的run方法。
					[1] . 在Mapper中的run方法中 ： map(context.getCurrentKey(), context.getCurrentValue(), context);//执行到WordCountMapper中的map方法。
					[2] . 在WordCountMapper中的map方法中将kv写出 : context.write(outK,outV);

三、 Shuffle流程(溢写，归并)

1. map中的kv持续往 缓冲区写， 会达到溢写条件，发生溢写，最后发生归并。
2. map中的 context.write(k,v) 
	1) . mapContext.write(key, value); 
		(1).  output.write(key, value);
			<1> collector.collect(key, value,partitioner.getPartition(key, value, partitions));   
			// 将map写出的kv 计算好分区后，收集到缓冲区中。
			<2> . 当满足溢写条件后 ，开始发生溢写
			startSpill();
				① spillReady.signal(); //线程间通信，通知溢写线程开始溢写
				② 溢写线程调用 sortAndSpill() 方法发生溢写操作
				③ 	final SpillRecord spillRec = new SpillRecord(partitions);
					final Path filename = mapOutputFile.getSpillFileForWrite(numSpills, size);
					out = rfs.create(filename)
					//根据分区的个数，创建溢写文件：
				    /tmp/hadoop-Administrator/mapred/local/localRunner/Administrator/jobcache/job_local277309786_0001/attempt_local277309786_0001_m_000000_0/output/spill0.out	
				④ sorter.sort(MapOutputBuffer.this, mstart, mend, reporter); // 溢写前先排序
				⑤ writer.close(); 通过writer进行溢写，溢写完成后，关闭流，可以查看磁盘中的溢写文件
				⑥ if (totalIndexCacheMemory >= indexCacheMemoryLimit)  
				// create spill index file
				Path indexFilename =mapOutputFile.getSpillIndexFileForWrite(numSpills, partitions
				// 判断索引使用的内存空间是否超过限制的大小，如果超过也需要溢写到磁盘
				⑦  map持续往缓冲区写，达到溢写条件，就继续溢写 ........ 可能整个过程中发生N次溢写。
				⑧  MapTask中的runNewMapper 中 output.close(mapperContext); 
				假如上一次溢写完后，剩余进入的到缓冲区的数据没有达到溢写条件，那么当map中的所有的数据
				都已经处理完后，在关闭output时，会把缓冲区中的数据刷到磁盘中(其实就是没有达到溢写条件的数据也要写到磁盘)
					[1] collector.flush();  //刷写
						{1} . sortAndSpill(); 通过溢写的方法进行剩余数据的刷写
						{2} . 最后一次刷写完后，磁盘中会有N个溢写文件 
						spill0.out  spill1.out .... spillN.out
						{3} . 归并 mergeParts();
							>>1.  for(int i = 0; i < numSpills; i++) {
										filename[i] = mapOutputFile.getSpillFile(i);
										finalOutFileSize += rfs.getFileStatus(filename[i]).getLen();
									}
									//根据溢写的次数，得到要归并多少个溢写文件
							>>2.  Path finalOutputFile = mapOutputFile.getOutputFileForWrite(finalOutFileSize);
							/tmp/hadoopAdministrator/mapred/local/localRunner/Administrator/jobcache/job_local1987086776_0001/attempt_local1987086776_0001_m_000000_0/output/file.out
							Path finalIndexFile = mapOutputFile.getOutputIndexFileForWrite(finalIndexFileSize); 
							/tmp/hadoop-Administrator/mapred/local/localRunner/Administrator/jobcache/job_local1987086776_0001/attempt_local1987086776_0001_m_000000_0/output/file.out.index
							//生成最终存储数据的两个文件
							>>3.  for (int parts = 0; parts < partitions; parts++) {
							// 按照分区的， 进行归并。
							>>4.  awKeyValueIterator kvIter = Merger.merge(job, rfs,
														keyClass, valClass, codec,
														segmentList, mergeFactor,
														new Path(mapId.toString()),
														job.getOutputKeyComparator(), reporter, sortSegments,
														null, spilledRecordsCounter, sortPhase.phase(),
														TaskType.MAP);
							//归并操作
							>>5 Writer<K, V> writer = new Writer<K, V>(job, finalPartitionOut, keyClass, valClass, codec,spilledRecordsCounter);
							//通过writer写归并后的数据到磁盘
							>>6 . 
							if (combinerRunner == null || numSpills < minSpillsForCombine) {
									Merger.writeFile(kvIter, writer, reporter, job);
							} else {
									combineCollector.setWriter(writer);
									combinerRunner.combine(kvIter, combineCollector);
							}
							在归并时，如果有combine，且溢写的次数大于等于minSpillsForCombine的值3才会使用Combine
							>>7. 
							for(int i = 0; i < numSpills; i++) {
									rfs.delete(filename[i],true);
							}
							归并完后，将溢写的文件删除
							>> 8.  最后在磁盘中存储map处理完后的数据，等待reduce的拷贝。
							file.out  file.out.index  

四、 ReduceTask工作机制

1.  在LocalJobRunner$Job中的run()方法中
	if (numReduceTasks > 0) {
		//根据reduceTask的个数，创建对应个数的LocalJobRunner$Job$ReduceTaskRunnable
		List<RunnableWithThrowable> reduceRunnables = getReduceTaskRunnables(
		jobId, mapOutputFiles);
		//线程池
		ExecutorService reduceService = createReduceExecutor();
		//将 ReduceTaskRunnable提交给线程池执行
		runTasks(reduceRunnables, reduceService, "reduce");
	}

	1) . 执行LocalJobRunner$Job$ReduceTaskRunnable 中的run方法
	
		(1) . ReduceTask reduce = new ReduceTask(systemJobFile.toString(),reduceId, taskId, mapIds.size(), 1); 
		//创建ReduceTask对象
		(2) . reduce.run(localConf, Job.this); // 执行ReduceTask的run方法
		
			<1> . runNewReducer(job, umbilical, reporter, rIter, comparator, 
			keyClass, valueClass);
				[1] . org.apache.hadoop.mapreduce.TaskAttemptContext taskContext = TaskAttemptContextImpl
				[2] . org.apache.hadoop.mapreduce.Reducer<INKEY,INVALUE,OUTKEY,OUTVALUE> reducer = WordCountReducer
				[3] . org.apache.hadoop.mapreduce.RecordWriter<OUTKEY,OUTVALUE> trackedRW = ReduceTask$NewTrackingRecordWriter
				[4] . reducer.run(reducerContext); 
				//执行WordCountReducer的run方法 ，实际执行的是WordCountReducer继承的Reducer类中的run方法.
			
					{1} .reduce(context.getCurrentKey(), context.getValues(), context); 
					//执行到WordCountReducer中的 reduce方法.
					{2} . context.write(k,v) 将处理完的kv写出.
					
						>>1 . reduceContext.write(key, value); 
						>>2 . output.write(key, value);
						>>3 . real.write(key,value);  // 通过RecordWriter将kv写出
						>>4 . out.write(NEWLINE);  //通过输出流将数据写到结果文件中