spark原理架构

架构图：

说明：

 client使用spark-submit使用standalone提交一个job到spark集群的一个机器上，会通过反射生成一个DriverActor进程，在这个Driver中将会执行我们所写的代码，首先初始化 SparkContxt使用createTaskScheduler方法，源码如下：

 //standalone方式运行      case SPARK_REGEX(sparkUrl) =>        val scheduler = new TaskSchedulerImpl(sc)        val masterUrls = sparkUrl.split(",").map("spark://" + _)        val backend = new StandaloneSchedulerBackend(scheduler, sc, masterUrls)        scheduler.initialize(backend)        (backend, scheduler)

1.在初始化sparkContext时会创建TaskSchedulerImpl和StandaloneSchedulerBackend对象，并利用TaskScheduler对象初始化backend，

---

2.在initialize方法中我们会开启backend对象线程，并且创建DagScheduler和TaskScheduler两个对象，进行任务的调度和stage的构建，

---

3.taskScheduler负责连接到master向master注册app，master接受到了app的注册后，会使用自己的调度算法在集群的work上为app启动多个excutor，源码：

调度初始化 private def scheduleExecutorsOnWorkers(      app: ApplicationInfo,      usableWorkers: Array[WorkerInfo],      spreadOutApps: Boolean): Array[Int] = {    val coresPerExecutor = app.desc.coresPerExecutor    val minCoresPerExecutor = coresPerExecutor.getOrElse(1)    val oneExecutorPerWorker = coresPerExecutor.isEmpty    val memoryPerExecutor = app.desc.memoryPerExecutorMB    val numUsable = usableWorkers.length    val assignedCores = new Array[Int](numUsable) // Number of cores to give to each worker    val assignedExecutors = new Array[Int](numUsable) // Number of new executors on each worker    var coresToAssign = math.min(app.coresLeft, usableWorkers.map(_.coresFree).sum)    /** Return whether the specified worker can launch an executor for this app. */    def canLaunchExecutor(pos: Int): Boolean = {      val keepScheduling = coresToAssign >= minCoresPerExecutor      val enoughCores = usableWorkers(pos).coresFree - assignedCores(pos) >= minCoresPerExecutor      // If we allow multiple executors per worker, then we can always launch new executors.      // Otherwise, if there is already an executor on this worker, just give it more cores.      val launchingNewExecutor = !oneExecutorPerWorker || assignedExecutors(pos) == 0      if (launchingNewExecutor) {        val assignedMemory = assignedExecutors(pos) * memoryPerExecutor        val enoughMemory = usableWorkers(pos).memoryFree - assignedMemory >= memoryPerExecutor        val underLimit = assignedExecutors.sum + app.executors.size < app.executorLimit        keepScheduling && enoughCores && enoughMemory && underLimit      } else {        // We're adding cores to an existing executor, so no need        // to check memory and executor limits        keepScheduling && enoughCores      }    } 开启在  private def startExecutorsOnWorkers(): Unit = {    // Right now this is a very simple FIFO scheduler. We keep trying to fit in the first app    // in the queue, then the second app, etc.    for (app <- waitingApps if app.coresLeft > 0) {      val coresPerExecutor: Option[Int] = app.desc.coresPerExecutor      // Filter out workers that don't have enough resources to launch an executor      val usableWorkers = workers.toArray.filter(_.state == WorkerState.ALIVE)        .filter(worker => worker.memoryFree >= app.desc.memoryPerExecutorMB &&          worker.coresFree >= coresPerExecutor.getOrElse(1))        .sortBy(_.coresFree).reverse      val assignedCores = scheduleExecutorsOnWorkers(app, usableWorkers, spreadOutApps)      // Now that we've decided how many cores to allocate on each worker, let's allocate them      for (pos <- 0 until usableWorkers.length if assignedCores(pos) > 0) {        allocateWorkerResourceToExecutors(          app, assignedCores(pos), coresPerExecutor, usableWorkers(pos))      }    }  }

调度算法有两种：

将executors安排到workers身上。 返回一个包含分配给每个worker的内核数的数组。  有两种启动执行者的模式。第一次尝试展开应用程序  执行尽可能多的worker，而第二个则相反(即启动他们  尽可能少的worker。前者通常更适合于数据局部性目的  默认。 配给每个executor的内核数是可配置的。当这是显式设置时， 同一应用程序的多个执行器可能在同一worker上启动 拥有足够的内核和内存。否则，每个执行器都会捕获所有可用的内核 默认情况下，在此情况下，每个worker只能执行一个执行者。 每次只分配一个worker是很重要的(而不是一个核心) 每次。考虑下面的例子:集群有4个worker，每个人拥有16个内核。 用户请求3个执行器(spark .内核)。max = 48,spark.executor。核= 16)。如果1核心是 每次分配给每位执行者12核。 由于12 < 16，没有执行器会启动[spark - 8881]。

调度算法有两种：

    有两种启动执行者的模式。第一次尝试展开应用程序    执行尽可能多的员工，而第二个则相反(即启动他们    尽可能少的工人

---

4.work接收master的调度后，会在本地启动多个excutor，并且在executor中建立一个线程池；

---

5.创建完executor后；excutor会反向注册到TaskScheduler，
6.所有的excutor都在TaskScheduler注册完成后，开始执行我们的代码，这是初始化完成
7,执行代码是，一个action操作就是产生一个job
8,job会提交给DagScheduler，将这个任务划分成多个stage，每个stage创建一个taskSet，
9将taskSet提交给TaskScheduler，TaskScheduler回见Taskset提交给excutor，
10.excutor收到task后，会开启一个taskRunner，去执行这个task，
11.所以所有的spark程序就是讲stage分批次的提交各excutor执行，
task有两种，一种就是shuffleTask另一种就是ReduceTask
最后一个就是reduceTask，其他的都是shuffleTask