Mapreduce 框架解析

MapReduce过程解析

一、客户端

Map-Reduce的过程首先是由客户端提交一个任务开始的。

public static RunningJob runJob(JobConf job) throws IOException {

//首先生成一个JobClient对象

JobClient jc = new JobClient(job);

……

//调用submitJob来提交一个任务

running = jc.submitJob(job);

JobID jobId = running.getID();

……

while (true) {

//while循环中不断得到此任务的状态，并打印到客户端console中

}

return running;

}

提交任务主要是通过JobClient.runJob(JobConf)静态函数实现的：

其中JobClient的submitJob函数实现如下：

public RunningJob submitJob(JobConf job) throws FileNotFoundException,

InvalidJobConfException, IOException {

//从JobTracker得到当前任务的id

JobID jobId = jobSubmitClient.getNewJobId();

//准备将任务运行所需要的要素写入HDFS：

//任务运行程序所在的jar封装成job.jar

//任务所要处理的input split信息写入job.split

//任务运行的配置项汇总写入job.xml

Path submitJobDir = new Path(getSystemDir(), jobId.toString());

Path submitJarFile = new Path(submitJobDir, "job.jar");

Path submitSplitFile = new Path(submitJobDir, "job.split");

//此处将-libjars命令行指定的jar上传至HDFS

configureCommandLineOptions(job, submitJobDir, submitJarFile);

Path submitJobFile = new Path(submitJobDir, "job.xml");

……

//通过input format的格式获得相应的input split，默认类型为FileSplit

InputSplit[] splits =

job.getInputFormat().getSplits(job, job.getNumMapTasks());

// 生成一个写入流，将input split得信息写入job.split文件

FSDataOutputStream out = FileSystem.create(fs,

submitSplitFile, new FsPermission(JOB_FILE_PERMISSION));

try {

//写入job.split文件的信息包括：split文件头，split文件版本号，split的个数，接着依次写入每一个input split的信息。

//对于每一个input split写入：split类型名(默认FileSplit)，split的大小，split的内容(对于FileSplit，写入文件名，此split 在文件中的起始位置)，split的location信息(即在那个DataNode上)。

writeSplitsFile(splits, out);

} finally {

out.close();

}

job.set("mapred.job.split.file", submitSplitFile.toString());

//根据split的个数设定map task的个数

job.setNumMapTasks(splits.length);

// 写入job的配置信息入job.xml文件

out = FileSystem.create(fs, submitJobFile,

new FsPermission(JOB_FILE_PERMISSION));

try {

job.writeXml(out);

} finally {

out.close();

}

//真正的调用JobTracker来提交任务

JobStatus status = jobSubmitClient.submitJob(jobId);

……

}

二、JobTracker

JobTracker作为一个单独的JVM运行，其运行的main函数主要调用有下面两部分：

调用静态函数startTracker(new JobConf())创建一个JobTracker对象

调用JobTracker.offerService()函数提供服务

在JobTracker的构造函数中，会生成一个taskScheduler成员变量，来进行Job的调度，默认为JobQueueTaskScheduler，也即按照FIFO的方式调度任务。

在offerService函数中，则调用taskScheduler.start()，在这个函数中，为JobTracker(也即taskScheduler的taskTrackerManager)注册了两个Listener：

JobQueueJobInProgressListener jobQueueJobInProgressListener用于监控job的运行状态

EagerTaskInitializationListener eagerTaskInitializationListener用于对Job进行初始化

EagerTaskInitializationListener中有一个线程JobInitThread，不断得到jobInitQueue中的JobInProgress对象，调用JobInProgress对象的initTasks函数对任务进行初始化操作。

在上一节中，客户端调用了JobTracker.submitJob函数，此函数首先生成一个JobInProgress对象，然后调用addJob函数，其中有如下的逻辑：

synchronized (jobs) {

synchronized (taskScheduler) {

jobs.put(job.getProfile().getJobID(), job);

//对JobTracker的每一个listener都调用jobAdded函数

for (JobInProgressListener listener : jobInProgressListeners) {

listener.jobAdded(job);

}

}

}

EagerTaskInitializationListener的jobAdded函数就是向jobInitQueue中添加一个JobInProgress对象，于是自然触发了此Job的初始化操作，由JobInProgress得initTasks函数完成：

public synchronized void initTasks() throws IOException {

……

//从HDFS中读取job.split文件从而生成input splits

String jobFile = profile.getJobFile();

Path sysDir = new Path(this.jobtracker.getSystemDir());

FileSystem fs = sysDir.getFileSystem(conf);

DataInputStream splitFile =

fs.open(new Path(conf.get("mapred.job.split.file")));

JobClient.RawSplit[] splits;

try {

splits = JobClient.readSplitFile(splitFile);

} finally {

splitFile.close();

}

//map task的个数就是input split的个数

numMapTasks = splits.length;

//为每个map tasks生成一个TaskInProgress来处理一个input split

maps = new TaskInProgress[numMapTasks];

for(int i=0; i < numMapTasks; ++i) {

inputLength += splits[i].getDataLength();

maps[i] = new TaskInProgress(jobId, jobFile,

splits[i],

jobtracker, conf, this, i);

}

//对于map task，将其放入nonRunningMapCache，是一个Map<Node, List<TaskInProgress>>，也即对于map task来讲，其将会被分配到其input split所在的Node上。nonRunningMapCache将在JobTracker向TaskTracker分配map task的时候使用。

if (numMapTasks > 0) { 

     nonRunningMapCache = createCache(splits, maxLevel);

   }

//创建reduce task

this.reduces = new TaskInProgress[numReduceTasks];

for (int i = 0; i < numReduceTasks; i++) {

reduces[i] = new TaskInProgress(jobId, jobFile,

numMapTasks, i,

jobtracker, conf, this);

//reduce task放入nonRunningReduces，其将在JobTracker向TaskTracker分配reduce task的时候使用。

nonRunningReduces.add(reduces[i]);

}

//创建两个cleanup task，一个用来清理map，一个用来清理reduce.

cleanup = new TaskInProgress[2];

cleanup[0] = new TaskInProgress(jobId, jobFile, splits[0],

jobtracker, conf, this, numMapTasks);

cleanup[0].setJobCleanupTask();

cleanup[1] = new TaskInProgress(jobId, jobFile, numMapTasks,

numReduceTasks, jobtracker, conf, this);

cleanup[1].setJobCleanupTask();

//创建两个初始化 task，一个初始化map，一个初始化reduce.

setup = new TaskInProgress[2];

setup[0] = new TaskInProgress(jobId, jobFile, splits[0],

jobtracker, conf, this, numMapTasks + 1 );

setup[0].setJobSetupTask();

setup[1] = new TaskInProgress(jobId, jobFile, numMapTasks,

numReduceTasks + 1, jobtracker, conf, this);

setup[1].setJobSetupTask();

tasksInited.set(true);//初始化完毕

……

}

三、TaskTracker

TaskTracker也是作为一个单独的JVM来运行的，在其main函数中，主要是调用了new TaskTracker(conf).run()，其中run函数主要调用了：

State offerService() throws Exception {

long lastHeartbeat = 0;

//TaskTracker进行是一直存在的

while (running && !shuttingDown) {

……

long now = System.currentTimeMillis();

//每隔一段时间就向JobTracker发送heartbeat

long waitTime = heartbeatInterval - (now - lastHeartbeat);

if (waitTime > 0) {

synchronized(finishedCount) {

if (finishedCount[0] == 0) {

finishedCount.wait(waitTime);

}

finishedCount[0] = 0;

}

}

……

//发送Heartbeat到JobTracker，得到response

HeartbeatResponse heartbeatResponse = transmitHeartBeat(now);

……

//从Response中得到此TaskTracker需要做的事情

TaskTrackerAction[] actions = heartbeatResponse.getActions();

……

if (actions != null){

for(TaskTrackerAction action: actions) {

if (action instanceof LaunchTaskAction) {

//如果是运行一个新的Task，则将Action添加到任务队列中

addToTaskQueue((LaunchTaskAction)action);

} else if (action instanceof CommitTaskAction) {

CommitTaskAction commitAction = (CommitTaskAction)action;

if (!commitResponses.contains(commitAction.getTaskID())) {

commitResponses.add(commitAction.getTaskID());

}

} else {

tasksToCleanup.put(action);

}

}

}

}

return State.NORMAL;

}

其中transmitHeartBeat主要逻辑如下：

private HeartbeatResponse transmitHeartBeat(long now) throws IOException {

//每隔一段时间，在heartbeat中要返回给JobTracker一些统计信息

boolean sendCounters;

if (now > (previousUpdate + COUNTER_UPDATE_INTERVAL)) {

sendCounters = true;

previousUpdate = now;

}

else {

sendCounters = false;

}

……

//报告给JobTracker，此TaskTracker的当前状态

if (status == null) {

synchronized (this) {

status = new TaskTrackerStatus(taskTrackerName, localHostname,

httpPort,

cloneAndResetRunningTaskStatuses(

sendCounters),

failures,

maxCurrentMapTasks,

maxCurrentReduceTasks);

}

}

……

//当满足下面的条件的时候，此TaskTracker请求JobTracker为其分配一个新的Task来运行：

//当前TaskTracker正在运行的map task的个数小于可以运行的map task的最大个数

//当前TaskTracker正在运行的reduce task的个数小于可以运行的reduce task的最大个数

boolean askForNewTask;

long localMinSpaceStart;

synchronized (this) {

askForNewTask = (status.countMapTasks() < maxCurrentMapTasks ||

status.countReduceTasks() < maxCurrentReduceTasks) &&

acceptNewTasks;

localMinSpaceStart = minSpaceStart;

}

……

//向JobTracker发送heartbeat，这是一个RPC调用

HeartbeatResponse heartbeatResponse = jobClient.heartbeat(status,

justStarted, askForNewTask,

heartbeatResponseId);

……

return heartbeatResponse;

}

四、JobTracker

当JobTracker被RPC调用来发送heartbeat的时候，JobTracker的heartbeat(TaskTrackerStatus status,boolean initialContact, boolean acceptNewTasks, short responseId)函数被调用：

public synchronized HeartbeatResponse heartbeat(TaskTrackerStatus status,

boolean initialContact, boolean acceptNewTasks, short responseId)

throws IOException {

……

String trackerName = status.getTrackerName();

……

short newResponseId = (short)(responseId + 1);

……

HeartbeatResponse response = new HeartbeatResponse(newResponseId, null);

List<TaskTrackerAction> actions = new ArrayList<TaskTrackerAction>();

//如果TaskTracker向JobTracker请求一个task运行

if (acceptNewTasks) {

TaskTrackerStatus taskTrackerStatus = getTaskTracker(trackerName);

if (taskTrackerStatus == null) {

LOG.warn("Unknown task tracker polling; ignoring: " + trackerName);

} else {

//setup和cleanup的task优先级最高

List<Task> tasks = getSetupAndCleanupTasks(taskTrackerStatus);

if (tasks == null ) {

//任务调度器分配任务

tasks = taskScheduler.assignTasks(taskTrackerStatus);

}

if (tasks != null) {

for (Task task : tasks) {

//将任务放入actions列表，返回给TaskTracker

expireLaunchingTasks.addNewTask(task.getTaskID());

actions.add(new LaunchTaskAction(task));

}

}

}

}

……

int nextInterval = getNextHeartbeatInterval();

response.setHeartbeatInterval(nextInterval);

response.setActions(

actions.toArray(new TaskTrackerAction[actions.size()]));

……

return response;

}

默认的任务调度器为JobQueueTaskScheduler，其assignTasks如下：

public synchronized List<Task> assignTasks(TaskTrackerStatus taskTracker)

throws IOException {

ClusterStatus clusterStatus = taskTrackerManager.getClusterStatus();

int numTaskTrackers = clusterStatus.getTaskTrackers();

Collection<JobInProgress> jobQueue = jobQueueJobInProgressListener.getJobQueue();

int maxCurrentMapTasks = taskTracker.getMaxMapTasks();

int maxCurrentReduceTasks = taskTracker.getMaxReduceTasks();

int numMaps = taskTracker.countMapTasks();

int numReduces = taskTracker.countReduceTasks();

//计算剩余的map和reduce的工作量：remaining

int remainingReduceLoad = 0;

int remainingMapLoad = 0;

synchronized (jobQueue) {

for (JobInProgress job : jobQueue) {

if (job.getStatus().getRunState() == JobStatus.RUNNING) {

int totalMapTasks = job.desiredMaps();

int totalReduceTasks = job.desiredReduces();

remainingMapLoad += (totalMapTasks - job.finishedMaps());

remainingReduceLoad += (totalReduceTasks - job.finishedReduces());

}

}

}

//计算平均每个TaskTracker应有的工作量，remaining/numTaskTrackers是剩余的工作量除以TaskTracker的个数。

int maxMapLoad = 0;

int maxReduceLoad = 0;

if (numTaskTrackers > 0) {

maxMapLoad = Math.min(maxCurrentMapTasks,

(int) Math.ceil((double) remainingMapLoad /

numTaskTrackers));

maxReduceLoad = Math.min(maxCurrentReduceTasks,

(int) Math.ceil((double) remainingReduceLoad

/ numTaskTrackers));

}

……

//map优先于reduce，当TaskTracker上运行的map task数目小于平均的工作量，则向其分配map task

if (numMaps < maxMapLoad) {

int totalNeededMaps = 0;

synchronized (jobQueue) {

for (JobInProgress job : jobQueue) {

if (job.getStatus().getRunState() != JobStatus.RUNNING) {

continue;

}

Task t = job.obtainNewMapTask(taskTracker, numTaskTrackers,

taskTrackerManager.getNumberOfUniqueHosts());

if (t != null) {

return Collections.singletonList(t);

}

……

}

}

}

//分配完map task，再分配reduce task

if (numReduces < maxReduceLoad) {

int totalNeededReduces = 0;

synchronized (jobQueue) {

for (JobInProgress job : jobQueue) {

if (job.getStatus().getRunState() != JobStatus.RUNNING ||

job.numReduceTasks == 0) {

continue;

}

Task t = job.obtainNewReduceTask(taskTracker, numTaskTrackers,

taskTrackerManager.getNumberOfUniqueHosts());

if (t != null) {

return Collections.singletonList(t);

}

……

}

}

}

return null;

}

从上面的代码中我们可以知道，JobInProgress的obtainNewMapTask是用来分配map task的，其主要调用findNewMapTask，根据TaskTracker所在的Node从nonRunningMapCache中查找 TaskInProgress。JobInProgress的obtainNewReduceTask是用来分配reduce task的，其主要调用findNewReduceTask，从nonRunningReduces查找TaskInProgress。

五、TaskTracker

private void addToTaskQueue(LaunchTaskAction action) {

if (action.getTask().isMapTask()) {

mapLauncher.addToTaskQueue(action);

} else {

reduceLauncher.addToTaskQueue(action);

}

}

在向JobTracker发送heartbeat后，返回的reponse中有分配好的任务LaunchTaskAction，将其加入队列，调用 addToTaskQueue，如果是map task则放入mapLancher(类型为TaskLauncher)，如果是reduce task则放入reduceLancher(类型为TaskLauncher)：

TaskLauncher是一个线程，其run函数从上面放入的queue中取出一个TaskInProgress，然后调用 startNewTask(TaskInProgress tip)来启动一个task，其又主要调用了localizeJob(TaskInProgress tip)：

private void localizeJob(TaskInProgress tip) throws IOException {

//首先要做的一件事情是有关Task的文件从HDFS拷贝的TaskTracker的本地文件系统中：job.split，job.xml以及job.jar

Path localJarFile = null;

Task t = tip.getTask();

JobID jobId = t.getJobID();

Path jobFile = new Path(t.getJobFile());

……

Path localJobFile = lDirAlloc.getLocalPathForWrite(

getLocalJobDir(jobId.toString())

+ Path.SEPARATOR + "job.xml",

jobFileSize, fConf);

RunningJob rjob = addTaskToJob(jobId, tip);

synchronized (rjob) {

if (!rjob.localized) {

FileSystem localFs = FileSystem.getLocal(fConf);

Path jobDir = localJobFile.getParent();

……

//将job.split拷贝到本地

systemFS.copyToLocalFile(jobFile, localJobFile);

JobConf localJobConf = new JobConf(localJobFile);

Path workDir = lDirAlloc.getLocalPathForWrite(

(getLocalJobDir(jobId.toString())

+ Path.SEPARATOR + "work"), fConf);

if (!localFs.mkdirs(workDir)) {

throw new IOException("Mkdirs failed to create "

+ workDir.toString());

}

System.setProperty("job.local.dir", workDir.toString());

localJobConf.set("job.local.dir", workDir.toString());

// copy Jar file to the local FS and unjar it.

String jarFile = localJobConf.getJar();

long jarFileSize = -1;

if (jarFile != null) {

Path jarFilePath = new Path(jarFile);

localJarFile = new Path(lDirAlloc.getLocalPathForWrite(

getLocalJobDir(jobId.toString())

+ Path.SEPARATOR + "jars",

5 * jarFileSize, fConf), "job.jar");

if (!localFs.mkdirs(localJarFile.getParent())) {

throw new IOException("Mkdirs failed to create jars directory ");

}

//将job.jar拷贝到本地

systemFS.copyToLocalFile(jarFilePath, localJarFile);

localJobConf.setJar(localJarFile.toString());

//将job得configuration写成job.xml

OutputStream out = localFs.create(localJobFile);

try {

localJobConf.writeXml(out);

} finally {

out.close();

}

// 解压缩job.jar

RunJar.unJar(new File(localJarFile.toString()),

new File(localJarFile.getParent().toString()));

}

rjob.localized = true;

rjob.jobConf = localJobConf;

}

}

//真正的启动此Task

launchTaskForJob(tip, new JobConf(rjob.jobConf));

}

当所有的task运行所需要的资源都拷贝到本地后，则调用launchTaskForJob，其又调用TaskInProgress的launchTask函数：

public synchronized void launchTask() throws IOException {

……

//创建task运行目录

localizeTask(task);

if (this.taskStatus.getRunState() == TaskStatus.State.UNASSIGNED) {

this.taskStatus.setRunState(TaskStatus.State.RUNNING);

}

//创建并启动TaskRunner，对于MapTask，创建的是MapTaskRunner，对于ReduceTask，创建的是ReduceTaskRunner

this.runner = task.createRunner(TaskTracker.this, this);

this.runner.start();

this.taskStatus.setStartTime(System.currentTimeMillis());

}

TaskRunner是一个线程，其run函数如下：

public final void run() {

……

TaskAttemptID taskid = t.getTaskID();

LocalDirAllocator lDirAlloc = new LocalDirAllocator("mapred.local.dir");

File jobCacheDir = null;

if (conf.getJar() != null) {

jobCacheDir = new File(

new Path(conf.getJar()).getParent().toString());

}

File workDir = new File(lDirAlloc.getLocalPathToRead(

TaskTracker.getLocalTaskDir(

t.getJobID().toString(),

t.getTaskID().toString(),

t.isTaskCleanupTask())

+ Path.SEPARATOR + MRConstants.WORKDIR,

conf). toString());

FileSystem fileSystem;

Path localPath;

……

//拼写classpath

String baseDir;

String sep = System.getProperty("path.separator");

StringBuffer classPath = new StringBuffer();

// start with same classpath as parent process

classPath.append(System.getProperty("java.class.path"));

classPath.append(sep);

if (!workDir.mkdirs()) {

if (!workDir.isDirectory()) {

LOG.fatal("Mkdirs failed to create " + workDir.toString());

}

}

String jar = conf.getJar();

if (jar != null) {

// if jar exists, it into workDir

File[] libs = new File(jobCacheDir, "lib").listFiles();

if (libs != null) {

for (int i = 0; i < libs.length; i++) {

classPath.append(sep);            // add libs from jar to classpath

classPath.append(libs[i]);

}

}

classPath.append(sep);

classPath.append(new File(jobCacheDir, "classes"));

classPath.append(sep);

classPath.append(jobCacheDir);

}

……

classPath.append(sep);

classPath.append(workDir);

//拼写命令行java及其参数

Vector<String> vargs = new Vector<String>(8);

File jvm =

new File(new File(System.getProperty("java.home"), "bin"), "java");

vargs.add(jvm.toString());

String javaOpts = conf.get("mapred.child.java.opts", "-Xmx200m");

javaOpts = javaOpts.replace("@taskid@", taskid.toString());

String [] javaOptsSplit = javaOpts.split(" ");

String libraryPath = System.getProperty("java.library.path");

if (libraryPath == null) {

libraryPath = workDir.getAbsolutePath();

} else {

libraryPath += sep + workDir;

}

boolean hasUserLDPath = false;

for(int i=0; i<javaOptsSplit.length ;i++) {

if(javaOptsSplit[i].startsWith("-Djava.library.path=")) {

javaOptsSplit[i] += sep + libraryPath;

hasUserLDPath = true;

break;

}

}

if(!hasUserLDPath) {

vargs.add("-Djava.library.path=" + libraryPath);

}

for (int i = 0; i < javaOptsSplit.length; i++) {

vargs.add(javaOptsSplit[i]);

}

//添加Child进程的临时文件夹

String tmp = conf.get("mapred.child.tmp", "./tmp");

Path tmpDir = new Path(tmp);

if (!tmpDir.isAbsolute()) {

tmpDir = new Path(workDir.toString(), tmp);

}

FileSystem localFs = FileSystem.getLocal(conf);

if (!localFs.mkdirs(tmpDir) && !localFs.getFileStatus(tmpDir).isDir()) {

throw new IOException("Mkdirs failed to create " + tmpDir.toString());

}

vargs.add("-Djava.io.tmpdir=" + tmpDir.toString());

// Add classpath.

vargs.add("-classpath");

vargs.add(classPath.toString());

//log文件夹

long logSize = TaskLog.getTaskLogLength(conf);

vargs.add("-Dhadoop.log.dir=" +

new File(System.getProperty("hadoop.log.dir")

).getAbsolutePath());

vargs.add("-Dhadoop.root.logger=INFO,TLA");

vargs.add("-Dhadoop.tasklog.taskid=" + taskid);

vargs.add("-Dhadoop.tasklog.totalLogFileSize=" + logSize);

// 运行map task和reduce task的子进程的main class是Child

vargs.add(Child.class.getName());  // main of Child

……

//运行子进程

jvmManager.launchJvm(this,

jvmManager.constructJvmEnv(setup,vargs,stdout,stderr,logSize,

workDir, env, pidFile, conf));

}

六、Child

真正的map task和reduce task都是在Child进程中运行的，Child的main函数的主要逻辑如下：

while (true) {

//从TaskTracker通过网络通信得到JvmTask对象

JvmTask myTask = umbilical.getTask(jvmId);

……

idleLoopCount = 0;

task = myTask.getTask();

taskid = task.getTaskID();

isCleanup = task.isTaskCleanupTask();

JobConf job = new JobConf(task.getJobFile());

TaskRunner.setupWorkDir(job);

numTasksToExecute = job.getNumTasksToExecutePerJvm();

task.setConf(job);

defaultConf.addResource(new Path(task.getJobFile()));

……

//运行task

task.run(job, umbilical);             // run the task

if (numTasksToExecute > 0 && ++numTasksExecuted == numTasksToExecute) {

break;

}

}

6.1、MapTask

如果task是MapTask，则其run函数如下：

public void run(final JobConf job, final TaskUmbilicalProtocol umbilical)

throws IOException {

//用于同TaskTracker进行通信，汇报运行状况

final Reporter reporter = getReporter(umbilical);

startCommunicationThread(umbilical);

initialize(job, reporter);

……

//map task的输出

int numReduceTasks = conf.getNumReduceTasks();

MapOutputCollector collector = null;

if (numReduceTasks > 0) {

collector = new MapOutputBuffer(umbilical, job, reporter);

} else {

collector = new DirectMapOutputCollector(umbilical, job, reporter);

}

//读取input split，按照其中的信息，生成RecordReader来读取数据

instantiatedSplit = (InputSplit)

ReflectionUtils.newInstance(job.getClassByName(splitClass), job);

DataInputBuffer splitBuffer = new DataInputBuffer();

splitBuffer.reset(split.getBytes(), 0, split.getLength());

instantiatedSplit.readFields(splitBuffer);

if (instantiatedSplit instanceof FileSplit) {

FileSplit fileSplit = (FileSplit) instantiatedSplit;

job.set("map.input.file", fileSplit.getPath().toString());

job.setLong("map.input.start", fileSplit.getStart());

job.setLong("map.input.length", fileSplit.getLength());

}

RecordReader rawIn =                  // open input

job.getInputFormat().getRecordReader(instantiatedSplit, job, reporter);

RecordReader in = isSkipping() ?

new SkippingRecordReader(rawIn, getCounters(), umbilical) :

new TrackedRecordReader(rawIn, getCounters());

job.setBoolean("mapred.skip.on", isSkipping());

//对于map task，生成一个MapRunnable，默认是MapRunner

MapRunnable runner =

ReflectionUtils.newInstance(job.getMapRunnerClass(), job);

try {

//MapRunner的run函数就是依次读取RecordReader中的数据，然后调用Mapper的map函数进行处理。

runner.run(in, collector, reporter);

collector.flush();

} finally {

in.close();                               // close input

collector.close();

}

done(umbilical);

}

MapRunner的run函数就是依次读取RecordReader中的数据，然后调用Mapper的map函数进行处理：

public void run(RecordReader<K1, V1> input, OutputCollector<K2, V2> output,

Reporter reporter)

throws IOException {

try {

K1 key = input.createKey();

V1 value = input.createValue();

while (input.next(key, value)) {

mapper.map(key, value, output, reporter);

if(incrProcCount) {

reporter.incrCounter(SkipBadRecords.COUNTER_GROUP,

SkipBadRecords.COUNTER_MAP_PROCESSED_RECORDS, 1);

}

}

} finally {

mapper.close();

}

}

结果集全部收集到MapOutputBuffer中，其collect函数如下：

public synchronized void collect(K key, V value)

throws IOException {

reporter.progress();

……

//从此处看，此buffer是一个ring的数据结构

final int kvnext = (kvindex + 1) % kvoffsets.length;

spillLock.lock();

try {

boolean kvfull;

do {

//在ring中，如果下一个空闲位置接上起始位置的话，则表示满了

kvfull = kvnext == kvstart;

//在ring中计算是否需要将buffer写入硬盘的阈值

final boolean kvsoftlimit = ((kvnext > kvend)

? kvnext - kvend > softRecordLimit

: kvend - kvnext <= kvoffsets.length - softRecordLimit);

//如果到达阈值，则开始将buffer写入硬盘，写成spill文件。

//startSpill主要是notify一个背后线程SpillThread的run()函数，开始调用sortAndSpill()开始排序，合并，写入硬盘

if (kvstart == kvend && kvsoftlimit) {

startSpill();

}

//如果buffer满了，则只能等待写入完毕

if (kvfull) {

while (kvstart != kvend) {

reporter.progress();

spillDone.await();

}

}

} while (kvfull);

} finally {

spillLock.unlock();

}

try {

//如果buffer不满，则将key, value写入buffer

int keystart = bufindex;

keySerializer.serialize(key);

final int valstart = bufindex;

valSerializer.serialize(value);

int valend = bb.markRecord();

//调用设定的partitioner，根据key, value取得partition id

final int partition = partitioner.getPartition(key, value, partitions);

mapOutputRecordCounter.increment(1);

mapOutputByteCounter.increment(valend >= keystart

? valend - keystart

: (bufvoid - keystart) + valend);

//将parition id以及key, value在buffer中的偏移量写入索引数组

int ind = kvindex * ACCTSIZE;

kvoffsets[kvindex] = ind;

kvindices[ind + PARTITION] = partition;

kvindices[ind + KEYSTART] = keystart;

kvindices[ind + VALSTART] = valstart;

kvindex = kvnext;

} catch (MapBufferTooSmallException e) {

LOG.info("Record too large for in-memory buffer: " + e.getMessage());

spillSingleRecord(key, value);

mapOutputRecordCounter.increment(1);

return;

}

}

内存buffer的格式如下：

(见几位hadoop大侠的分析http://blog.csdn.net/HEYUTAO007/archive/2010/07/10/5725379.aspx 以及http://caibinbupt.javaeye.com/)

kvoffsets是为了写入内存前排序使用的。

从上面可知，内存buffer写入硬盘spill文件的函数为sortAndSpill：

private void sortAndSpill() throws IOException {

……

FSDataOutputStream out = null;

FSDataOutputStream indexOut = null;

IFileOutputStream indexChecksumOut = null;

//创建硬盘上的spill文件

Path filename = mapOutputFile.getSpillFileForWrite(getTaskID(),

numSpills, size);

out = rfs.create(filename);

……

final int endPosition = (kvend > kvstart)

? kvend

: kvoffsets.length + kvend;

//按照partition的顺序对buffer中的数据进行排序

sorter.sort(MapOutputBuffer.this, kvstart, endPosition, reporter);

int spindex = kvstart;

InMemValBytes value = new InMemValBytes();

//依次一个一个parition的写入文件

for (int i = 0; i < partitions; ++i) {

IFile.Writer<K, V> writer = null;

long segmentStart = out.getPos();

writer = new Writer<K, V>(job, out, keyClass, valClass, codec);

//如果combiner为空，则直接写入文件

if (null == combinerClass) {

……

writer.append(key, value);

++spindex;

}

else {

……

//如果combiner不为空，则先combine，调用combiner.reduce(…)函数后再写入文件

combineAndSpill(kvIter, combineInputCounter);

}

}

……

}

当map阶段结束的时候，MapOutputBuffer的flush函数会被调用，其也会调用sortAndSpill将buffer中的写入文件，然后再调用mergeParts来合并写入在硬盘上的多个spill:

private void mergeParts() throws IOException {

……

//对于每一个partition

for (int parts = 0; parts < partitions; parts++){

//create the segments to be merged

List<Segment<K, V>> segmentList =

new ArrayList<Segment<K, V>>(numSpills);

TaskAttemptID mapId = getTaskID();

//依次从各个spill文件中收集属于当前partition的段

for(int i = 0; i < numSpills; i++) {

final IndexRecord indexRecord =

getIndexInformation(mapId, i, parts);

long segmentOffset = indexRecord.startOffset;

long segmentLength = indexRecord.partLength;

Segment<K, V> s =

new Segment<K, V>(job, rfs, filename[i], segmentOffset,

segmentLength, codec, true);

segmentList.add(i, s);

}

//将属于同一个partition的段merge到一起

RawKeyValueIterator kvIter =

Merger.merge(job, rfs,

keyClass, valClass,

segmentList, job.getInt("io.sort.factor", 100),

new Path(getTaskID().toString()),

job.getOutputKeyComparator(), reporter);

//写入合并后的段到文件

long segmentStart = finalOut.getPos();

Writer<K, V> writer =

new Writer<K, V>(job, finalOut, keyClass, valClass, codec);

if (null == combinerClass || numSpills < minSpillsForCombine) {

Merger.writeFile(kvIter, writer, reporter, job);

} else {

combineCollector.setWriter(writer);

combineAndSpill(kvIter, combineInputCounter);

}

……

}

}

6.2、ReduceTask

ReduceTask的run函数如下：

public void run(JobConf job, final TaskUmbilicalProtocol umbilical)

throws IOException {

job.setBoolean("mapred.skip.on", isSkipping());

//对于reduce，则包含三个步骤：拷贝，排序，Reduce

if (isMapOrReduce()) {

copyPhase = getProgress().addPhase("copy");

sortPhase  = getProgress().addPhase("sort");

reducePhase = getProgress().addPhase("reduce");

}

startCommunicationThread(umbilical);

final Reporter reporter = getReporter(umbilical);

initialize(job, reporter);

//copy阶段，主要使用ReduceCopier的fetchOutputs函数获得map的输出。创建多个线程MapOutputCopier，其中copyOutput进行拷贝。

boolean isLocal = "local".equals(job.get("mapred.job.tracker", "local"));

if (!isLocal) {

reduceCopier = new ReduceCopier(umbilical, job);

if (!reduceCopier.fetchOutputs()) {

……

}

}

copyPhase.complete();

//sort阶段，将得到的map输出合并，直到文件数小于io.sort.factor时停止，返回一个Iterator用于访问key-value

setPhase(TaskStatus.Phase.SORT);

statusUpdate(umbilical);

final FileSystem rfs = FileSystem.getLocal(job).getRaw();

RawKeyValueIterator rIter = isLocal

? Merger.merge(job, rfs, job.getMapOutputKeyClass(),

job.getMapOutputValueClass(), codec, getMapFiles(rfs, true),

!conf.getKeepFailedTaskFiles(), job.getInt("io.sort.factor", 100),

new Path(getTaskID().toString()), job.getOutputKeyComparator(),

reporter)

: reduceCopier.createKVIterator(job, rfs, reporter);

mapOutputFilesOnDisk.clear();

sortPhase.complete();

//reduce阶段

setPhase(TaskStatus.Phase.REDUCE);

……

Reducer reducer = ReflectionUtils.newInstance(job.getReducerClass(), job);

Class keyClass = job.getMapOutputKeyClass();

Class valClass = job.getMapOutputValueClass();

ReduceValuesIterator values = isSkipping() ?

new SkippingReduceValuesIterator(rIter,

job.getOutputValueGroupingComparator(), keyClass, valClass,

job, reporter, umbilical) :

new ReduceValuesIterator(rIter,

job.getOutputValueGroupingComparator(), keyClass, valClass,

job, reporter);

//逐个读出key-value list，然后调用Reducer的reduce函数

while (values.more()) {

reduceInputKeyCounter.increment(1);

reducer.reduce(values.getKey(), values, collector, reporter);

values.nextKey();

values.informReduceProgress();

}

reducer.close();

out.close(reporter);

done(umbilical);

}

七、总结

Map-Reduce的过程总结如下图：