Spark内核

一些名词概念

AM : ApplicationMaster
RM : ResourceManager
NM : NodeManager
Backend : 后台
RpcEnv : RPC 进程和进程的通信协议
RpcEndpoint ： 终端
 
constructor -> onStart -> receive* -> onStop
 
RpcEndpointRef ：终端引用
 
NettyRpcEnv
RpcEndpointAddress
NettyRpcEndpointRef
 
ThreadSafeRpcEndpoint
 
Inbox
 
BIO, NIO, AIO

以yarn-cluster模式为例源码分析作业提交流程

##spark-yarn-cluster模式
bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--num-executors 2 \
--master yarn \
--deploy-mode cluster \
./examples/jars/spark-examples_2.11-2.1.1.jar \
100

##spark-yarn-client模式
bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--num-executors 2 \
--master yarn \
--deploy-mode client \
./examples/jars/spark-examples_2.11-2.1.1.jar \
100

Spark-submit提交源码解析

执行spark-submit实际上执行的是$SPARK_HOME/spark-class -->执行一个java类  java  org.apache.spark.launcher.Main调它的main方法（它就是检查参数、构建CommandBuiler指令）--->最终真正要执行 这个类 org.apache.spark.deploy.SparkSubmit xxx是命令行参数，它就会启动一个叫SparkSubmit进程

SparkSubmit类，对命令行参数进行了封装，准备提交环境，不是集群模式它会拿到指令中的--class所传的类， if (isYarnCluster)-->> org.apache.spark.deploy.yarn.Client 

利用反射通过类名获取类的信息，利用反射通过类信息获取Main方法，调用Client的main方法： Client的调用只是一个普通方法的调用

根据yarn的配置进行初始化创建yarn客户端准备去跟yarn打交道（要有yarn的server集群）， yarnClient.start()启动客户端，获取一个appId,yarn的全局id，根据id可以查询它的所有信息；
 Client向yarn的RM提交应用, 集群模式通过submitApplication来完成，启动JAVA_HOME/bin/java org.apache.spark.deploy.yarn.ApplicationMaster这个进程类（主要是为了与Yarn做关联）

这些commands上边封装好的指令|类都提交给yarn，由yarn来执行，这时Client客户端就结束了；

spark-submit 它实际上调用的是"${SPARK_HOME}"/bin/spark-class org.apache.spark.deploy.SparkSubmit （java中的类）
   　　 spark-class中：   RUNNER="${JAVA_HOME}/bin/java"  ##执行java.exe-->类 -->相当于启动一个JVM -->就是启动一个进程Process（进程中有独立内存、线程）
                  　　  "$RUNNER" -Xmx128m -cp "$LAUNCH_CLASSPATH"(#就是类路径) org.apache.spark.launcher.Main <=>等同于执行Main这个类，调用main方法
                   　　 build_command()构建指令； 最终是要执行SparkSubmit ##className.equals("org.apache.spark.deploy.SparkSubmit")
org.apache.spark.launcher.Main   
org.apache.spark.deploy.SparkSubmit  --xx等参数

SparkSubmit类
 
          // 对命令行参数进行封装
    -- . new SparkSubmitArguments(args) //命令行参数包含master、deployMode、executorMemory等 ；在scala中，类{ 类体or构造函数体 }，参数中类体，类初始化时都会执行
    　　　　　　　　parse(args.asJava)类体中；parse方法做了正则的匹配 Pattern.compile("(--[^=]+)=(.+)") ==> handle (源码326)方法对传的命令行参数做模式匹配；
　　　　　　　　　　SparkSubmit类，appArgs.action.match{ SUBMIT| ... }模式匹配，action在SparkSubmitArguments做了封装  action = Option(action).getOrElse(SUBMIT)
    -- . submit（SparkSubmit中的方法）
               // 准备提交环境
        -- 2.1 prepareSubmitEnvironment
 
        -- 2.2 doRunMain（声明了但没有执行） isStandaloneCluster 和 其他模式都会走doRunMain方法
 
        -- 2.3 runMain(childArgs, childClasspath, sysProps, childMainClass, args.verbose)参数来自提交对环境准备  <--if (args.proxyUser != null)
 
            -- 2.3. ClassLoader : Thread.currentThread.setContextClassLoader(loader)  //loader类加载器，把类放到集群的节点上去执行；
 
                     // childMainClass（Client）  ： org.apache.spark.examples.SparkPi //不是集群模式它会拿到指令中的--class所传的类
                     // childMainClass（Clustor） ： org.apache.spark.deploy.yarn.Client  // if (isYarnCluster)集群模式
　　　　　　　　　　　　// 反射：通过类名获取类的信息
            -- 2.3. mainClass = Utils.classForName(childMainClass) //var mainClass: Class[_] = null,Class为类的全部信息；
                     // 反射：通过类信息获取Main方法
            -- 2.3. val mainMethod = mainClass.getMethod("main", new Array[String]().getClass)
                     // 反射：调用main方法
            -- 2.3. mainMethod.invoke(null, childArgs.toArray)
Client
　　　　　　Client的调用只是一个普通方法的调用；如果是进程：java Client=》JVM=》Process； 如果是线程：Thread.start() ； 普通方法调用: method.invoke
          // 对命令行参数进行封装
    -- . new ClientArguments(argStrings) //在main方法中 
 
    -- . new Client(args, sparkConf).run() //它会去调用辅助构造方法-->一定会会去调用主构造方法
    　　　　　　private val yarnClient = YarnClient.createYarnClient //它去创建yarn客户端准备去跟yarn打交道（要有yarn的server集群）
　　　　　　　　private val amMemory = if (isClusterMode) //ApplicationMaster的内存
　　　　　　　　  ...等等，主要是去构造属性、方法和对象
    -- . client.run //创建好了对象.run
        -- 3.1 submitApplication  //this.appId = submitApplication() 提交应用；
        　　　　　　launcherBackend.connect() //Backend叫后台
　　　　　　　　　　 yarnClient.init(yarnConf) 根据yarn的配置进行初始化； yarnClient.start()启动客户端 ，目的是与yarn做交互；
　　　　　　　　　　　appId = newAppResponse.getApplicationId()//获取一个appId,yarn的全局id，根据id可以查询它的所有信息；
　　　　　　　　　　　　yarnClient.submitApplication(appContext) //Client向yarn的RM提交应用，由submitApplication（抽象方法->实现类）来完成；
　　　　　　　　　　　　rmClient.submitApplication(request); //跟RM做关联
                // commands(Client)： JAVA_HOME/bin/java org.apache.spark.deploy.yarn.ExecutorLauncher //不是集群模式 Spark-shell只能是client模式，不能是集群！！
                // commands(Clustor)：JAVA_HOME/bin/java org.apache.spark.deploy.yarn.ApplicationMaster//如果是集群模式，isClusterMode就把类对名字给amClass;启动一个ApplicationMaster进程
　　　　　　　　　　//这些commands上边封装好的指令类都提交给yarn，由yarn来执行，这时Client客户端就结束了；
            -- 3.1. createContainerLaunchContext   //要去封装一个指令bin/java  javaOpts ++ amArgs(这个参数中Seq（amClass）) ++
        　　　　　　　　　　启动一个进程执行ApplicationMaster
            -- 3.1. createApplicationSubmissionContext
val containerContext = createContainerLaunchContext(newAppResponse)
val appContext = createApplicationSubmissionContext(newApp, containerContext) //它调用的是上边的；
                // 向Yarn提交应用
            -- 3.1. yarnClient.submitApplication(appContext) //把上边封装好的给yarnClient（相当于这些指令发给它）；在yarn中执行，Client把类提交给yarn之后就完成了

yarn的调度流程 https://www.cnblogs.com/shengyang17/p/10321228.html

SparkSubmit进程（启动一个java虚拟机即启动一个进程名字就叫SparkSubmit） -->调用Client方法，YarnClient去创建yarn客户端并启动， submitApplication()---launcherBackend.connect() ；

Client的submitApplication（抽象方法->去找它的实现类YarnClientImpl）向RM提交应用完成之后； rmClient.submitApplication(request)来跟RM做关联；  
createContainerLaunchContext去启动一个进程执行ApplicationMaster；

yarnClient.submitApplication(appContext) //把上边封装好的给yarnClient（相当于这些指令发给它），Client把类提交给yarn之后就完成了

ApplicationMaster
 
    -- . main
 
        -- 1.1. new ApplicationMasterArguments(args) //同上，封装了--jar, --class等
        -- 1.2. master = new ApplicationMaster(amArgs, new YarnRMClient)
        　　　　　　yarnConf 
　　　　　　　　　　heartbeatInterval心跳周期
　　　　　　　　　　RpcEnv : RPC 进程和进程的通信协议
　　　　　　　　　　RpcEndpoint ： 终端    RpcEndpointRef：终端引用
        -- 1.3. master.run
                // 集群模式它运行的是Driver；如果不是集群模式运行的就是ExecutorLauncher
            -- 1.3. runDriver() //isClusterMode

// 启动用户应用 就是提交的类
                -- 1.3.1.1 startUserApplication()--->即启动一个Driver线程
                        // 从命令行参数中获取--class的值，然后获取main方法；  用类加载器加载类 userClass封装类名（从命令行中获取）
                    --     val mainMethod = userClassLoader.loadClass(args.userClass).getMethod("main", classOf[Array[String]])
　　
                    -- new Thread("Driver").start() ==> --class.invoke(main)
                    　　启动之前：userThread.setContextClassLoader(userClassLoader) //类加载器放进去
　　　　　　　　　　　　　　userThread.setName("Driver") //真正的Driver是一个线程，只是把这个线程起个名字叫Driver
　　　　　　　　　　　　　　userThread.start() //启动之后肯定会运行线程的run方法  mainMethod.invoke(main);创建SparkConetext的那个类叫Driver，就是你写的那个main方法
　　　　　　　　　　　　　　虽然start，但什么时候执行不确定， userClassThread.join() //主线程不能结束，要等待它
　　　　　　　　　　　　　　　　　　rpcEnv = sc.env.rpcEnv构建环境对象
　　　　　　　　　　　　　　
                    // 向Yarn注册AM
                -- 1.3.1.2 registerAM()//client.
                　　　　allocator = client.register()
　　　　　　　　　　　　　　allocator.allocateResources() 它们进行注册和分配，申请资源，看看哪个资源可用 allocateResources资源列表；
　　　　　　　　　　　　　val allocatedContainers = allocateResponse.getAllocatedContainers() //以container的形式把资源给你，allocatedContainers是列表　
                    // 分配可用资源 （移动数据不如移动计算（计算在Driver，数据在executor，任务task发给哪个节点），本地化级别）
                    -- handleAllocatedContainers
                    　　　　本地化（计算和数据在同一个进程里）本地化(进程本地化即计算和数据中同一个进程 |节点本地化即一个节点有多个executor，发给另外一个executor|机架本地化，发给另外一个nodemanager)
                        -- runAllocatedContainers() //运行已经分配好的容器 
 
                            -- launcherPool.execute（线程） <-- if(launchContainers)  private val launcherPool = ThreadUtils.newDaemonCachedThreadPool //ThreadPool线程池 --> val threadPool = new ThreadPoolExecutor(),底层还是调用了jdk的线程池的操作
                            　　　　launcherPool.execute(new Runnable{ run(方法 new ExecutorRunnable).run( 与nmClient(即nodemanager的关联) ) }) //启动一个线程来执行操作，从线程池里边去执行一个线程
                            -- ExecutorRunnable.run() //nmClient.init(conf)  nmClient.start()  startContainer() 要去连接NM
 
                                -- nmClient.start()
                                // 启动容器
                                -- startContainer
                                       // JAVA_HOME/bin/java org.apache.spark.executor.CoarseGrainedExecutorBackend //执行器的后台，数据对接收处理，在NM中执行；
                                    -- val commands = prepareCommand()
                                    -- nmClient.startContainer(container.get, ctx) //由NM（AM就在这里边）来启动这个容器；xtx就是commands指令
 
CoarseGrainedExecutorBackend 粗粒度的
     -- . main
 
        -- 1.1. run  //var executor: Executor = null //所谓的Executor是后台CoarseGrainedExecutorBackend的一个计算对象，就是一个属性；
        　　SparkEnv.createExecutorEnv()   env.rpcEnv.setupEndpoint()
                 env.rpcEnv.awaitTermination() //主线程不会结束，需要等待它的结束 
　　　　　　　　　　 executor = new Executor() //在里边构建对象，跟CoarseGrainedExecutorBackend关系是很紧密的
　　　　　　　　　　　　case LaunchTask(data) => executor.launchTask() //executor启动任务
　　　　　　　　 -- 1.1.1 env.rpcEnv.setupEndpoint("Executor", new CoarseGrainedExecutorBackend //把当前的Executor对象创建出来； setupEndpoint设置，它是个抽象方法=>实现类NettyRpcEnv
　　　　　　　　　　　　　　　　override def setupEndpoint(): RpcEndpointRef = {dispatcher.registerRpcEndpoint(name, endpoint)} //把当前对象进行封装成name把它绑定中一起，形成注册效果就可以实现消息对发送和接收；
　　　　　　　　　　　　　　　　registerRpcEndpoint完成注册

ApplicationMaster
master = new ApplicationMaster.run()即runDriver()->startUserApplication()--->即启动一个Driver线程（通过反射来获取类名）.join()还没启动， 向Yarn注册AM--registerAM
client.register().allocateResources() 进行注册和分配，申请资源，看看哪个资源可用 allocateResources资源列表； allocateResponse.getAllocatedContainers() //以container的形式把资源给你

分配可用资源--handleAllocatedContainers--runAllocatedContainers() //运行已经分配好的容器 

if(launchContainers)--> launcherPool.execute（线程）->.run(ExecutorRunnable.run())，nmClient(即与nodeManager的关联)
nmClient.init(conf)  nmClient.start() nmClient.startContainer(container.get, ctx) //由NM（AM就在这里边）来启动这个容器

CoarseGrainedExecutorBackend 
所谓的Executor是后台CoarseGrainedExecutorBackend的一个计算对象，就是一个属性；
case LaunchTask(data) => new Executor().launchTask() //executor启动任务

    RpcEndpointAddress
    NettyRpcEndpointRef
    new EndpointData() //往终端里传数据 --> val inbox = new Inbox(ref, endpoint)//收件箱
            -->inbox.synchronized {messages.add(OnStart)} //往消息里发送数据，给当前终端CoarseGrainedExecutorBackend发送OnStart消息
            当前终端是可以通信的；ThreadSafeRpcEndpoint extends RpcEndpoint； RpcEndpoint终端是有生命周期的：
          　 The life-cycle of an endpoint is: constructor构造方法 -> onStart启动 -> receive* -> onStop关闭
    CoarseGrainedExecutorBackend接收到消息就会去调用OnStart 
　　　　　　 -->rpcEnv.asyncSetupEndpointRefByURI(driverUrl).flatMap 通过URI异步的去安装引用，通过一个地址得到远程对象对引用
    通过driverUrl地址建立了两个executor之间的通信，而且是异步发送；
    "Connecting to driver: " + driverUrl 找到Driver所在进程(AM)，异步的这个操作等同于拿到了与ApplicationMaster的关系；
    driver = Some(ref) 起完driver
      ref.ask[Boolean](RegisterExecutor()) 发送RegisterExecutor请求，它会去反向注册
      driver应该接收消息，它是一个线程不能接收，通过以下方法：
     　　 SparkContext 中SchedulerBackend属性 它的实现类CoarseGrainedSchedulerBackend(driver这边的引用)，而CoarseGrainedExecutorBackend是executor的后台引用；
      它们之间通信，刚刚ref发送了消息，它就接收到--->case RegisterExecutor  在PartialFunction偏函数中(所有的模式匹配的case都是)；
        反向注册就是建立executor和driver之间的关系；
        if (executorDataMap.contains(executorId)) {
          executorRef.send(RegisterExecutorFailed("Duplicate executor ID: " + executorId))
          //如果executorDataMap的数据集合中包含executorId，它向executor的引用发送注册失败的消息；else就启动
          context.reply(true)
          executorRef.send(RegisteredExecutor)//向远程的executor引用发送消息说在driver中已经注册好了可以启动了；
        } 

①脚本启动，执行SparkSubmit里面的main方法；

②反射获取Client类里边的main方法；

③封装并发送指令：bin/java ApplicationMaster

④选择一台NM机器启动AM

执行spark-submit实际上执行的是$SPARK_HOME/spark-class -->执行一个java类  java  org.apache.spark.launcher.Main调它的main方法（它就是检查参数、构建CommandBuiler指令）--->最终真正要执行 这个类 org.apache.spark.deploy.SparkSubmit xxx是命令行参数，它就会启动一个叫SparkSubmit进程

SparkSubmit类，对命令行参数进行了封装，准备提交环境，不是集群模式它会拿到指令中的--class所传的类， if (isYarnCluster)-->> org.apache.spark.deploy.yarn.Client 

利用反射通过类名获取类的信息，利用反射通过类信息获取Main方法，调用Client的main方法： Client的调用只是一个普通方法的调用

根据yarn的配置进行初始化创建yarn客户端准备去跟yarn打交道（要有yarn的server集群）， yarnClient.start()启动客户端，获取一个appId,yarn的全局id，根据id可以查询它的所有信息；
 Client向yarn的RM提交应用, 集群模式通过submitApplication来完成，启动JAVA_HOME/bin/java org.apache.spark.deploy.yarn.ApplicationMaster这个进程类（主要是为了与Yarn做关联）

这些commands上边封装好的指令|类都提交给yarn，由yarn来执行，这时Client客户端就结束了；

RM找一个节点NM来启动ApplicationMaster--java command；虽然只是不是集群模式它的类是ExecutorLauncher，但底层它同样还是调用的是ApplicationMaster.main;

集群模式 集群模式它运行的是Driver，启动用户应用 就是--class提交的类（通过类加载器）；

new Thread("Driver").start() Driver只是ApplicationMaster进程中的一个线程起名叫Driver； 之后它运行的是--class.invoke(main)就是你写的那个有sparkContext的main方法的那个类
称为Driver类；  向Yarn的RM注册AM，并申请资源；RM会返回一个资源列表，去进行分配资源，资源是以container的方式；

分配可用资源 （移动数据不如移动计算（计算在Driver，数据在某个节点executor，driver来分配任务task发给哪个节点），本地化级别）；
AM建立与NM的关联，向指定的资源NM发送指令； NM就会启动，它启动它的container容器；

//启动一个进程 JAVA_HOME/bin/java org.apache.spark.executor.CoarseGrainedExecutorBackend //执行器的后台，数据对接收处理，在NM中执行，粗粒度的执行器后台

；所谓的Executor是后台CoarseGrainedExecutorBackend的一个计算对象，就是一个属性；

反向注册就是建立executor和driver之间的关系，告诉driver我有一个executor已经启动了；

向远程的executor引用发送消息说在driver中已经注册好了可以启动了；

RDD中的数据变成一个个分区的数据，一个个分区变成任务

RDD（对数据计算逻辑的 抽象，里边没有数据）提交

任务的划分、分配、执行

RDD
 
    -- . collect
 
        -- 1.1 SparkContext.runJob
 
            -- dagScheduler.runJob() //有向无环图,有放向不能形成一个环，血缘关系形成的一个有向无环图调度器；
 
                -- submitJob()
 
                    -- eventProcessLoop.post( JobSubmitted()) //它等同往里边放了一个样例类；发送消息JobSubmitted
 
                    -- dagScheduler.handleJobSubmitted() //接收到JobSubmitted消息
 
DAGScheduler
 
    -- . handleJobSubmitted
 
            // 划分阶段-Stage
        -- 1.1 createResultStage  //finalStage = createResultStage(finalRDD, func, partitions, jobId, callSite)  val job = new ActiveJob()构建job对象即一个作业；有多个行动算子即执行了多个作业；
            // 提交阶段,有多少个阶段State  val missing = getMissingParentStages(stage).sortBy(_.id) 这个阶段有没有上级即上一饿阶段Stage呢
        -- 1.2 submitStage  
 
                // 提交任务 ，如果有上一个阶段就提交上个阶段，如果还有上个阶段就继续提交上个阶段，如果没有就提交现阶段中的任务
            -- 1.2. submitMissingTasks提交任务，missing表没有上级了  //if (missing.isEmpty) 如果上一个阶段为空没有，则submitMissingTasks提交task //如果有阶段就把上一个阶段给提交了 submitStage(parent)
                // 将任务进行封装，进行调度  stage 模式匹配 ShuffleMapStage | ResultStage ，spark中只有两种模式匹配；
                                    val tasks: Seq[Task[_]] 构建任务集合{对stage进行操作}
                                    如果上ShuffleMapStage会计算分区partitionsToCompute.map  <=>new ShuffleMapTask多少个分区变成多少个任务
 
            -- 1.2. taskScheduler.submitTasks（TaskSet）//任务调度器提交任务<--if (tasks.size > 0), 把任务封装成一个TaskSet集合传进来
                                    submitTasks的实现类TaskSchedulerImpl；   backend.reviveOffers()
                                    reviveOffers的实现类CoarseGrainedSchedulerBackend ->reviveOffers->makeOffers()-->launchTasks(scheduler.resourceOffers(workOffers))
 
            // 启动任务
            -- 1.2. launchTasks  //拿到了一个个任务； val serializedTask = ser.serialize(task)序列化
                    executorData.executorEndpoint.send(LaunchTask(new SerializableBuffer(serializedTask)))从executor中取出一个终端，从当前后台去找的executor的后台
                    发送一个LaunchTask启动任务的消息
 
CoarseGrainedExecutorBackend
 
    -- LaunchTask  //receive接收到一个消息LaunchTask，表让executor执行这个任务 val taskDesc = ser.deserialize[TaskDescription](data.value)反序列化
 
        -- executor.launchTask() //拿到任务，executor再去启动 --> val tr = new TaskRunner(context, taskId = taskId, attemptNumber = attemptNumber, taskName,serializedTask)
            // 运行任务                  threadPool.execute(tr) //线程池在执行某个线程操作即TaskRunner extends Runnable -->run
            -- task.run //释放内存更新状态等；
            

DAGScheduler

划分阶段 finalStage = createResultStage(finalRDD..)；

ShuffleMapStage | ResultStage ，spark中只有两种模式匹配；

 taskScheduler.submitTasks（TaskSet）//任务调度器提交任务<--if (tasks.size > 0), 把任务封装成一个TaskSet集合传进来；

Spark通信架构

RPC通信:远程过程(服务)调用-(两个进程之间的通信)
RPC的实现有多种，其中有RMI，原理：
一个Process1中的client去调用它的service，要让Process2中的service去执行；通过socket，两个进程的service一定是个接口，那么client怎么去调用接口呢
通过动态代理(把接口代理为对象来使用)，client通过代理对象Proxy与service去关联，代理对象会完成两个进程中socket的交互；

有封装好的框架可以使用；

Spark2.x版本使用Netty通讯框架作为内部通讯组件。spark 基于netty新的rpc框架借鉴了Akka的中的设计（随着版本升级已不再使用Akka，用Netty），它是基于Actor模型；

 Actor模型

Actor模型：
有多个对象，Object1, Object2 、Object3都给Object1发消息，都可以发消息(异步操作，发完该干嘛干嘛去；同步是发完之后不能做别的要等待它的返回)，但消息的先后由自己决定
接收消息的一方Object1有个收件箱Inbox(消息不是马上执行的)，它会去周期性的去取即轮询操作，有就去处理；
Object1从Inbox中查询到消息，发件箱Outbox(对应每一个对象)，可以有多个发件箱可以同时发送
Outbox(Object2) ---> Object2中相应的要有收件箱Inbox(query)，则Object1中要有Object2中地址的引用；
Actor模型中不叫Object了改叫EndPoint，Outbox(Object2)中的Object2引用改叫EndPointRef
Ref即远程的引用，要有地址去连接RpcAddress，终端和终端的引用互相发生关联；

Endpoint（Client/Master/Worker）有1个InBox和N个OutBox，每一个引用就是一个OutBox，多个OutBox可以同时发送消息

Netty 

NETT底层还是socket

IO中三种不同的处理方式：
BIO(最慢，阻塞式IO，读取文件时要等着不能去做别的事),
NIO(非阻塞式IO), 性能高，拿一个线程不断的去轮询，还可以去做其他事(只是在做事的过程中要不断的去问下好了没); 也叫多路IO复用，redis linux中
AIO(异步非阻塞式IO)，读取文件时遇到阻塞可以去做别的事，没有阻塞了它会把文件直接发送给你，不需你不断的去轮询的去问   
　　　　Netty就是基于AIO的  ；但是linux中不能用，windows可以

NettyRpcEnv是整个通信的环境，RpcEndpoint 终端，可以send和ask消息，还可以receive接收消息，请求和接收消息都要走Dispatcher调度器，它来决定你发送的消息该往收件箱还是发件箱走；在收件箱按照队列方式排列好，周期性的去取FIFO（先进先出），消息处理完之后发往send另外一个RpcEndPoint，往发件箱OubBox里走（会有一个远程地址RpcEndpointAddress-->该给谁发消息）；发消息时会有一个TransportClient，往远程去发（通过Netty网络通信去发）；

远程TransportServer接收消息又回到了Inbox，处理再返回；  ===>整个过程形成8字环绕

Spark任务调度

RDD是对数据计算逻辑的抽象；真正执行（行动算子）的时候才会计算； 

在DAGScheduler的handleJobSubmitted这个方法中完成了阶段的划分 finalStage = createResultStage(finalRDD, func, partitions, jobId, callSite)
--->val stage = new ResultStage(id, rdd, func, partitions, parents, jobId, callSite) //结果阶段，作业执行一遍这个对象也是就创建一遍
把当前作业当作整体形成完整的阶段--称作ResultStage
 val parents = getOrCreateParentStages(rdd, jobId) //参数rdd是handleJobSubmitted(finalRDD，xxx)给的，即当前要执行行动算子的rdd叫做finalRDD
  private def getOrCreateParentStages(rdd: RDD[_], firstJobId: Int): List[Stage] = {
    getShuffleDependencies(rdd).map { shuffleDep =>
    //把rdd传进去获取shuffle的依赖关系，.map把得到的结果进行转换；getShuffleDependencies返回的结果是parents  val parents = new HashSet[ShuffleDependency[_, _, _]]
                                    case shuffleDep: ShuffleDependency[_, _, _] => parents += shuffleDep
                                        先压栈new Stack[RDD[_]].push(rdd)，循环如果不为空就弹出来.pop()
                                        判断依赖关系中有没有shuffle依赖，有就加上 parents += shuffleDep
                                    case dependency => waitingForVisit.push(dependency.rdd)//没有shuffle就把上一层的rdd取出来，再做循环，push、pop不断的取上一级做判断
      getOrCreateShuffleMapStage(shuffleDep, firstJobId)  //它又new ShuffleMapStage()
    }.toList
  }
ShuffleMapStage和ResultStage两个阶段，最后构建job、设定、提交submitJob

 spark任务的划分、分配和执行

RDD读取file数据（按一行一行的读取），放到3个分区；发现0号分区不是想要的比如统计wordcount，分解产生了一个新的rdd（所有的转换算子等同于产生了一个新的rdd，rdd是不可变数据集），把一行一行数据变成一个个的，flatMap；转换结构如(a, 1)这样的结构map；reduceBykey打乱重组，产生shuffle过程

有向无环图的调度器，运行并且提交job作业（会进行简单的判断，jobWaiter传到样例类一旦发生特殊事件就产生特殊的方法 handlerJobSubmit完成了整个过程的阶段划分resultStage）； 把当前作业当成一个整体，形成了一个完整的阶段称为resultStage；

阶段怎么划分成一个个任务的了？

map->new MapPartitionsRDD -->extends RDD[U](prev)-->def this(@transient oneParent: RDD[_]) =this(oneParent.context, List(new OneToOneDependency(oneParent)))
OneToOneDependency[T](rdd: RDD[T]) extends NarrowDependency[T](rdd) ,源码中只有窄依赖，不是窄的就是宽的呗就是有shuffle的
创建了两个Stage，给的是finalStage, 创建job，提交submitStage(finalStage)
val missing = getMissingParentStages(stage).sortBy(_.id)    //看看有没有上一级的阶段即查找ShuffleMapStage
    new HashSet[Stage].push(stage.rdd) 把当前的rdd传到栈里-压栈，---不为空-->弹栈.pop()
    -->visit() rdd.dependencies取出它的依赖关系，找到shuffle的依赖关系，val mapStage = getOrCreateShuffleMapStage(shufDep, stage.firstJobId)有就拿来没有就创建新的
    missing += mapStage //放到hashSet里  missing.toList
    missing不为空 --> for (parent <- missing) {submitStage(parent)}循环遍历提交每一个Stage
    准备提交ResultStage时把它ShuffleMapStage取出来； submitStage(parent)}又自己调自己，找它ShuffleMapStage的上一级，为空-->submitMissingTasks(stage, jobId.get)提交任务
    提交的是shuffleStage，找的时候是一层层往上找，提交时是从最开始那一层层往下submitWaitingChildStages(stage)
    提交任务：
    只有两种类型的Stage
    case s: ShuffleMapStage =>
    case s: ResultStage =>
        taskIdToLocations，最优位置决定计算在哪里算，task和位置进行关联来决定在哪个executor中执行 getPreferredLocs(stage.rdd, p)
 
    case stage: ShuffleMapStage => partitionsToCompute.map计算分区 locs part ShuffleMapTask //一个阶段中多个分区map转换一个分区形成一个任务
    case stage: ResultStage =>  p locs part ResultTask
用shuffle来划分stage，因为shuffle是要落盘的；flatmap、map处理数据中间不停留，直接处理往下走，RDD之间每个分区的数据都是连贯的，但是
在shuffle阶段它就不连贯了，在这个阶段它要等待所有的数据都处理完了，shuffle是要全落盘的；这也是划分阶段的原因；
任务跟阶段有关系，有多少个分区就有多少个任务
taskScheduler.submitTasks(new TaskSet()) //任务的调度器它来提交任务，封装成任务集
     val manager = createTaskSetManager(taskSet, maxTaskFailures)//任务集管理器
     schedulableBuilder.addTaskSetManager(manager, manager.taskSet.properties) //manager会放到任务池中
     --->FIFOSchedulableBuilder 可以往里边放任务addTaskSetManager{ rootPool.addSchedulable(manager)} //任务池，TaskPool把任务划分好了来不及执行，可能划分好任务时资源还没申请到，
backend.reviveOffers()  --> launchTasks(scheduler.resourceOffers(workOffers))查找任务集
resourceOffers 看看有没有可用的资源executor， 拿到之后 launchTasks()[TaskDescription] ser.serialize(task)把任务序列化，executorData，executorData.executorEndpoint.send(LaunchTask(new SerializableBuffer(serializedTask)))
找到executor向它的终端发送消息--启动task，把得到的任务发送过去；
反向注册目的是启动一个Executor之后告诉Driver我准备好了-->可以发任务了；
启动：
 case LaunchTask(data) => if (executor == null) -->val taskDesc = ser.deserialize[TaskDescription](data.value)反序列化得到任务对象
 executor.launchTask() -->run()  task.run() //只有两种task
 以ResultTask为例：
    runTask(),shuffle前把数据写到文件里-->rdd.iterator读取数据func(context, rdd.iterator(partition, context))
    -->ShuffleRDD中 compute  .getReader  .read() 读取的是shuffle之前往里写的数据
    -->ShuffleMapTask阶段的最后一个RDD  runTask() .getWriter 由它来写

taskScheduler.submitTasks(new TaskSet()) //任务的调度器来提交任务，把任务封装成一个TaskSet任务集
val manager = createTaskSetManager(taskSet..)//任务集管理器
schedulableBuilder.addTaskSetManager(manager, manager.taskSet.properties) //manager会放到任务池中
-->FIFOSchedulableBuilder 可以往里边放任务addTaskSetManager{ rootPool.addSchedulable(manager)} //任务池

backend.reviveOffers(), launchTasks(scheduler.resourceOffers(workOffers))查找任务集, 拿到之后launchTasks(), ser.serialize(task)把任务序列化

特质SchedulerBackend--实现类--> CoarseGrainedSchedulerBackend它是(driver这边的引用)；