spark streaming源码分析3 调度及运行

前面的两节内容介绍了StreamingContext的构造以及在此上的一系列操作。

通过调用start方法，真正开始调度执行。首先校验状态是否是INITIALIZED,然后调用JobScheduler的start方法，并将状态设置为ACTIVE。

看一下JobScheduler的start方法内部

[java] view plain copy

1. def start(): Unit = synchronized {  
2.     if (eventLoop != null) return // scheduler has already been started  
3.   
4.     logDebug("Starting JobScheduler")  
5.     eventLoop = new EventLoop[JobSchedulerEvent]("JobScheduler") {  
6.       override protected def onReceive(event: JobSchedulerEvent): Unit = processEvent(event)  
7.   
8.       override protected def onError(e: Throwable): Unit = reportError("Error in job scheduler", e)  
9.     }  
10.     eventLoop.start()  
11.   
12.     listenerBus.start(ssc.sparkContext)  
13.     receiverTracker = new ReceiverTracker(ssc)  
14.     inputInfoTracker = new InputInfoTracker(ssc)  
15.     receiverTracker.start()  
16.     jobGenerator.start()  
17.     logInfo("Started JobScheduler")  
18.   }  

1、首先构造一个事件类型为［JobSchedulerEvent］的循环器eventLoop（包含JobStarted，JobCompleted，ErrorReported三个事件），内部有一个线程实时获取队列中的事件，有则处理。实际调用如上的onReceive/onError方法。eventLoop.start后，内部线程真正运行起来，并等待事件的到来。 

2、构造ReceiverTracker

（1）从DStreamGraph中获取注册的ReceiverInputStreams

（2）获取所有ReceiverInputStreams的streamId

（3）构造一个ReceiverLauncher，它是一个接受器

（4）构造一个ReceivedBlockTracker，用于维护所有的接收器(receiver)接收到的所有block信息，即ReceivedBlockInfo

3、调用receiverTracker的start方法。

如果receiverInputStreams不为空，则建立akka RPC服务，名称为ReceiverTracker，负责注册Receiver、AddBlock、ReportError(报告错误)、注销Receiver四个事件

调用receiverExecutor的start方法，最终调用了startReceivers方法。

[java] view plain copy

1. /** 
2.      * Get the receivers from the ReceiverInputDStreams, distributes them to the 
3.      * worker nodes as a parallel collection, and runs them. 
4.      */  
5.     private def startReceivers() {  
6.       val receivers = receiverInputStreams.map(nis => {  
7.         val rcvr = nis.getReceiver()  
8.         rcvr.setReceiverId(nis.id)  
9.         rcvr  
10.       })  
11.   
12.       // Right now, we only honor preferences if all receivers have them  
13.       val hasLocationPreferences = receivers.map(_.preferredLocation.isDefined).reduce(_ && _)  
14.   
15.       // Create the parallel collection of receivers to distributed them on the worker nodes  
16.       val tempRDD =  
17.         if (hasLocationPreferences) {  
18.           val receiversWithPreferences = receivers.map(r => (r, Seq(r.preferredLocation.get)))  
19.           ssc.sc.makeRDD[Receiver[_]](receiversWithPreferences)  
20.         } else {  
21.           ssc.sc.makeRDD(receivers, receivers.size)  
22.         }  
23.   
24.       val checkpointDirOption = Option(ssc.checkpointDir)  
25.       val serializableHadoopConf = new SerializableWritable(ssc.sparkContext.hadoopConfiguration)  
26.   
27.       // Function to start the receiver on the worker node  
28.       val startReceiver = (iterator: Iterator[Receiver[_]]) => {  
29.         if (!iterator.hasNext) {  
30.           throw new SparkException(  
31.             "Could not start receiver as object not found.")  
32.         }  
33.         val receiver = iterator.next()  
34.         val supervisor = new ReceiverSupervisorImpl(  
35.           receiver, SparkEnv.get, serializableHadoopConf.value, checkpointDirOption)  
36.         supervisor.start()  
37.         supervisor.awaitTermination()  
38.       }  
39.       // Run the dummy Spark job to ensure that all slaves have registered.  
40.       // This avoids all the receivers to be scheduled on the same node.  
41.       if (!ssc.sparkContext.isLocal) {  
42.         ssc.sparkContext.makeRDD(1 to 50, 50).map(x => (x, 1)).reduceByKey(_ + _, 20).collect()  
43.       }  
44.   
45.       // Distribute the receivers and start them  
46.       logInfo("Starting " + receivers.length + " receivers")  
47.       running = true  
48.       ssc.sparkContext.runJob(tempRDD, ssc.sparkContext.clean(startReceiver))  
49.       running = false  
50.       logInfo("All of the receivers have been terminated")  
51.     }  

1）获取所有的receiver(接收器)

2）将receivers建立tempRDD,并分区并行化，每个分区一个元素，元素为receiver

3）创建方法startReceiver，该方法以分区元素(receiver)的迭代器作为参数,之后将该方法参数传入runJob中，针对每个分区，依次将每个分区中的元素(receiver)应用到该方法上

4）runJob的startReceiver方法。每个分区只有一个receiver，因此在该方法内构造一个ReceiverSupervisorImpl，在它内部真正的接收数据并保存。发送RegisterReceiver消息给dirver驱动。

重点介绍一下supervisor.start方法内部的逻辑实现：主要分为以下两个方法

[java] view plain copy

1. /** Start the supervisor */  
2.   def start() {  
3.     onStart()  
4.     startReceiver()  
5.   }  

（1）onStart方法：

[java] view plain copy

1. override protected def onStart() {  
2.     blockGenerator.start()  
3.   }  

1. 数据真正接收到是发生在SocketReceiver.receive函数中，将接收到的数据放入到BlockGenerator.currentBuffer
2. 在BlockGenerator中有一个重复定时器，处理函数为updateCurrentBuffer, updateCurrentBuffer将当前buffer中的数据封装为一个新的Block，放入到blocksForPush队列中
3. 同样是在BlockGenerator中有一个BlockPushingThread，其职责就是不停的将blocksForPushing队列中的成员通过pushArrayBuffer函数传递给blockmanager,让BlockManager将数据存储到MemoryStore中
4. pushArrayBuffer还会将已经由BlockManager存储的Block的id号传递给ReceiverTracker，ReceiverTracker会将存储的blockId放到对应StreamId的队列中

（2）startReceiver方法：

[java] view plain copy

1. /** Start receiver */  
2.   def startReceiver(): Unit = synchronized {  
3.     try {  
4.       logInfo("Starting receiver")  
5.       receiver.onStart()  
6.       logInfo("Called receiver onStart")  
7.       onReceiverStart()  
8.       receiverState = Started  
9.     } catch {  
10.       case t: Throwable =>  
11.         stop("Error starting receiver " + streamId, Some(t))  
12.     }  
13.   }  

1)receiver.onStart方法
建立socket连接，逐行读取数据，最终将数据插入BlockGenerator的currentBuffer中。一旦插入了数据，就触发了上面重复定时器。按设置的block生产间隔(默认200ms)，生成block，将block插入blocksForPushing队列中。然后，blockPushingThread线程逐个取出传递给blockmanager保存起来，同时通过AddBlock消息通知ReceiverTracker已经将哪些block存储到了blockmanager中。

2)onReceiverStart方法

向receiverTracker(位于driver端)发送RegisterReceiver消息，报告自己(receiver)启动了，目的是可以在UI中反馈出来。ReceiverTracker将每一个stream接收到但还没有进行处理的block放入到receiverInfo,其为一Hashmap. 在后面的generateJobs中会从receiverInfo提取数据以生成相应的RDD。

4、调用jobGenerator的start方法。

（1）首先构建JobGeneratorEvent类型事件的EventLoop，包含GenerateJobs,ClearMetadata,DoCheckpoint,ClearCheckpointData四个事件。并运行起来。

（2）调用startFirstTime启动generator

[java] view plain copy

1. /** Starts the generator for the first time */  
2.   private def startFirstTime() {  
3.     val startTime = new Time(timer.getStartTime())  
4.     graph.start(startTime - graph.batchDuration)  
5.     timer.start(startTime.milliseconds)  
6.     logInfo("Started JobGenerator at " + startTime)  
7.   }  

timer.getStartTime计算出来下一个周期的到期时间，计算公式：(math.floor(clock.currentTime.toDouble / period) + 1).toLong * period，以当前的时间/除以间隔时间，再用math.floor求出它的上一个整数（即上一个周期的到期时间点），加上1，再乘以周期就等于下一个周期的到期时间。

  (3) 启动DStreamGraph，调用graph.start方法，启动时间比startTime早一个时间间隔，为什么呢？求告知！！！

[java] view plain copy

1. def start(time: Time) {  
2.     this.synchronized {  
3.       if (zeroTime != null) {  
4.         throw new Exception("DStream graph computation already started")  
5.       }  
6.       zeroTime = time  
7.       startTime = time  
8.       outputStreams.foreach(_.initialize(zeroTime))//设置outputstream的zeroTime为time值  
9.       outputStreams.foreach(_.remember(rememberDuration))//如果设置过rememberDuration,则设置outputstream的rememberDuration为该值  
10.       outputStreams.foreach(_.validateAtStart)  
11.       inputStreams.par.foreach(_.start())  
12.     }  
13.   }  

 (4) 调用timer.start方法，参数为startTime

这里的timer为：

[java] view plain copy

1. private val timer = new RecurringTimer(clock, ssc.graph.batchDuration.milliseconds,  
2.     longTime => eventLoop.post(GenerateJobs(new Time(longTime))), "JobGenerator")  

内部包含一个定时器，每隔batchDuration的时间间隔就向eventLoop发送一个GenerateJobs消息，参数longTime为下一个间隔到来时的时间点

[java] view plain copy

1. /** 
2.  * Start at the given start time. 
3.  */  
4. def start(startTime: Long): Long = synchronized {  
5.   nextTime = startTime  
6.   thread.start()  
7.   logInfo("Started timer for " + name + " at time " + nextTime)  
8.   nextTime  
9. }  

通过内部的thread.start方法，触发timer内部的定时器运行。从而按时间间隔产生job。

5、GenerateJobs/ClearMetadata 事件处理介绍

JobGeneratorEvent类型事件的EventLoop，包含GenerateJobs,ClearMetadata,DoCheckpoint,ClearCheckpointData四个事件

 GenerateJobs：

[java] view plain copy

1. /** Generate jobs and perform checkpoint for the given `time`.  */  
2.   private def generateJobs(time: Time) {  
3.     // Set the SparkEnv in this thread, so that job generation code can access the environment  
4.     // Example: BlockRDDs are created in this thread, and it needs to access BlockManager  
5.     // Update: This is probably redundant after threadlocal stuff in SparkEnv has been removed.  
6.     SparkEnv.set(ssc.env)  
7.     Try {  
8.       jobScheduler.receiverTracker.allocateBlocksToBatch(time) // allocate received blocks to batch  
9.       graph.generateJobs(time) // generate jobs using allocated block  
10.     } match {  
11.       case Success(jobs) =>  
12.         val streamIdToInputInfos = jobScheduler.inputInfoTracker.getInfo(time)  
13.         val streamIdToNumRecords = streamIdToInputInfos.mapValues(_.numRecords)  
14.         jobScheduler.submitJobSet(JobSet(time, jobs, streamIdToNumRecords))  
15.       case Failure(e) =>  
16.         jobScheduler.reportError("Error generating jobs for time " + time, e)  
17.     }  
18.     eventLoop.post(DoCheckpoint(time, clearCheckpointDataLater = false))  
19.   }  

（1）allocateBlocksToBatch：首先根据time的值获取之前receiver接收到的并且通过AddBlock消息传递给receiverTracker的block元数据信息。并且将time对应的blocks信息映射保存起来。

那么，这里的time是怎么和每200ms间隔产生blocks对应起来的呢？答案就是time时间到后，将所有接收到但还未分配的blocks都划为这个time间隔内的。

（2）generateJobs：根据一个outputStream生成一个job，最终每个outputStream都调用如下的方法，见下面代码注释

注：这里的generateJob实际调用的是根据outputStream重载的方法，比如print的方法是输出一些值：

[java] view plain copy

1. override def generateJob(time: Time): Option[Job] = {  
2.     parent.getOrCompute(time) match {<span style="font-family: Tahoma, 'Microsoft Yahei', Simsun;">//这里实际是手动调用了ReceiverInputDStream的compute方法，产生一个RDD，确切的说是BlockRDD。见下面介绍</span>  
3.       case Some(rdd) =>  
4.         val jobFunc = () => createRDDWithLocalProperties(time) {  
5.           ssc.sparkContext.setCallSite(creationSite)  
6.           foreachFunc(rdd, time)<span style="font-family: Tahoma, 'Microsoft Yahei', Simsun;">//这里将上面的到的BlockRDD和一个在每个分区上执行的方法封装成一个jobFunc，在foreachFunc方法内部通过runJob提交任务获得输出的值，从而输出</span>  
7.         }  
8.         Some(new Job(time, jobFunc))<span style="font-family: Tahoma, 'Microsoft Yahei', Simsun;">//</span><span style="font-family: Tahoma, 'Microsoft Yahei', Simsun;">将time和jobFunc再次封装成Job，返回，等待被调度执行</span>  
9.       case None => None  
10.     }  
11.   }  

这里需要解释一下ReceiverInputDStream的compute方法

1）首先根据time值将之前映射的blocks元数据信息获取出来

2) 获取这些blocks的blockId，blockId其实就是streamId＋唯一值，这个唯一值可以保证在一个流里面产生的唯一的Id

3）将这个batchTime时间内的blocks元信息汇总起来，保存到inputInfoTracker中

4）将sparkContext和blockIds封装成BlockRDD返回

至此，Job已经产生了。如果Job产生成功，就走Case Success(Jobs) =>分支

[java] view plain copy

1. jobScheduler.submitJobSet(JobSet(time, jobs, streamIdToNumRecords))  

主要是根据time，jobs，以及streamId和每个streamId的记录数的映射封装成JobSet，调用submitJobSet

[java] view plain copy

1. def submitJobSet(jobSet: JobSet) {  
2.     if (jobSet.jobs.isEmpty) {  
3.       logInfo("No jobs added for time " + jobSet.time)  
4.     } else {  
5.       listenerBus.post(StreamingListenerBatchSubmitted(jobSet.toBatchInfo))  
6.       jobSets.put(jobSet.time, jobSet)  
7.       jobSet.jobs.foreach(job => jobExecutor.execute(new JobHandler(job)))  
8.       logInfo("Added jobs for time " + jobSet.time)  
9.     }  
10.   }  

可以看到，将jobSet保存到jobSets这样一个映射结构当中，然后将每个job通过JobHandler封装之后，通过一个线程调用运行起来。这个线程就是通过“spark.streaming.concurrentJobs”参数设置的一个线程池，默认是1。

接着看JobHandler被线程处理时的逻辑，见代码注释：

[java] view plain copy

1. private class JobHandler(job: Job) extends Runnable with Logging {  
2.     def run() {  
3.       ssc.sc.setLocalProperty(JobScheduler.BATCH_TIME_PROPERTY_KEY, job.time.milliseconds.toString)  
4.       ssc.sc.setLocalProperty(JobScheduler.OUTPUT_OP_ID_PROPERTY_KEY, job.outputOpId.toString)  
5.       try {  
6.         eventLoop.post(JobStarted(job))//这里主要是设置这个job所处的jobset的processingStartTime为当时时刻  
7.         // Disable checks for existing output directories in jobs launched by the streaming  
8.         // scheduler, since we may need to write output to an existing directory during checkpoint  
9.         // recovery; see SPARK-4835 for more details.  
10.         PairRDDFunctions.disableOutputSpecValidation.withValue(true) {  
11.           job.run()//这里的run方法就是调用了封装Job时的第二个参数，一个方法参数，就是上面的jobFunc  
12.         }  
13.         eventLoop.post(JobCompleted(job))//如果这个job所处的jobset都完成了，就设置processingEndTime，并向时间循环器发送ClearMetadata消息，后续讲解  
14.       } finally {  
15.         ssc.sc.setLocalProperty(JobScheduler.BATCH_TIME_PROPERTY_KEY, null)  
16.         ssc.sc.setLocalProperty(JobScheduler.OUTPUT_OP_ID_PROPERTY_KEY, null)  
17.       }  
18.     }  
19.   }  

ClearMetadata：

当一个jobset完成后，就会处理ClearMetadata消息

1、根据time的时间，过滤出在time之前的rdd，如果设置了rememberDuration，则过滤出小于（time－rememberDuration）的rdd

2、将过滤出的rdd调用unpersist

3、删除在blockManager中的block

4、根据dependencies关系链依次删除，从outputStream开始，根据链路依次进行

5、删除其它内存纪录信息

至此，关于spark stream最重要的部分，调度及运行就分析结束了！

转载： http://blog.csdn.net/yueqian_zhu/article/details/49023383