事件驱动带来的变化

在MRv1中，对象之间的作用关系是基于函数调用实现的，当一个对象向另外一个对象传递信息时，会直接采用函数调用的方式，且整个过程是串行的。比如，当TaskTracker需要执行一个Task时，将首先下载Task依赖的文件（JAR包、二进制文件等、字典文件等）、然后执行Task。同时在整个过程中会记录一些关键日志，该过程可用图3-16描述。在整个过程中，下载依赖文件是阻塞式的，也就是说，前一个任务未完成文件下载之前，后一个新任务将一直处于等待状态，只有在下载完成后，才会启动一个独立进程运行该任务。尽管后来MRv1通过启动过独立线程下载文件解决了该问题，但这种方式不是在大系统中彻底解决问题之道，必须引入新的编程模型。

基于函数调用的编程模型是低效的，它隐含着整个过程是串行、同步进行的。相比之下，MRv2引入的事件驱动编程模型则是一种更加高效的方式。在基于事件驱动的编程模型中，所有对象被抽象成了事件处理器，而事件处理器之间通过事件相互关联。每种事件处理器处理一种类型的事件，同时根据需要触发另外一种事件，该过程如图3-17所示，当A需要下载文件时，只需向中央异步处理器发送一个事件即可（之后可以继续完成后面的功能而无须等待下载完成），该事件会被传递给对应的事件处理器B，由B完成具体的下载任务。一旦B完成下载任务，便可以通过事件通知A。

相比于基于函数调用的编程模型，这种编程方式具有异步、并发等特点，更加高效，因此更适合大型分布式系统。

状态机类

YARN自己实现了一个非常简单的状态机库（位于包org.apache.hadcop.yarn.state中），具体如图3-21所示。YARN对外提供了一个状态机工厂StatemachineFactory，它提供多种addTransition方法供用户添加各种状态转移，一旦状态机添加完毕后，可通过调用installTopology完成一个状态机的构建。
 

状态机的使用方法

本小节将给出一个状态机应用实例，在该实例中，创建一个作业状态机JobStateMachine，该状态机维护作业内部的各种状态变化。该状态机同时也是一个事件处理器，当接收到某种事件后，会触发相应的状态转移。该实例中没有给出一个中央异步调度器，可以嵌到3.4.3节的实例程序中运行。

1）定义作业类型。
 

 
 
public enum JobEventType {  
  JOB_KILL,  
  JOB_INIT,  
  JOB_START,  
  JOB_SETUP_COMPLETED,  
  JOB_COMPLETED  
} 

2）定义作业状态机。
 

 
 
@SuppressWarnings({ "rawtypes", "unchecked" })  
public class JobStateMachine implements EventHandler<JobEvent>{  
  private final String jobID;  
  private EventHandler eventHandler;  
  private final Lock writeLock;  
  private final Lock readLock;  
 
// 定义状态机  
  protected static final  
    StateMachineFactory<JobStateMachine, JobStateInternal, JobEventType, JobEvent> 
      stateMachineFactory 
        = new StateMachineFactory<JobStateMachine, JobStateInternal, JobEventType, JobEvent> 
          (JobStateInternal.NEW)  
 
          .addTransition(JobStateInternal.NEW, JobStateInternal.INITED,  
               JobEventType.JOB_INIT,  
              new InitTransition())  
          .addTransition(JobStateInternal.INITED, JobStateInternal.SETUP,  
              JobEventType.JOB_START,  
              new StartTransition())  
          .addTransition(JobStateInternal.SETUP, JobStateInternal.RUNNING,  
              JobEventType.JOB_SETUP_COMPLETED,  
              new SetupCompletedTransition())  
          .addTransition  
              (JobStateInternal.RUNNING,  
              EnumSet.of(JobStateInternal.KILLED, JobStateInternal.SUCCEEDED),  
              JobEventType.JOB_COMPLETED,  
              new JobTasksCompletedTransition())  
           .installTopology();  
 
  private final StateMachine<JobStateInternal, JobEventType, JobEvent> stateMachine;  
 
  public JobStateMachine(String jobID, EventHandler eventHandler) {  
    this.jobID = jobID;  
    ReadWriteLock readWriteLock = new ReentrantReadWriteLock();  
    this.readLock = readWriteLock.readLock();  
    this.writeLock = readWriteLock.writeLock();  
    this.eventHandler = eventHandler;  
    stateMachine = stateMachineFactory.make(this);  
  }  
  protected StateMachine<JobStateInternal, JobEventType, JobEvent> getStateMachine() {  
    return stateMachine;  
  }  
 
  public static class InitTransition  
    implements SingleArcTransition<JobStateMachine, JobEvent> {  
      @Override  
      public void transition(JobStateMachine job, JobEvent event) {  
        System.out.println("Receiving event " + event);  
        job.eventHandler.handle(new JobEvent(job.getJobId(), JobEventType.JOB_START));  
      }  
  }  
 
  public static class StartTransition  
  implements SingleArcTransition<JobStateMachine, JobEvent> {  
    @Override  
    public void transition(JobStateMachine job, JobEvent event) {  
      System.out.println("Receiving event " + event);  
      job.eventHandler.handle(new JobEvent(job.getJobId(), JobEventType.JOB_SETUP_COMPLETED));  
    }  
  }  
  …  
  //定义类SetupCompletedTransition和JobTasksCompletedTransition  
 
  @Override  
  public void handle(JobEvent event) {  
    try {  
      writeLock.lock();  
      JobStateInternal oldState = getInternalState();  
      try {  
         getStateMachine().doTransition(event.getType(), event);  
         } catch (InvalidStateTransitonException e) {  
         System.out.println("Can't handle this event at current state");  
      }  
      if (oldState != getInternalState()) {  
        System.out.println("Job Transitioned from " + oldState + " to "  
                 + getInternalState());  
      }  
    }  
    finally {  
      writeLock.unlock();  
    }  
  }  
 
  public JobStateInternal getInternalState() {  
    readLock.lock();  
    try {  
     return getStateMachine().getCurrentState();  
    } finally {  
    readLock.unlock();  
    }  
  }  
  public enum JobStateInternal { //作业内部状态  
    NEW,  
    SETUP,  
    INITED,  
    RUNNING,  
    SUCCEEDED,  
    KILLED,  
  }  
} 

状态机可视化

YARN中实现了多个状态机对象，包括ResourceManager中的RMAppImpl、RMApp-AttemptImpl、RMContainerImpl和RMNodeImpl，NodeManager中的ApplicationImpl、ContainerImpl和LocalizedResource，MRAppMaster中的JobImpl、TaskImpl和TaskAttemptImpl等。为了便于用户查看这些状态机的状态变化以及相关事件，YARN提供了一个状态机可视化工具，具体操作步骤如下。

步骤1　将状态机转化为graphviz(.gv)格式的文件，编译命令如下：
 

 
 
mvn compile -Pvisualize 

经过该步骤后，本地目录中生成了ResourceManager.gv、NodeManager.gv和MapReduce.gv三个graphviz格式的文件（有兴趣可以直接打开查看具体内容）。

步骤2　使用可视化包graphviz中的相关命令生成状态机图，Shell命令具体如下：
 

 
 
dot -Tpng NodeManager.gv > NodeManager.png 

如果尚未安装graphviz包，操作该步骤之前先要安装该包。