整体架构

MRAppMaster是MapReduce的ApplicationMaster实现，它使得MapReduce计算框架可以运行于YARN之上。在YARN中，MRAppMaster负责管理MapReduce作业的生命周期，包括创建MapReduce作业，向ResourceManager申请资源，与NodeManage通信要求其启动Container，监控作业的运行状态，当任务失败时重新启动任务等。

hadoop3 yarn 地址_事件处理

 

YARN使用了基于事件驱动的异步编程模型，它通过事件将各个组件联系起来，并由一个中央事件调度器统一将各种事件分配给对应的事件处理器。在YARN中，每种组件是一种事件处理器，当MRAppMaster启动时，它们会以服务的形式注册到MRAppMaster的中央事件调度器上，并告诉调度器它们处理的事件类型，这样，当出现某一种事件时，MRAppMaster会查询<事件，事件处理器>表，并将该事件分配给对应的事件处理器。

接下来，我们分别介绍MRAppMaster各种组件/服务的功能。

ContainerAllocator

与ResourceManager通信，为作业申请资源。作业的每个任务资源需求可描述为四元组<Priority, hostname，capability，containers>，分别表示作业优先级、期望资源所在的host，资源量（当前仅支持内存），container数目。ContainerAllocator周期性通过RPC与ResourceManager通信，而ResourceManager会为之返回已经分配的container列表，完成的container列表等信息。

ClientService

ClientService是一个接口，由MRClientService实现。MRClientService实现了MRClientProtocol协议，客户端可通过该协议获取作业的执行状态（而不必通过ResourceManager）和制作业（比如杀死作业等）。

Job

表示一个MapReduce作业，与MRv1的JobInProgress功能一样，负责监控作业的运行状态。它维护了一个作业状态机，以实现异步控制各种作业操作。

Task

表示一个MapReduce作业中的某个任务，与MRv1中的TaskInProgress功能类似，负责监控一个任务的运行状态。它为花了一个任务状态机，以实现异步控制各种任务操作。

TaskAttempt

表示一个任务运行实例，同MRv1中的概念一样。

TaskCleaner

清理失败任务或者被杀死任务产生的结果，它维护了一个线程池，异步删除这些任务产生的结果。

Speculator

完成推测执行功能。当一个任务运行速度明显慢于其他任务时，Speculator会为该任务启动一个备份任务，让其同慢任务一同处理同一份数据，谁先计算完成则将谁的结果作为最终结果，另一个任务将被杀掉。该机制可有效防止“拖后腿”任务拖慢整个作业的执行进度。

ContainerLauncher

与NodeManager通信，要求其启动一个Container。当ResourceManager为作业分配资源后，ContainerLauncher会将资源信息封装成container，包括任务运行所需资源、任务运行命令、任务运行环境、任务依赖的外部文件等，然后与对应的节点通信，要求其启动container。

TaskAttemptListener

管理各个任务的心跳信息，如果一个任务一段时间内未汇报心跳，则认为它死掉了，会将其从系统中移除。同MRv1中的TaskTracker类似，它实现了TaskUmbilicalProtocol协议，任务会通过该协议汇报心跳，并询问是否能够提交最终结果。

JobHistoryEventHandler

对作业的各个事件记录日志，比如作业创建、作业开始运行、一个任务开始运行等，这些日志会被写到HDFS的某个目录下，这对于作业恢复非常有用。当MRAppMaster出现故障时，YARN会将其重新调度到另外一个节点上，为了避免重新计算，MRAppMaster首先会从HDFS上读取上次运行产生的运行日志，以恢复已经运行完成的任务，进而能够只运行尚未运行完成的任务。

Recovery

当一个MRAppMaster故障后，它将被调度到另外一个节点上重新运行，为了避免重新计算，MRAppMaster首先会从HDFS上读取上次运行产生的运行日志，并恢复作业运行状态。

--------------------------------------------------------------------------------------------------------------------------------------------------------------------

作业生命周期

 

在正式讲解作业生命周期之前，先要了解MRAppMaster中作业表示方式，每个作业由若干干Map Task和Reduce Task组成，每个Task进一步由若干个TaskAttempt组成，Job、Task和TaskAttempt的生命周期均由一个状态机表示，具体可参考https://issues.apache.org/jira/browse/MAPREDUCE-279（附件中的图yarn-state-machine.job.png，yarn-state-machine.task.png和yarn-state-machine.task-attempt.png）

hadoop3 yarn 地址_状态机_02

 

作业的创建入口在MRAppMaster类中，如下所示：

1. public class MRAppMaster extends CompositeService {
2.  
3.   public void start() {
4.  
5.     ...
6.  
7.     job = createJob(getConfig());//创建Job
8.  
9.     JobEvent initJobEvent = new JobEvent(job.getID(), JobEventType.JOB_INIT);
10.  
11.     jobEventDispatcher.handle(initJobEvent);//发送JOB_INI,创建MapTask,ReduceTask
12.  
13.     startJobs();//启动作业，这是后续一切动作的触发之源
14.  
15.     ...
16.  
17.   }
18.  
19. protected Job createJob(Configuration conf) {
20.  
21.   Job newJob =
22.  
23.     new JobImpl(jobId, appAttemptID, conf, dispatcher.getEventHandler(),
24.  
25.       taskAttemptListener, jobTokenSecretManager, fsTokens, clock,
26.  
27.       completedTasksFromPreviousRun, metrics, committer, newApiCommitter,
28.  
29.       currentUser.getUserName(), appSubmitTime, amInfos, context);
30.  
31.   ((RunningAppContext) context).jobs.put(newJob.getID(), newJob);
32.  
33.   dispatcher.register(JobFinishEvent.Type.class,
34.  
35.     createJobFinishEventHandler());
36.  
37.   return newJob;
38.  
39.   }
40.  
41. }

复制代码

（1）作业/任务初始化

JobImpl会接收到.JOB_INIT事件，然后触发作业状态从NEW变为INITED，并触发函数InitTransition()，该函数会创建MapTask和

ReduceTask，代码如下：

1. public static class InitTransition
2.  
3.   implements MultipleArcTransition<JobImpl, JobEvent, JobState> {
4.  
5.   ...
6.  
7.   createMapTasks(job, inputLength, taskSplitMetaInfo);
8.  
9.   createReduceTasks(job);
10.  
11.   ...
12.  
13. }

复制代码其中，createMapTasks函数实现如下： 

1. private void createMapTasks(JobImpl job, long inputLength,
2.  
3.   TaskSplitMetaInfo[] splits) {
4.  
5.   for (int i=0; i < job.numMapTasks; ++i) {
6.  
7.     TaskImpl task =
8.  
9.       new MapTaskImpl(job.jobId, i,
10.  
11.       job.eventHandler,
12.  
13.       job.remoteJobConfFile,
14.  
15.       job.conf, splits[i],
16.  
17.       job.taskAttemptListener,
18.  
19. job.committer, job.jobToken, job.fsTokens,
20.  
21. job.clock, job.completedTasksFromPreviousRun,
22.  
23. job.applicationAttemptId.getAttemptId(),
24.  
25. job.metrics, job.appContext);
26.  
27. job.addTask(task);
28.  
29. }
30.  
31. }

复制代码（2）作业启动 

1. public class MRAppMaster extends CompositeService {
2.  
3. protected void startJobs() {
4.  
5. JobEvent startJobEvent = new JobEvent(job.getID(), JobEventType.JOB_START);
6.  
7. dispatcher.getEventHandler().handle(startJobEvent);
8.  
9. }
10.  
11. }

复制代码JobImpl会接收到.JOB_START事件，会触发作业状态从INITED变为RUNNING，并触发函数StartTransition()，进而触发Map Task和Reduce Task开始调度: 

1. public static class StartTransition
2.  
3. implements SingleArcTransition<JobImpl, JobEvent> {
4.  
5. public void transition(JobImpl job, JobEvent event) {
6.  
7. job.scheduleTasks(job.mapTasks);
8.  
9. job.scheduleTasks(job.reduceTasks);
10.  
11. }
12.  
13. }

复制代码

这之后，所有Map Task和Reduce Task各自负责各自的状态变化，ContainerAllocator模块会首先为Map Task申请资源，然后是Reduce Task，一旦一个Task获取到了资源，则会创建一个运行实例TaskAttempt，如果该实例运行成功，则Task运行成功，否则，Task还会启动下一个运行实例TaskAttempt，直到一个TaskAttempt运行成功或者达到尝试次数上限。当所有Task运行成功后，Job运行成功。一个运行成功的任务所经历的状态变化如下（不包含失败或者被杀死情况）：

hadoop3 yarn 地址_生命周期_03

 

【总结】

本文分析只是起到抛砖引入的作用，读者如果感兴趣，可以自行更深入的研究以下内容：

（1）Job、Task和TaskAttempt状态机设计（分别在JobImpl、TaskImpl和TaskAttemptImpl中）

（2）在以下几种场景下，以上三个状态机的涉及到的变化：

1）  kill job

2）  kill task attempt

3）  fail task attempt

4）  container failed

5）  lose node