Spark2源碼閱讀——Rpc心跳（3）

一. Spark 心跳概述

前面兩節中介紹了 Spark RPC 的基本知識，以及深入剖析了 Spark RPC 中一些源碼的實現流程。

具體可以看這裏：

• Spark RPC 框架源碼分析（二）運行時序
• Spark RPC 框架源碼分析（一）簡述

這一節我們來看看一個 Spark RPC 中的運用實例 -- Spark 的心跳機制。這次主要還是從代碼的角度來看。

image

我們首先要知道 Spark 的心跳有什麼用。心跳是分佈式技術的基礎，我們知道在 Spark 中，是有一個 Master 和衆多的 Worker，那麼 Master 怎麼知道每個 Worker 的情況呢，這就需要藉助心跳機制了。心跳除了傳輸信息，另一個主要的作用就是 Worker 告訴 Master 它還活着，當心跳停止時，方便 Master 進行一些容錯操作，比如數據轉移備份等等。

我們同樣分成兩部分來分析 Spark 的心跳機制，分爲服務端（Spark Context）和客戶端（Executor）。

二. Spark 心跳服務端 heartbeatReceiver 解析

我們可以發現，SparkContext 中有關於心跳的類以及 RpcEndpoint 註冊代碼。

class SparkContext(config: SparkConf) extends Logging {
    ......
    private var _heartbeatReceiver: RpcEndpointRef = _
    ......
    //向 RpcEnv 註冊 Endpoint。
    _heartbeatReceiver = env.rpcEnv.setupEndpoint(HeartbeatReceiver.ENDPOINT_NAME, new HeartbeatReceiver(this))
    ......
      val (sched, ts) = SparkContext.createTaskScheduler(this, master, deployMode)
    _schedulerBackend = sched
    _taskScheduler = ts
    _dagScheduler = new DAGScheduler(this)
    _heartbeatReceiver.ask[Boolean](TaskSchedulerIsSet)
    ......
}

這裏 rpcEnv 已經在上下文中創建好，通過 setupEndpoint 向 rpcEnv 註冊一個心跳的 Endpoint。還記得上一節中 HelloworldServer 的例子嗎，在 setupEndpoint 方法中，會去調用 Dispatcher 創建這個 Endpoint（這裏就是HeartbeatReceiver） 對應的 Inbox 和 EndpointRef ，然後在 Inbox 監聽是否有新消息，有新消息則處理它。註冊完會返回一個 EndpointRef （注意這裏有 Refer，即是客戶端，用來發送消息的）。

所以這一句

_heartbeatReceiver = env.rpcEnv.setupEndpoint(HeartbeatReceiver.ENDPOINT_NAME, new HeartbeatReceiver(this))

就已經完成了心跳服務端監聽的功能。
那麼這條代碼的作用呢？

_heartbeatReceiver.ask[Boolean](TaskSchedulerIsSet)

這裏我們要看上面那句 val (sched, ts) = SparkContext.createTaskScheduler(this, master, deployMode) ，它會根據 master url 創建 SchedulerBackend 和 TaskScheduler。這兩個類都是和資源調度有關的，所以需要藉助心跳機制來傳送消息。其中 TaskScheduler 負責任務調度資源分配，SchedulerBackend 負責與 Master、Worker 通信收集 Worker 上分配給該應用使用的資源情況。

這裏主要是告訴 HeartbeatReceiver（心跳） 的監聽端 ，告訴它 TaskScheduler 這個東西已經設置好啦。HeartbeatReceiver 就會迴應你說好的，我知道的，並持有這個 TaskScheduler。

到這裏服務端 heartbeatReceiver 就差不多完了，我們可以發現，HeartbeatReceiver 除了向 RpcEnv 註冊並監聽消息之外，還會去持有一些資源調度相關的類 ，比如 TaskSchedulerIsSet 。

三. Spark 心跳客戶端發送心跳解析

發送心跳發送在 Worker ，每個 Worker 都會有一個 Executor ，所以我們可以發現在 Executor 中發送心跳的代碼。

private[spark] class Executor(
    executorId: String,
    executorHostname: String,
    env: SparkEnv,
    userClassPath: Seq[URL] = Nil,
    isLocal: Boolean = false)
  extends Logging {
  ......
  // must be initialized before running startDriverHeartbeat()
  //創建心跳的 EndpointRef
  private val heartbeatReceiverRef = RpcUtils.makeDriverRef(HeartbeatReceiver.ENDPOINT_NAME, conf, env.rpcEnv)
  ......
  startDriverHeartbeater()
  ......
    /**
   * Schedules a task to report heartbeat and partial metrics for active tasks to driver.
   * 用一個 task 來報告活躍任務的信息以及發送心跳。
   */
  private def startDriverHeartbeater(): Unit = {
    val intervalMs = conf.getTimeAsMs("spark.executor.heartbeatInterval", "10s")

    // Wait a random interval so the heartbeats don't end up in sync
    val initialDelay = intervalMs + (math.random * intervalMs).asInstanceOf[Int]

    val heartbeatTask = new Runnable() {
      override def run(): Unit = Utils.logUncaughtExceptions(reportHeartBeat())
    }
    //heartbeater是一個單線程線程池，scheduleAtFixedRate 是定時執行任務用的，和 schedule 類似，只是一些策略不同。
    heartbeater.scheduleAtFixedRate(heartbeatTask, initialDelay, intervalMs, TimeUnit.MILLISECONDS)
  }
  ......
}

可以看到，在 Executor 中會創建心跳的 EndpointRef ，變量名爲 heartbeatReceiverRef 。

然後我們主要看 startDriverHeartbeater() 這個方法，它是關鍵。
我們可以看到最後部分代碼

    val heartbeatTask = new Runnable() {
      override def run(): Unit = Utils.logUncaughtExceptions(reportHeartBeat())
    }
    heartbeater.scheduleAtFixedRate(heartbeatTask, initialDelay, intervalMs, TimeUnit.MILLISECONDS)

heartbeatTask 是一個 Runaable，即一個線程任務。scheduleAtFixedRate 則是 java concurrent 包中用來執行定時任務的一個類，這裏的意思是每隔 10s 跑一次 heartbeatTask 中的線程任務，超時時間 30s 。

爲什麼到這裏還是沒看到 heartbeatReceiverRef 呢，說好的發送心跳呢？別急，其實在 heartbeatTask 線程任務中又調用了另一個方法，我們到裏面去一探究竟。

private[spark] class Executor(
    executorId: String,
    executorHostname: String,
    env: SparkEnv,
    userClassPath: Seq[URL] = Nil,
    isLocal: Boolean = false)
  extends Logging {
  ......
  private def reportHeartBeat(): Unit = {
    // list of (task id, accumUpdates) to send back to the driver
    val accumUpdates = new ArrayBuffer[(Long, Seq[AccumulatorV2[_, _]])]()
    val curGCTime = computeTotalGcTime()

    for (taskRunner <- runningTasks.values().asScala) {
      if (taskRunner.task != null) {
        taskRunner.task.metrics.mergeShuffleReadMetrics()
        taskRunner.task.metrics.setJvmGCTime(curGCTime - taskRunner.startGCTime)
        accumUpdates += ((taskRunner.taskId, taskRunner.task.metrics.accumulators()))
      }
    }

    val message = Heartbeat(executorId, accumUpdates.toArray, env.blockManager.blockManagerId)
    try {
      //終於看到 heartbeatReceiverRef 的身影了
      val response = heartbeatReceiverRef.askWithRetry[HeartbeatResponse](
          message, RpcTimeout(conf, "spark.executor.heartbeatInterval", "10s"))
      if (response.reregisterBlockManager) {
        logInfo("Told to re-register on heartbeat")
        env.blockManager.reregister()
      }
      heartbeatFailures = 0
    } catch {
      case NonFatal(e) =>
        logWarning("Issue communicating with driver in heartbeater", e)
        heartbeatFailures += 1
        if (heartbeatFailures >= HEARTBEAT_MAX_FAILURES) {
          logError(s"Exit as unable to send heartbeats to driver " +
            s"more than $HEARTBEAT_MAX_FAILURES times")
          System.exit(ExecutorExitCode.HEARTBEAT_FAILURE)
        }
    }
  }
  ......
  
}

可以看到，這裏 heartbeatReceiverRef 和我們上一節的例子， HelloworldClient 類似，核心也是調用了 askWithRetry() 方法，這個方法是通過同步的方式發送 Rpc 消息。而這個方法裏其他代碼其實就是獲取 task 的信息啊，或者是一些容錯處理。核心就是調用 askWithRetry() 方法來發送消息。

看到這你就明白了吧。Executor 初始化便會用一個定時任務不斷髮送心跳，同時當有 task 的時候，會獲取 task 的信息一併發送。這就是心跳的大概內容了。

OK，Spark RPC 三部曲完畢。如果你能看到這裏那不容易呀，給自己點個贊吧！！

作者：大數據_zzzzMing
鏈接：https://www.jianshu.com/p/6760acadedc9