Hadoop3.2.1 【 YARN 】源码分析 : StateMachineFactory解析[一]

淩亂°似流年 2022-12-28 09:15 95阅读 0赞

# 一. 前言 #

YARN采用了基于事件驱动的并发模型， 该模型能够大大增强并发性， 从而提高系统整体性能。 为了构建该模型， YARN将各种处理逻辑抽象成事件和对应事件调度器， 并将每类事件的处理过程分割成多个步骤， 用有限状态机表示。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70]  
整个处理过程大致为： 处理请求会作为事件进入系统， 由中央异步调度器（AsyncDispatcher） 负责传递给相应事件调度器（Event Handler） 。 该事件调度器可能将该事件转发给另外一个事件调度器， 也可能交给一个带有有限状态机的事件处理器， 其处理结果  
也以事件的形式输出给中央异步调度器。 而新的事件会再次被中央异步调度器转发给下一个事件调度器， 直至处理完成（达到终止条件） 。

在YARN中， 所有核心服务实际上都是一个中央异步调度器， 包括ResourceManager、 NodeManager、 MRAppMaster（MapReduce应用程序的ApplicationMaster） 等， 它们维护了事先注册的事件与事件处理器， 并根据接收的事件类型驱动服务的运行。

在基于事件驱动的编程模型中， 所有对象被抽象成了事件处理器， 而事件处理器之间通过事件相互关联。 每种事件处理器处理一种类型的事件， 同时根据需要触发另外一种事件.

状态机工厂StateMachineFactory， 它提供多种addTransition方法供用户添加各种状态转移， 一旦状态机添加完毕后， 可通过调用installTopology完成一个状态机的构建  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70 1]

# 二. 属性 #

**transitionsListNode**：就是将状态机的一个个过渡的ApplicableTransition实现串联为一个列表，每个节点包含一个ApplicableTransition实现及指向下一个节点的引用

**stateMachineTable** : 状态拓扑表,为了提高检索状态对应的过渡map而冗余的数据结构，此结构在optimized为真时，通过对transitionsListNode链表进行处理产生

**defaultInitialState**：对象创建时，内部有限状态机的默认初始状态。比如：JobImpl的内部状态机默认初始状态是JobStateInternal.NEW。

**optimized**：布尔类型，用于标记当前状态机是否需要优化性能，即构建状态拓扑表stateMachineTable。

// transitionsListNode的主要作用的把状态机中的transition按照状态转移的顺利逆序的链成一个链表。
     private final TransitionsListNode transitionsListNode;
    
    
      // 状态机表
      // [状态 -> <事件类型->操作>  ]
    
      // <OPERAND> 状态机操作此对象类型.
      // <STATE> 实体的状态.
      // <EVENTTYPE> 需要处理的外部事件.
      // <EVENT> 事件对象.
    
      private Map<STATE, Map<EVENTTYPE,  Transition<OPERAND, STATE, EVENTTYPE, EVENT>>> stateMachineTable;
    
      // 默认初始化状态
      private STATE defaultInitialState;
    
      // 是否优化, 用于构建 makeStateMachineTable , 默认值 true  
      private final boolean optimized;

# 三. 构造方法 #

在StateMachineFactory里面有三个构造方法,其中 只有一个构造方法是共有的,另外两个是私有的构造方法.

## 3.1. 公有的构造方法: ##

/** * Constructor * * This is the only constructor in the API. * */
      public StateMachineFactory(STATE defaultInitialState) { 
        this.transitionsListNode = null;
        this.defaultInitialState = defaultInitialState;
        this.optimized = false;
        this.stateMachineTable = null;
      }

## 3.2. 私有的构造方法: ##

// 私有构造方法 : no.1 主要作用是构建transitionsListNode链表。
      // addTransition内部创建StateMachineFactory对象。
      private StateMachineFactory(StateMachineFactory<OPERAND, STATE, EVENTTYPE, EVENT> that,
           ApplicableTransition<OPERAND, STATE, EVENTTYPE, EVENT> t) { 
        this.defaultInitialState = that.defaultInitialState;
        this.transitionsListNode 
            = new TransitionsListNode(t, that.transitionsListNode);
        this.optimized = false;
        this.stateMachineTable = null;
      }
    
    
      // 私有构造方法 : no.2 用于installTopology方法
      // 这个比较特殊: 只有 StateMachineFactory.installTopology() 方法调用 ==> optimized : true
      // addTransition内部创建StateMachineFactory对象。
      private StateMachineFactory(StateMachineFactory<OPERAND, STATE, EVENTTYPE, EVENT> that,  boolean optimized) { 
        this.defaultInitialState = that.defaultInitialState;
        this.transitionsListNode = that.transitionsListNode;
        this.optimized = optimized;
        if (optimized) { 
          makeStateMachineTable();
        } else { 
          stateMachineTable = null;
        }
      }

# 四. 状态转换 \[ addTransition \] #

状态机由一组状态组成， 这些状态分为三类： 初始状态、 中间状态和最终状态。  
**状态机从初始状态开始运行， 经过一系列中间状态后， 到达最终状态并退出。 在一个状态机中， 每个状态都可以接收一组特定事件， 并根据具体的事件类型转换到另一个状态。 当状态机转换到最终状态时， 则退出.**

> YARN中四种状态 : **转换前状态（preState）** 、 **转换后状态（postState）** 、 **事件（event）** 和**回调函数（hook）**

YARN定义了三种状态转换方式， 具体如下( 4.1 ~ 4.3 )： 不管哪种状态都是通过addTransition方法转换的,只是参数不同而已.最底层调用的是都是同一个 StateMachineFactory构造方法, 核心是更新transitionsListNode链表, 这个具体是干啥,我们下面再做分析.

// 私有构造方法 : no.1
      // addTransition内部创建StateMachineFactory对象。
      private StateMachineFactory(StateMachineFactory<OPERAND, STATE, EVENTTYPE, EVENT> that,
           ApplicableTransition<OPERAND, STATE, EVENTTYPE, EVENT> t) { 
        this.defaultInitialState = that.defaultInitialState;
        this.transitionsListNode = new TransitionsListNode(t, that.transitionsListNode);
        this.optimized = false;
        this.stateMachineTable = null;
      }

## 4.1. 一个初始状态、 一个最终状态、 一种事件、 零/一个回调 ##

该方式表示状态机在preState状态下， 接收到Event事件后， 执行函数状态转移函数Hook， 并在执行完成后将当前状态转换为postState

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70 2]

/** * * 一个初始状态、一个最终状态、一种事件 * * @return a NEW StateMachineFactory just like {@code this} with the current * transition added as a new legal transition. This overload * has no hook object. * * Note that the returned StateMachineFactory is a distinct * object. * * This method is part of the API. * * @param preState pre-transition state * @param postState post-transition state * @param eventType stimulus for the transition */
      // 构造方法 no.1
      // 一个初始状态、一个最终状态、一种事件
      public StateMachineFactory
                 <OPERAND, STATE, EVENTTYPE, EVENT>
              addTransition(STATE preState, STATE postState, EVENTTYPE eventType) { 
        return addTransition(preState, postState, eventType, null);
      }
    
    
      /** * @return a NEW StateMachineFactory just like {@code this} with the current * transition added as a new legal transition * * Note that the returned StateMachineFactory is a distinct object. * * This method is part of the API. * * @param preState pre-transition state * @param postState post-transition state * @param eventType stimulus for the transition * @param hook transition hook */
      // 构造方法 no.1
      // [ 1-1-1-1 引用 + 1 ] 一个初始状态、一个最终状态，一个事件，一个回调;
      public StateMachineFactory
              <OPERAND, STATE, EVENTTYPE, EVENT>
      addTransition(STATE preState, STATE postState,
                    EVENTTYPE eventType,
                    SingleArcTransition<OPERAND, EVENT> hook){ 
        return new StateMachineFactory<OPERAND, STATE, EVENTTYPE, EVENT>
                (this, new ApplicableSingleOrMultipleTransition<OPERAND, STATE, EVENTTYPE, EVENT>
                        (preState, eventType, new SingleInternalArc(postState, hook)));
      }

## 4.2. 一个初始状态、 一个最终状态、 多种事件 、 零/一个回调 ##

该方式表示状态机在preState状态下， 接收到Event1、 Event2和Event3中的任何一个事件， 将执行函数状态转移函数Hook， 并在执行完成后将当前状态转换为postState。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70 3]

/** * @return a NEW StateMachineFactory just like {@code this} with the current * transition added as a new legal transition. This overload * has no hook object. * * * Note that the returned StateMachineFactory is a distinct * object. * * This method is part of the API. * * @param preState pre-transition state * @param postState post-transition state * @param eventTypes List of stimuli for the transitions */
      // 一个初始状态、多种事件、一个最终状态、无回调函数
      public StateMachineFactory<OPERAND, STATE, EVENTTYPE, EVENT> addTransition(
          STATE preState, STATE postState, Set<EVENTTYPE> eventTypes) { 
        return addTransition(preState, postState, eventTypes, null);
      }
    
      /** * @return a NEW StateMachineFactory just like {@code this} with the current * transition added as a new legal transition * * Note that the returned StateMachineFactory is a distinct * object. * * This method is part of the API. * * @param preState pre-transition state * @param postState post-transition state * @param eventTypes List of stimuli for the transitions * @param hook transition hook */
      // 一个初始状态、多种事件、一个最终状态 、 一个回调函数
      // [ 1-*-1-1 引用 + 1 ]
      public StateMachineFactory<OPERAND, STATE, EVENTTYPE, EVENT> addTransition(
          STATE preState, STATE postState, Set<EVENTTYPE> eventTypes,
          SingleArcTransition<OPERAND, EVENT> hook) { 
    
        StateMachineFactory<OPERAND, STATE, EVENTTYPE, EVENT> factory = null;
    
        for (EVENTTYPE event : eventTypes) { 
          if (factory == null) { 
            // 构造方法 no.1 : 构建StateMachineFactory 头信息
            factory = addTransition(preState, postState, event, hook);
          } else { 
            // 构造方法 no.1
            factory = factory.addTransition(preState, postState, event, hook);
          }
        }
        return factory;
      }

最后依旧会将任务进行拆解 变成 一个初始状态、一种事件、一个最终状态 、 一个回调函数 .

## 4.3. **一个初始状态、 多个最终状态、 一种事件、多个回调 。** ##

该方式表示状态机在preState状态下， 接收到Event事件后， 执行函数状态转移函数Hook， 并将当前状态转移为  
函数Hook的返回值所表示的状态

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70 4]

/** * @return a NEW StateMachineFactory just like {@code this} with the current * transition added as a new legal transition * * Note that the returned StateMachineFactory is a distinct object. * * This method is part of the API. * * @param preState pre-transition state * @param postStates valid post-transition states * @param eventType stimulus for the transition * @param hook transition hook */
      // 第三种 : 一个初始状态、多个最终状态，一个事件，多个回调
      public StateMachineFactory  <OPERAND, STATE, EVENTTYPE, EVENT>  addTransition(STATE preState, 
                            Set<STATE> postStates,
                            EVENTTYPE eventType,
                            MultipleArcTransition<OPERAND, EVENT, STATE> hook){ 
        return new StateMachineFactory<OPERAND, STATE, EVENTTYPE, EVENT>
            (this,
             new ApplicableSingleOrMultipleTransition<OPERAND, STATE, EVENTTYPE, EVENT>
               (preState, eventType, new MultipleInternalArc(postStates, hook)));
      }

# 五. SingleArcTransition & MultipleInternalArc #

SingleArcTransition 和 MultipleInternalArc都实现了Transition接口. 是具体状态的实现类.  
Transition的具体实现类只负责接收到事件后的具体操作或行为，并没有包含状态相关的信息，所以在状态机执行状态过渡时，并不是直接调用SingleArcTransition具体实现类的transition方法，而是由接口Transition定义doTransition方法实现真正的转态过渡（包括行为和状态改变）。

// SingleInternalArc 和 MultipleInternalArc 实现Transition的接口
      // Transition接口中定义了doTransition来定义State的转换
      private interface Transition<OPERAND, STATE extends Enum<STATE>,
              EVENTTYPE extends Enum<EVENTTYPE>, EVENT> { 
        STATE doTransition(OPERAND operand, STATE oldState,
                           EVENT event, EVENTTYPE eventType);
      }

## 5.1. SingleInternalArc ##

用来处理一个状态被一个事件触发之后转移到下一个状态的 .

该类有两个属性，分别为表示STATE的postState属性和表示事件发生之后调用对应hook进行处理的SingleArcTransition属性。

该类只有一个doTransition方法，该方法中会调用hook.transition去处理发生该事件之后的状态变化，hook正常处理结束之后，返回postState状态。

// SingleInteralArc 实现了Transition，
      // 用来处理一个状态被一个事件触发之后转移到下一个状态
      //
      // 有转换之后的状态postState和SingleArcTransition类型的转换，
      // 在SingleInternalArc中的doTransition方法返回了转换之后的状态。
      private class SingleInternalArc
                        implements Transition<OPERAND, STATE, EVENTTYPE, EVENT> { 
    
        //后续的状态
        private STATE postState;
    
        // 表示事件发生之后调用对应hook进行处理的SingleArcTransition属性。
        private SingleArcTransition<OPERAND, EVENT> hook; // transition hook
    
        SingleInternalArc(STATE postState,
            SingleArcTransition<OPERAND, EVENT> hook) { 
          this.postState = postState;
          this.hook = hook;
        }
    
        // 调用hook.transition去处理发生该事件之后的状态变化，
        // hook正常处理结束之后，返回postState状态。
        @Override
        public STATE doTransition(OPERAND operand, STATE oldState,
                                  EVENT event, EVENTTYPE eventType) { 
          if (hook != null) { 
            hook.transition(operand, event);
          }
          return postState;
        }
      }

## 5.2. MultipleInternalArc ##

由于MultipleArcTransition的具体实现类只负责接收到事件后的具体操作或行为，并没有包含状态相关的信息，所以在状态机执行状态过渡时，并不是直接调用MultipleArcTransition具体实现类的transition方法，而是通过代理类MultipleInternalArc  
MultipleInternalArc也实现了Transition接口，并在代理 MultipleArcTransition 的转换行为的同时，负责状态变换.

MultipleInternalArc类，其逻辑结构和SingleInternalArc类似，只是在hook处理结束之后，判断下postState是否在备选的状态集中.

// MultipleInternalArc
      private class MultipleInternalArc  implements Transition<OPERAND, STATE, EVENTTYPE, EVENT>{ 
    
        // Fields
        // 存储可供选择的postState状态
        private Set<STATE> validPostStates;
    
        // // 事件对应的hook
        private MultipleArcTransition<OPERAND, EVENT, STATE> hook;  // transition hook
    
        MultipleInternalArc(Set<STATE> postStates,
                       MultipleArcTransition<OPERAND, EVENT, STATE> hook) { 
          this.validPostStates = postStates;
          this.hook = hook;
        }
    
        @Override
        public STATE doTransition(OPERAND operand, STATE oldState,
                                  EVENT event, EVENTTYPE eventType)
            throws InvalidStateTransitionException { 
    
    
          STATE postState = hook.transition(operand, event);
    
          // 校验postState是否在可选的状态集中
          if (!validPostStates.contains(postState)) { 
            throw new InvalidStateTransitionException(oldState, eventType);
          }
          return postState;
        }
      }

# 六. ApplicableTransition #

为了将所有状态机中的状态过渡与状态建立起映射关系，YARN中提供了ApplicableTransition接口用于将SingleInternalArc和 MultipleInternalArc 添加到状态机的拓扑表中，提高在检索状态对应的过渡实现时的性能.

## 6.1.ApplicableTransition接口定义 ##

// ApplicableTransition是一个接口，有一个apply方法
      private interface ApplicableTransition
                 <OPERAND, STATE extends Enum<STATE>,
                  EVENTTYPE extends Enum<EVENTTYPE>, EVENT> { 
        void apply(StateMachineFactory<OPERAND, STATE, EVENTTYPE, EVENT> subject);
      }

## 6.2.ApplicableSingleOrMultipleTransition ##

ApplicableTransition的实现类为ApplicableSingleOrMultipleTransition类，其apply方法用于代理SingleInternalArc和MultipleInternalArc ，将它们添加到状态拓扑表中。  
ApplicableSingleOrMultipleTransition主要是将preState、eventType和transition的映射关系放入stateMachineTable属性中。

// 主要是将preState、eventType和transition的映射关系放入stateMachineTable属性中。
      static private class ApplicableSingleOrMultipleTransition
                 <OPERAND, STATE extends Enum<STATE>,
                  EVENTTYPE extends Enum<EVENTTYPE>, EVENT>
              implements ApplicableTransition<OPERAND, STATE, EVENTTYPE, EVENT> { 
        final STATE preState;
        final EVENTTYPE eventType;
        final Transition<OPERAND, STATE, EVENTTYPE, EVENT> transition;
    
        ApplicableSingleOrMultipleTransition
            (STATE preState, EVENTTYPE eventType,
             Transition<OPERAND, STATE, EVENTTYPE, EVENT> transition) { 
          this.preState = preState;
          this.eventType = eventType;
          this.transition = transition;
        }
    
        @Override
        public void apply  (StateMachineFactory<OPERAND, STATE, EVENTTYPE, EVENT> subject) { 
    
          // 从stateMachineTable中拿到preState对应的transitionMap
          Map<EVENTTYPE, Transition<OPERAND, STATE, EVENTTYPE, EVENT>> transitionMap = subject.stateMachineTable.get(preState);
    
          // transitionMap为null则new一个transitionMap的HashMap
          if (transitionMap == null) { 
            // I use HashMap here because I would expect most EVENTTYPE's to not
            // apply out of a particular state, so FSM sizes would be 
            // quadratic if I use EnumMap's here as I do at the top level.
            transitionMap = new HashMap<EVENTTYPE, Transition<OPERAND, STATE, EVENTTYPE, EVENT>>();
            // 更新前置节点的 preState, transitionMap
            subject.stateMachineTable.put(preState, transitionMap);
          }
          // 将eventType对应的Transition放入transitionMap中
          transitionMap.put(eventType, transition);
        }
      }

# 七. installTopology 构建拓扑图 #

StateMachineFactory使用installTopology构建拓扑图:

/** * @return a StateMachineFactory just like {@code this}, except that if * you won't need any synchronization to build a state machine * * Note that the returned StateMachineFactory is a distinct object. * * This method is part of the API. * * The only way you could distinguish the returned * StateMachineFactory from {@code this} would be by * measuring the performance of the derived * {@code StateMachine} you can get from it. * * Calling this is optional. It doesn't change the semantics of the factory, * if you call it then when you use the factory there is no synchronization. * * 调用installTopology进行状态链的初始化。 * */
      public StateMachineFactory<OPERAND, STATE, EVENTTYPE, EVENT> installTopology() { 
        // 实例化了一个新的StateMachineFactory，不同的是将属性optimized设置为true。
        // 当optimized为true是，会在构造函数中调用makeStateMachineTable对stateMachineTable进行赋值。
        return new StateMachineFactory<OPERAND, STATE, EVENTTYPE, EVENT>(this, true);
      }

# 八. makeStateMachineTable 构建状态表 #

private void makeStateMachineTable() { 
        // 声明一个stack数据结构，用来存储TransitionsListNode链中的TransitionsListNode
        // 之所以用stack，是因为TransitionsListNode链是按照状态转移的逆序排列的
        // 也就是说TransitionsListNode链中的第一个是状态转移中最后一个状态对应的ApplicableSingleOrMultipleTransition
        Stack<ApplicableTransition<OPERAND, STATE, EVENTTYPE, EVENT>> stack = new Stack<ApplicableTransition<OPERAND, STATE, EVENTTYPE, EVENT>>();
    
        Map<STATE, Map<EVENTTYPE, Transition<OPERAND, STATE, EVENTTYPE, EVENT>>>
          prototype = new HashMap<STATE, Map<EVENTTYPE, Transition<OPERAND, STATE, EVENTTYPE, EVENT>>>();
    
        prototype.put(defaultInitialState, null);
    
        // I use EnumMap here because it'll be faster and denser. I would
        // expect most of the states to have at least one transition.
        stateMachineTable
           = new EnumMap<STATE, Map<EVENTTYPE,
                               Transition<OPERAND, STATE, EVENTTYPE, EVENT>>>(prototype);
    
    
        // 将TransitionsListNode链中的ApplicableSingleOrMultipleTransition入stack
        for (TransitionsListNode cursor = transitionsListNode;
             cursor != null;
             cursor = cursor.next) { 
          stack.push(cursor.transition);
        }
    
        // 将ApplicableSingleOrMultipleTransition出stack，
        // 调用apply对stateMachineTable进行赋值
        while (!stack.isEmpty()) { 
          stack.pop().apply(this);
        }
      }

> 1.创建堆栈stack，用于将transitionsListNode链表中各个节点持有的ApplicableSingleOrMultipleTransition压入栈中；

> 1.  创建状态拓扑表stateMachineTable，并在此拓扑表中插入一个额外的默认初始状态defaultInitialState与null的映射；

> 3.迭代访问transitionsListNode链表，并将各个节点持有的ApplicableSingleOrMultipleTransition压入栈中；

> 1.  依次弹出栈顶的ApplicableSingleOrMultipleTransition，并应用其apply方法（已在前面小节介绍），持续不断的构建状态拓扑表stateMachineTable。

# 九. InternalStateMachine #

状态机的具体实现类.

## 9.1. 属性 ##

// 操作
        private final OPERAND operand;
        // 当前状态
        private STATE currentState;
        // 监听器
        private final StateTransitionListener<OPERAND, EVENT, STATE> listener;

## 9.2. 构造函数 ##

InternalStateMachine(OPERAND operand, STATE initialState) { 
          this(operand, initialState, null);
        }
    
        InternalStateMachine(OPERAND operand, STATE initialState,
            StateTransitionListener<OPERAND, EVENT, STATE> transitionListener) { 
          this.operand = operand;
          this.currentState = initialState;
          this.listener =
              (transitionListener == null) ? NOOP_LISTENER : transitionListener;
          if (!optimized) { 
            maybeMakeStateMachineTable();
          }
        }

## 9.3. doTransition ##

针对事件类型和时间处理数据.

@Override
        public synchronized STATE doTransition(EVENTTYPE eventType, EVENT event)
             throws InvalidStateTransitionException  { 
    
          //监听 处理数据
          listener.preTransition(operand, currentState, event);
    
          STATE oldState = currentState;
    
          // 从stateMachineTable中得到当前state和eventType对应的transition，
          // 然后调用transition.doTransition方法，
          // 调用eventType对应的hook去执行相关逻辑。
          currentState = StateMachineFactory.this.doTransition
              (operand, currentState, eventType, event);
          listener.postTransition(operand, oldState, currentState, event);
          return currentState;
        }

# 十. 数据示例参考 #

数据示例请参考 : [Hadoop3.2.1 【 YARN 】源码分析 : StateMachineFactory解析\[二\]][Hadoop3.2.1 _ YARN _ _ StateMachineFactory]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70]: /images/20221120/4e0d4447afd240caab3207ba705fa7a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70 1]: /images/20221120/a287b49844f94cd1832dbf84db392ff5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70 2]: /images/20221120/dfebfa0838d943f491d2babe2358fbb3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20201228212037940.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20201228212058353.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0,size_16,color_FFFFFF,t_70
[Hadoop3.2.1 _ YARN _ _ StateMachineFactory]: https://zhangboyi.blog.csdn.net/article/details/111985352