JobScheduler内幕实现和深度思考(第七篇)

接着上一节我们看到了JobGenerator.generateJobs()方法：

private def generateJobs(time: Time) {
    // Set the SparkEnv in this thread, so that job generation code can access the environment
    // Example: BlockRDDs are created in this thread, and it needs to access BlockManager
    // Update: This is probably redundant after threadlocal stuff in SparkEnv has been removed.
    SparkEnv.set(ssc.env)
    Try {
      jobScheduler.receiverTracker.allocateBlocksToBatch(time) // allocate received blocks to batch
      graph.generateJobs(time) // generate jobs using allocated block
    } match {
      case Success(jobs) =>
        val streamIdToInputInfos = jobScheduler.inputInfoTracker.getInfo(time)
        jobScheduler.submitJobSet(JobSet(time, jobs, streamIdToInputInfos))
      case Failure(e) =>
        jobScheduler.reportError("Error generating jobs for time " + time, e)
    }
    eventLoop.post(DoCheckpoint(time, clearCheckpointDataLater = false))
  }

jobScheduler.submitJobSet方法：

def submitJobSet(jobSet: JobSet) {
    if (jobSet.jobs.isEmpty) {
      logInfo("No jobs added for time " + jobSet.time)
    } else {
      listenerBus.post(StreamingListenerBatchSubmitted(jobSet.toBatchInfo))
      jobSets.put(jobSet.time, jobSet)
      jobSet.jobs.foreach(job => jobExecutor.execute(new JobHandler(job)))
      logInfo("Added jobs for time " + jobSet.time)
    }
  }

由上我们可以看到：里会为每个job生成一个新的JobHandler，交给jobExecutor运行。jobScheduler会为每个Job生成一个JobHandler并交由jobExecutor以线程的方式去执行

而jobExecutor 是这样初始化的：

private val numConcurrentJobs = ssc.conf.getInt("spark.streaming.concurrentJobs", 1)
  private val jobExecutor =
    ThreadUtils.newDaemonFixedThreadPool(numConcurrentJobs, "streaming-job-executor")

由上我们可以看到通过设置参数：spark.streaming.concurrentJobs，可以动态的增加jobExecutor的并行度，尤其是当我们有多个输出的时候，这也是一个可以调优的地方

我们接着看JobHandler中提交Job的主要逻辑：

  var _eventLoop = eventLoop
        if (_eventLoop != null) {
          _eventLoop.post(JobStarted(job, clock.getTimeMillis()))
//上面这句主要用于记录Job的启动时间，并以事件方式推送eventLoop的队列中
          // Disable checks for existing output directories in jobs launched by the streaming
          // scheduler, since we may need to write output to an existing directory during checkpoint
          // recovery; see SPARK-4835 for more details.
          PairRDDFunctions.disableOutputSpecValidation.withValue(true) {
            job.run()   //真正的Job执行
          }
          _eventLoop = eventLoop
          if (_eventLoop != null) {
//上面这句主要用于记录Job的完成时间，并以事件方式推送eventLoop的队列中
            _eventLoop.post(JobCompleted(job, clock.getTimeMillis()))
          }

由上可以看到JobHandler除了做一些状态记录外，最主要的就是调用job.run()

我们在job.run()可以看到run方法中执行func()函数，而func()函数是Job初始化时转入进来的

def run() {
    _result = Try(func())
  }

而Job的产生是在JobGenerator的generateJobs方法中产生，而JobGenerator.generateJobs方法中又调用了DStreamGraph.generateJobs方法：

DStreamGraph.generateJobs：

 def generateJobs(time: Time): Seq[Job] = {
    logDebug("Generating jobs for time " + time)
    val jobs = this.synchronized {
      outputStreams.flatMap { outputStream =>
        val jobOption = outputStream.generateJob(time)
        jobOption.foreach(_.setCallSite(outputStream.creationSite))
        jobOption
      }
    }
    logDebug("Generated " + jobs.length + " jobs for time " + time)
    jobs
  }

这时候我们可以发现这块实际调用的是：outputStream.generateJob(time)，而outputStream本身就是一个DStream，而这个DStream从何而来呢？

下面我们有DStream的print方法进一步跟踪代码：

def print(num: Int): Unit = ssc.withScope {
    def foreachFunc: (RDD[T], Time) => Unit = {
      (rdd: RDD[T], time: Time) => {
        val firstNum = rdd.take(num + 1)
        // scalastyle:off println
        println("-------------------------------------------")
        println("Time: " + time)
        println("-------------------------------------------")
        firstNum.take(num).foreach(println)
        if (firstNum.length > num) println("...")
        println()
        // scalastyle:on println
      }
    }
    foreachRDD(context.sparkContext.clean(foreachFunc), displayInnerRDDOps = false)
  }

这时候我们发现print方法中封装了一个foreachFunc函数，我们接着看foreachRDD方法：

private def foreachRDD(
      foreachFunc: (RDD[T], Time) => Unit,
      displayInnerRDDOps: Boolean): Unit = {
    new ForEachDStream(this,
      context.sparkContext.clean(foreachFunc, false), displayInnerRDDOps).register()
  }

这时候我们发现有初始化了ForEachDStream，我们来看其主要方法，这这时候你可以会有似曾相识的感觉了

  override def generateJob(time: Time): Option[Job] = {
    parent.getOrCompute(time) match {
      case Some(rdd) =>
        val jobFunc = () => createRDDWithLocalProperties(time, displayInnerRDDOps) {
          foreachFunc(rdd, time)
        }
        Some(new Job(time, jobFunc))
      case None => None
    }
  }

这时候我们看到这儿也有一个generateJob方法，而且DStream中的print方法的函数foreachFunc最终传入到了ForEachDStream的generateJob中，这时候我们再联想DStreamGraph中执行的generateJob方法，这时候我们发现DStreamGraph方法实际上是执行了ForEachDStream.generateJob(DStream所有子类当中只有ForEachDStream实现了generateJob方法)，而上文看到的job.run()中的func()函数其本身中调用的是此处的foreachFunc方法(业务逻辑方法)

我们这块借用一位兄弟的一张图来阐明整个过程（该图出自：http://lqding.blog.51cto.com/9123978/1773391）：