• Flink 1.13 源码解析——JobManager启动流程概览

    点击这里查看 Flink 1.13 源码解析 目录汇总

    点击查看相关章节：Flink 1.13 源码解析——JobManager启动流程 WebMonitorEndpoint启动

    点击查看相关章节：Flink 1.13 源码解析——JobManager启动流程之ResourceManager启动

    点击查看相关章节：Flink 1.13 源码解析——JobManager启动流程之Dispatcher启动

    目录

    一、基础概念

    二、JobManager启动源码分析

    2.1、启动流程概述

    2.2、启动流程源码分析

    2.2.1 主节点准备工作分析

    2.2.2 主节点启动过程分析

    一、基础概念

            在开始分析Flink JobManager启动之前流程之前，我们需要了解一些重要的概念。

            关于Flink的主节点JobManager，他只是一个逻辑上的主节点，针对不同的部署模式，主节点的实现类也不同

            JobManager（逻辑）有三大核心内容，分别为ResourceManager、Dispatcher和WebmonitorEndpoin：

    ResourceManager：

            Flink集群的资源管理器，只有一个，关于Slot的管理和申请等工作，都有它负责

    Dispatcher：

            1、负责接收用户提交的JobGraph，然后启动一个JobMaster，蕾西与Yarn中的AppMaster和Spark中的Driver。

            2、内有一个持久服务：JobGraphStore，负责存储JobGraph。当构建执行图或物理执行图时主节点宕机并恢复，则可以从这里重新拉取作业JobGraph

    WebMonitorEndpoint：

            Rest服务，内部有一个Netty服务，客户端的所有请求都由该组件接收处理

    用一个例子来描述这三个组件的功能：

            当Client提交一个Job到集群时（Client会把Job构建成一个JobGraph），主节点接收到提交的job的Rest请求后，WebMonitorEndpoint 会通过Router进行解析找到对应的Handler来执行处理，处理完毕后交由Dispatcher，Dispatcher负责大气JobMaster来负责这个Job内部的Task的部署执行，执行Task所需的资源，JobMaster向ResourceManager申请。 

    在了解完以上的核心概念后，我们开始本章的核心内容，JobManager的启动过程！

    二、JobManager启动源码分析

    2.1、启动流程概述

            JobManager的启动流程分为三大部分，分别为：

    • 初始化8个基础服务
    • 创建工厂实例
    • 通过不同的工厂实例创建三大核心组件ResourceManager、Dispatcher、WebMonitorEndpoint

            在第一步初始化基础服务中，完成了以下基础服务的初始化

    1. // 初始化和启动 AkkaRpcService，内部其实包装了一个 ActorSystem
    2. commonRpcService = AkkaRpcServiceUtils.createRemoteRpcService(...)
    3. // 启动一个 JMXService，用于客户端链接 JobManager JVM 进行监控
    4. JMXService.startInstance(configuration.getString(JMXServerOptions.JMX_SERVER_PORT);
    5. // 初始化一个负责 IO 的线程池
    6. ioExecutor = Executors.newFixedThreadPool(...)
    7. // 初始化 HA 服务组件，负责 HA 服务的是：ZooKeeperHaServices
    8. haServices = createHaServices(configuration, ioExecutor);
    9. // 初始化 BlobServer 服务端
    10. blobServer = new BlobServer(configuration, haServices.createBlobStore());
    11. blobServer.start();
    12. // 初始化心跳服务组件, heartbeatServices = HeartbeatServices
    13. heartbeatServices = createHeartbeatServices(configuration);
    14. // 启动 metrics（性能监控） 相关的服务，内部也是启动一个 ActorSystem
    15. MetricUtils.startRemoteMetricsRpcService(configuration,
    16. commonRpcService.getAddress());
    17. // 初始化一个用来存储 ExecutionGraph 的 Store, 实现是：
    18. FileArchivedExecutionGraphStore
    19. archivedExecutionGraphStore = createSerializableExecutionGraphStore(...)

            在第二步创建工厂中,内部创建了三个重要的工厂:

            1、DispatcherRunner工厂(DispatcherRunnerFactory)，默认实现：DefaultDispatcherRunnerFactory，生产 DefaultDispatcherRunner

            2、ResourceManager工厂(ResourceManagerFactory)，默认实现：StandaloneResourceManagerFactory，生产 StandaloneResourceManager

            3、WebMonitorEndpoint工厂(RestEndpointFactory)，默认实现：SessionRestEndpointFactory，生产 DispatcherRestEndpoint

            在第三步中，根据不同的工厂类创建出来三个核心组件：

            1、DispatcherRunner，实现是：DefaultDispatcherRunner

            2、ResourceManager，实现是：StandaloneResourceManager

            3、WebMonitorEndpoint，实现是：DispatcherRestEndpoint

    了解完总体流程之后，我们来看代码实现！

    2.2、启动流程源码分析

    2.2.1 主节点准备工作分析

    首先根据flink-damen脚本确定主节点启动类为 StandaloneSessionClusterEntrypoint（本次源码解析我们以Standalong模式进行） ，我们去看这个类

    1. public class StandaloneSessionClusterEntrypoint extends SessionClusterEntrypoint {
    2.  
    3.     public StandaloneSessionClusterEntrypoint(Configuration configuration) {
    4.         super(configuration);
    5.     }
    6.  
    7.     @Override
    8.     protected DefaultDispatcherResourceManagerComponentFactory
    9.             createDispatcherResourceManagerComponentFactory(Configuration configuration) {
    10.         return DefaultDispatcherResourceManagerComponentFactory.createSessionComponentFactory(
    11.                 StandaloneResourceManagerFactory.getInstance());
    12.     }
    13.  
    14.     public static void main(String[] args) {
    15.         // startup checks and logging
    16.         EnvironmentInformation.logEnvironmentInfo(
    17.                 LOG, StandaloneSessionClusterEntrypoint.class.getSimpleName(), args);
    18.         SignalHandler.register(LOG);
    19.         JvmShutdownSafeguard.installAsShutdownHook(LOG);
    20.  
    21.         // TODO 1. 解析flink run。。。的命令参数，如Flink 作业jar的入口类等等
    22.         final EntrypointClusterConfiguration entrypointClusterConfiguration =
    23.                 ClusterEntrypointUtils.parseParametersOrExit(
    24.                         args,
    25.                         new EntrypointClusterConfigurationParserFactory(),
    26.                         StandaloneSessionClusterEntrypoint.class);
    27.  
    28.         // TODO 2. 解析flink-conf.yaml 配置文件
    29.         Configuration configuration = loadConfiguration(entrypointClusterConfiguration);
    30.  
    31.         // TODO 3. 创建主节点
    32.         StandaloneSessionClusterEntrypoint entrypoint =
    33.                 new StandaloneSessionClusterEntrypoint(configuration);
    34.  
    35.         // TODO 4. 启动主节点
    36.         ClusterEntrypoint.runClusterEntrypoint(entrypoint);
    37.     }
    38. }

    在这个入口类里主要做了4件事：

    1、解析提交作业命令的参数

    2、解析flink-conf.yaml配置文件

    3、创建主节点

    4、启动主节点

    首先我们来看解析Flink-conf.yaml的过程，进入到loadConfiguration方法里

    1.  public static Configuration loadConfiguration(
    2.             final String configDir, @Nullable final Configuration dynamicProperties) {
    3.  
    4.         if (configDir == null) {
    5.             throw new IllegalArgumentException(
    6.                     "Given configuration directory is null, cannot load configuration");
    7.         }
    8.  
    9.         final File confDirFile = new File(configDir);
    10.         if (!(confDirFile.exists())) {
    11.             throw new IllegalConfigurationException(
    12.                     "The given configuration directory name '"
    13.                             + configDir
    14.                             + "' ("
    15.                             + confDirFile.getAbsolutePath()
    16.                             + ") does not describe an existing directory.");
    17.         }
    18.  
    19.         // get Flink yaml configuration file
    20.         // TODO 读取flink-conf.yaml文件
    21.         final File yamlConfigFile = new File(confDirFile, FLINK_CONF_FILENAME);
    22.  
    23.         // 文件不存在则报错
    24.         if (!yamlConfigFile.exists()) {
    25.             throw new IllegalConfigurationException(
    26.                     "The Flink config file '"
    27.                             + yamlConfigFile
    28.                             + "' ("
    29.                             + yamlConfigFile.getAbsolutePath()
    30.                             + ") does not exist.");
    31.         }
    32.         // TODO 解析flink-conf.yaml文件
    33.         Configuration configuration = loadYAMLResource(yamlConfigFile);
    34.  
    35.         if (dynamicProperties != null) {
    36.             configuration.addAll(dynamicProperties);
    37.         }
    38.  
    39.         return configuration;
    40.     }

    在方法里，首先根据conf路径将文件读进来，在通过loadYAMLResource()方法解析文件中的配置，并将configuration返回出去。

    接下来我们看本章节中最最最最重要的部分——主节点的启动过程

    2.2.2 主节点启动过程分析

    我们点进ClusterEntrypoint.runClusterEntrypoint(entrypoint)方法里：

    1. final String clusterEntrypointName = clusterEntrypoint.getClass().getSimpleName();
    2.         try {
    3.             // TODO 启动主类
    4.             clusterEntrypoint.startCluster();
    5.         } catch (ClusterEntrypointException e) {
    6.             LOG.error(
    7.                     String.format("Could not start cluster entrypoint %s.", clusterEntrypointName),
    8.                     e);
    9.             System.exit(STARTUP_FAILURE_RETURN_CODE);
    10.         }

    再点进startCluster方法里，看这段代码，再进入runCluster方法

    1. SecurityContext securityContext = installSecurityContext(configuration);
    2.  
    3. securityContext.runSecured(
    4.         (Callable)
    5.          () -> {
    6.                runCluster(configuration, pluginManager);
    7.                return null;
    8.                  });

    现在我们来到主节点启动的核心方法runCluster。在runCLuster方法里，主要做了三个重要的工作：

    1、初始化了主节点对外提供服务的时候所需要的三大核心组件启动时所需的基础服务。

    2、初始化了一个DispatcherResourceManagerComponentFactory 工厂实例， 内部初始化了三大核心组件的工厂实例。

    3、根据工厂类和基础环境，创建三大核心组件。

    首先我们来看第一步，初始化8大基础服务：

    1. /*
    2.             TODO 初始化了主节点对外提供服务的时候所需要的三大核心组件启动时所需的基础服务
    3.              1. commonRPCService：  基于Akka的RpcService实现。内部包装了ActorSystem
    4.              2. JMXService：        启动一个JMXService
    5.              3. ioExecutor：        启动一个线程池
    6.              4. haServices：        提供对高可用性所需的所有服务的访问注册，分布式计数器和领导人选举
    7.              5. blobServer：        负责侦听传入的请求生成线程来处理这些请求 。它还负责创建要存储的目录结构blob或临时缓存目录
    8.              6. heartbeatServices： 提供心跳所需的所有服务，这包括创建心跳接收器和心跳发送者。
    9.              7. metricRegistry：    跟踪所有已注册的Metric，他作为连接MetricGroup和MetricReporter
    10.              8. archivedExecutionGraphStore：存储执行图ExecutionGraph的可序列化形式。
    11.              */
    12.             initializeServices(configuration, pluginManager);

    点进initializeServices方法内，我们可以看到都初始化了哪些服务

    分别是：

    1. commonRPCService：

    基于Akka的RpcService实现。内部包装了ActorSystem，这个服务其实就是一个tcp的Rpc服务，端口为：6123

    2. JMXService：

    启动一个JMXService，用于客户端连接JobManager JVM监控

    3. ioExecutor：

    启动一个线程池，大小为当前节点cpu核心数*4

    4. haServices：

    初始化一个基于Zookeeper的HA服务—ZookeeperHaServices ，提供对高可用性所需的所有服务的访问注册，分布式计数器和领导人选举

    5. blobServer：

    初始化大文件存储BlobServer服务端，所谓大文件例如上传Flink-job的jar时所依赖的一些需要一起上传的jar，或者TaskManager上传的log文件等

    6. heartbeatServices：

    提供心跳所需的所有服务，这包括创建心跳接收器和心跳发送者。

    7. metricRegistry：

    启动Metric（性能监控） 相关服务，内部也是启动一个ActorSystem ，跟踪所有已注册的Metric，他作为连接MetricGroup和MetricReporter

    8. archivedExecutionGraphStore：

    存储执行图ExecutionGraph的可序列化形式。注意此处并不是JobGraphStore，JobGraphStore会在Dispatcher启动时启动。

    1.     protected void initializeServices(Configuration configuration, PluginManager pluginManager)
    2.             throws Exception {
    3.  
    4.         LOG.info("Initializing cluster services.");
    5.  
    6.         synchronized (lock) {
    7.             // TODO 1.初始化和启动AkkaRpcService，内部包装了ActorSystem
    8.             // 创建一个AkkaRpc服务，基于Akka的RpcService实现。
    9.             // commonRpcService 是一个基于Akka的ActorSystem，其实就是一个tcp的Rpc服务，端口为：6123
    10.             commonRpcService =
    11.                     AkkaRpcServiceUtils.createRemoteRpcService(
    12.                             configuration,
    13.                             configuration.getString(JobManagerOptions.ADDRESS),
    14.                             getRPCPortRange(configuration),
    15.                             configuration.getString(JobManagerOptions.BIND_HOST),
    16.                             configuration.getOptional(JobManagerOptions.RPC_BIND_PORT));
    17.  
    18.             // TODO 2.启动了一个JMXService，用于客户端连接JobManager JVM监控
    19.             JMXService.startInstance(configuration.getString(JMXServerOptions.JMX_SERVER_PORT));
    20.  
    21.             // update the configuration used to create the high availability services
    22.             configuration.setString(JobManagerOptions.ADDRESS, commonRpcService.getAddress());
    23.             configuration.setInteger(JobManagerOptions.PORT, commonRpcService.getPort());
    24.  
    25.             // TODO 3.初始化IO线程池，大小为当前节点cpu核心数*4
    26.             // Flink有很多地方的代码都是异步编程
    27.             ioExecutor =
    28.                     Executors.newFixedThreadPool(
    29.                             ClusterEntrypointUtils.getPoolSize(configuration),
    30.                             new ExecutorThreadFactory("cluster-io"));
    31.  
    32.             // TODO 4.初始化一个基于Zookeeper的HA服务：ZookeeperHaServices
    33.             haServices = createHaServices(configuration, ioExecutor);
    34.             // TODO 5.初始化大文件存储BlobServer服务端，所谓大文件例如上传Flink-job的jar时所依赖的一些需要一起上传的jar，或者TaskManager上传的log文件等
    35.             blobServer = new BlobServer(configuration, haServices.createBlobStore());
    36.             blobServer.start();
    37.             // TODO 6.心跳服务
    38.             heartbeatServices = createHeartbeatServices(configuration);
    39.             // TODO 7.启动Metric（性能监控） 相关服务，内部也是启动一个ActorSystem
    40.             metricRegistry = createMetricRegistry(configuration, pluginManager);
    41.  
    42.             final RpcService metricQueryServiceRpcService =
    43.                     MetricUtils.startRemoteMetricsRpcService(
    44.                             configuration, commonRpcService.getAddress());
    45.             metricRegistry.startQueryService(metricQueryServiceRpcService, null);
    46.  
    47.             final String hostname = RpcUtils.getHostname(commonRpcService);
    48.  
    49.             processMetricGroup =
    50.                     MetricUtils.instantiateProcessMetricGroup(
    51.                             metricRegistry,
    52.                             hostname,
    53.                             ConfigurationUtils.getSystemResourceMetricsProbingInterval(
    54.                                     configuration));
    55.             // TODO 8.初始化一个用来存储ExecutionGraph的Store，实现是FileArchivedExecutionGraphStore
    56.             // JobGraphStore会在Dispatcher启动时启动
    57.             executionGraphInfoStore =
    58.                     createSerializableExecutionGraphStore(
    59.                             configuration, commonRpcService.getScheduledExecutor());
    60.         }
    61.     }

    这个方法里面基本都是从配置文件拿出配置，再赋给服务，没有很复杂很重要的工作，就不在赘述了，下面开始分析工厂类的构建过程

    第二步核心工厂类的构建：

    1.  /*
    2.             TODO 此处核心方法，初始化了一个DispatcherResourceManagerComponentFactory 工厂实例，
    3.              内部初始化了三大核心组件的工厂实例：
    4.              1. Dispatcher = DefaultDispatcherRunnerFactory，生产DefaultDispatcherRunner
    5.              2. ResourceManager = StandalongResourceManagerFactory， 生产StandalongResourceManager
    6.              3. WebMonitorEndpoint = SessionRestEndpointFactory，生产 DispatcherRestEndpoint
    8.              */
    9.             final DispatcherResourceManagerComponentFactory
    10.                     dispatcherResourceManagerComponentFactory =
    11.                             createDispatcherResourceManagerComponentFactory(configuration);

    在这个工厂内部,初始化了三大核心组件工厂实例:

    1. Dispatcher = DefaultDispatcherRunnerFactory，生产DefaultDispatcherRunner

    2. ResourceManager = StandalongResourceManagerFactory,生产StandalongResourceManager

    3. WebMonitorEndpoint = SessionRestEndpointFactory，生产 DispatcherRestEndpoint

    我们点进createDispatcherResourceManagerComponentFactory方法，找StandaloneSessionClusterEntrypoint的实现

    1.     @Override
    2.     protected DefaultDispatcherResourceManagerComponentFactory
    3.             createDispatcherResourceManagerComponentFactory(Configuration configuration) {
    4.         // 创建第一个工厂 StandaloneResourceManagerFactory
    5.         return DefaultDispatcherResourceManagerComponentFactory.createSessionComponentFactory(
    6.                 StandaloneResourceManagerFactory.getInstance());
    7.     }

    在这里通过StandaloneResourceManagerFactory.getInstance()，创建了第一个工厂StandaloneResourceManagerFactory

    我们进入createSessionComponentFactory方法来继续看剩下两个工厂的构建

    1.     public static DefaultDispatcherResourceManagerComponentFactory createSessionComponentFactory(
    2.             ResourceManagerFactory resourceManagerFactory) {
    3.         // TODO 构建工厂
    4.         return new DefaultDispatcherResourceManagerComponentFactory(
    5.                 // TODO 第二个工厂
    6.                 DefaultDispatcherRunnerFactory.createSessionRunner(
    7.                         SessionDispatcherFactory.INSTANCE),
    8.                 // TODO 第一个工厂
    9.                 resourceManagerFactory,
    10.  
    11.                 // TODO 第三个工厂
    12.                 SessionRestEndpointFactory.INSTANCE);
    13.     }

    代码很清楚很简洁，将ResourceManager的工厂和DispatcherRunner的工厂创建了出来。

    到此为止，主节点的三个核心组件的工厂类已经创建完毕，接下来我们来看三个核心组件

    第三步，创建ResourceManager、DispatcherRunner、WebMonitorEndpoint

    1.             /*
    2.             TODO 根据第一步中已创建基础服务，创建JobManager的三大核心角色实例
    3.             1. WebMonitorEndpoint：用于接受客户端发送的执行任务的Rest请求
    4.             2. resourceManager：负责资源的分配和记账
    5.             3. dispatcher：负责用于接收作业提交，持久化他们，生成要执行的作业管理器任务，并在主任务失败时恢复它们。
    6.              */
    7.             clusterComponent =
    8.                     dispatcherResourceManagerComponentFactory.create(
    9.                             configuration,
    10.                             ioExecutor,
    11.                             commonRpcService,
    12.                             haServices,
    13.                             blobServer,
    14.                             heartbeatServices,
    15.                             metricRegistry,
    16.                             executionGraphInfoStore,
    17.                             new RpcMetricQueryServiceRetriever(
    18.                                     metricRegistry.getMetricQueryServiceRpcService()),
    19.                             this);

    在这一步中，根据第二步创建的三个核心工厂实例，分别创建了WebMonitorEndpoint、ResourceManager以及DispatcherRunner。

    1、DispatcherRunner，实现是：DefaultDispatcherRunner

    2、ResourceManager，实现是：StandaloneResourceManager

    3、WebMonitorEndpoint，实现是：DispatcherRestEndpoint

    我们来看代码，首先进入create方法，在这个方法里完成了很多操作，我们来逐一分析。

    第一步、首先初始化了一些监控服务：

    1.   // TODO DefaultLeaderRetrievalService 监控 Dispatcher
    2.             dispatcherLeaderRetrievalService =
    3.                     highAvailabilityServices.getDispatcherLeaderRetriever();
    4.  
    5.             // TODO DefaultLeaderRetrievalService 监控 ResourceManager
    6.             resourceManagerRetrievalService =
    7.                     highAvailabilityServices.getResourceManagerLeaderRetriever();
    8.  
    9.             // TODO Dispatcher 的 GatewayRetriever
    10.             final LeaderGatewayRetriever dispatcherGatewayRetriever =
    11.                     new RpcGatewayRetriever<>(
    12.                             rpcService,
    13.                             DispatcherGateway.class,
    14.                             DispatcherId::fromUuid,
    15.                             new ExponentialBackoffRetryStrategy(
    16.                                     12, Duration.ofMillis(10), Duration.ofMillis(50)));
    17.  
    18.             // TODO ResourceManager 的 GatewayRetriever
    19.             final LeaderGatewayRetriever resourceManagerGatewayRetriever =
    20.                     new RpcGatewayRetriever<>(
    21.                             rpcService,
    22.                             ResourceManagerGateway.class,
    23.                             ResourceManagerId::fromUuid,
    24.                             new ExponentialBackoffRetryStrategy(
    25.                                     12, Duration.ofMillis(10), Duration.ofMillis(50)));

    第二步、构建了一个线程池用于执行WebMonitorEndpointEndpoint所接收到的client发送过来的请求

    1.  // TODO 创建线程池，用于执行WebMonitorEndpointEndpoint所接收到的client发送过来的请求
    2.  final ScheduledExecutorService executor =
    3.              WebMonitorEndpoint.createExecutorService(
    4.                    configuration.getInteger(RestOptions.SERVER_NUM_THREADS),
    5.                    configuration.getInteger(RestOptions.SERVER_THREAD_PRIORITY),
    6.                    "DispatcherRestEndpoint");

    第三步、初始化 MetricFetcher， 刷新间隔是10s

    1. // TODO 初始化 MetricFetcher， 间隔是10s
    2. final long updateInterval =
    3.         configuration.getLong(MetricOptions.METRIC_FETCHER_UPDATE_INTERVAL);
    4. final MetricFetcher metricFetcher =
    5.         updateInterval == 0
    6.                 ? VoidMetricFetcher.INSTANCE
    7.                 : MetricFetcherImpl.fromConfiguration(
    8.                         configuration,
    9.                         metricQueryServiceRetriever,
    10.                         dispatcherGatewayRetriever,
    11.                         executor);

    第四步、创建WebMonitorEndpoint实例，并启动，在Standalong模式下为：DispatcherRestEndpoint 该实例内部会启动一个Netty服务端，绑定了一堆Handler

    1.  /*
    2.  TODO 创建WebMonitorEndpoint实例，在Standalong模式下为：DispatcherRestEndpoint
    3.   该实例内部会启动一个Netty服务端，绑定了一堆Handler
    4.   */
    5.  webMonitorEndpoint =
    6.          restEndpointFactory.createRestEndpoint(
    7.                  configuration,
    8.                  dispatcherGatewayRetriever,
    9.                  resourceManagerGatewayRetriever,
    10.                  blobServer,
    11.                  executor,
    12.                  metricFetcher,
    13.                  highAvailabilityServices.getClusterRestEndpointLeaderElectionService(),
    14.                  fatalErrorHandler);
    15.  // TODO 启动WebMonitorEndpoint
    16.  log.debug("Starting Dispatcher REST endpoint.");
    17.  webMonitorEndpoint.start();

    第五步、创建ResourceManager对象，这里有三个要点：

    1. ResourceManager是一个RpcEndpoint(Actor),当构建好对象后启动时会触发onStart(Actor的perStart生命周期方法)方法

    2. ResourceManager也是一个LeaderContendr,也会执行竞选, 会执行竞选结果方法

    3. ResourceManagerService 具有两个心跳服务和两个定时服务:

            a. 两个心跳服务: 从节点 和 主节点之间的心跳 ，Job的主控程序 和 主节点之间的心跳

            b. 两个定时服务: TaskManager 的超时检查服务 Slot申请的 超时检查服务

    1. /*
    2. TODO 创建ResourceManager实例
    3.  三个要点:
    4.  1. ResourceManager是一个RpcEndpoint(Actor),当构建好对象后启动时会触发onStart(Actor的p
    5.  2. ResourceManager也是一个LeaderContendr,也会执行竞选, 会执行竞选结果方法
    6.  3. ResourceManagerService 具有两个心跳服务和两个定时服务:
    7.         两个心跳服务:
    8.             从节点  和   主节点之间的心跳
    9.             Job的主控程序 和 主节点之间的心跳
    10.         两个定时服务:
    11.             TaskManager 的超时检查服务
    12.             Slot申请的 超时检查服务
    13.  */
    14. resourceManager =
    15.         resourceManagerFactory.createResourceManager(
    16.                 configuration,
    17.                 ResourceID.generate(),
    18.                 rpcService,
    19.                 highAvailabilityServices,
    20.                 heartbeatServices,
    21.                 fatalErrorHandler,
    22.                 new ClusterInformation(hostname, blobServer.getPort()
    23.                 webMonitorEndpoint.getRestBaseUrl(),
    24.                 metricRegistry,
    25.                 hostname,
    26.                 ioExecutor);

    第六步、构建了一个DispatcherRunner，注意不是Dispatcher，Dispatcher的构建和启动是在DispatcherRunner内部实现的

    1. /*
    2. TODO 在该代码的内部会创建Dispatcher组件，并调用start() 方法启动
    3.  */
    4. dispatcherRunner =
    5.         dispatcherRunnerFactory.createDispatcherRunner(
    6.                 highAvailabilityServices.getDispatcherLeaderElectionService(),
    7.                 fatalErrorHandler,
    8.                 new HaServicesJobGraphStoreFactory(highAvailabilityServices),
    9.                 ioExecutor,
    10.                 rpcService,
    11.                 partialDispatcherServices);

    第七步、启动ResourceManager

    1. // TODO 启动ResourceManager
    2. log.debug("Starting ResourceManager.");
    3. resourceManager.start();

    到此为止，主节点（逻辑JobManager）已启动完毕

    到这里你们可能要问了，ResourceManager、WebMonitorEndpoint、Dispatcher具体的启动是怎么做的呢，由于涉及到的代码量太大，我在这里拆分为三章来分别解析这三大核心组件的构建过程。在下一章，我们就先来看看WebMonitorEndpoint是如何启动的！

  • 相关阅读:
    基于javaweb的宿舍管理系统（idea+servlet+jsp+jdbc）
    40. 组合总和 II
    Flutter页面状态保留策略
    一、Linux入门：购买服务器，与服务器建立连接
    2 开源鸿蒙OpenHarmony4.1源码下载和编译流程
    GEE遥感云大数据林业应用典型案例实践及GPT模型应用
    论文解读(GraphSMOTE)《GraphSMOTE: Imbalanced Node Classification on Graphs with Graph Neural Networks》
    lvs的工作模式
    .net-----Windows 窗体应用程序包括控件，对话框，多重窗体，绘制图形，菜单和工具栏
    python爬虫之爬取携程景点评价（5）
  • 原文地址：https://blog.csdn.net/EdwardWong_/article/details/126526013