Spark基础知识梳理

用户提交的应用程序代码在spark中运行起来就是一个driver，用户提交的程序运行起来就是一个driver，他是一个一段特殊的excutor进程，这个进程除了一般excutor都具有的运行环境外，这个进程里面运行着DAGscheduler Tasksheduler Schedulerbackedn等组件。

官方例子中计算π值的程序代码在spark上运行起来就是一个driver，可以看到这段程序里有个main函数，它是整个应用程序的开始，也可以看到在这段代码中创建了context，

Driver做什么?

1. 运行应用程序代码里面的main函数, main函数是整个程序的开始.
2. 创建spark的上下文对象.
3. 划分RDD并生成有向无环图(DAGScheduler)
4. 与spark中的其他组件进行协调, 协调资源等等(SchedulerBackend)
5. 生成并发送task到executor(taskScheduler)

可以阅读下面文章:
http://www.jobplus.com.cn/article/getArticleDetail/30566

看下面的代码:

//创建spark上下文对象的类就是Driver类, 也就是Spark02_Oper1类是Driver
object Spark02_Oper1 {
     
  def main(args: Array[String]): Unit = {
     

    /**
      * 演示 map
      */

    // 设定spark计算框架的运行(部署) 环境
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("JSONApp")
    /// 创建Spark上下文对象
    val sc = new SparkContext(conf)

    val listRDD: RDD[Int] = sc.makeRDD(1 to 4, 2)

    val mapRDD: RDD[Int] = listRDD.map[Int](
      x => {
     
        x * 2
      }
    )
    mapRDD.collect().foreach(println)
  }
}

在上述的代码中，哪些代码是在Driver中执行的, 哪些代码是在Executor上执行的,

说白了就是转换算子里的代码是在Executor, 转换算子是由RDD来调用.

任务的划分和任务调度

一个分区划分一个任务(Task), 一个任务会被分配到Exector中执行.

shuffle操作

将rdd中的一个分区的数据打乱重组到其他不同的分区的操作, 称之为shuffle操作.
Spark中所有转换算子中没有如果没有shuffle的算子, 执行性能比较快!

窄依赖

窄依赖指的是每一个父RDD的Partition最多被子RDD的一个Partition使用.

宽依赖

宽依赖指的是多个子RDD的Partition会依赖同一个父RDD的Partition，会引起shuffle,

DAG

DAG(Directed Acyclic Graph)叫做有向无环图，原始的RDD通过一系列的转换就就形成了DAG，根据RDD之间的依赖关系的不同将DAG划分成不同的Stage，对于窄依赖，partition的转换处理在Stage中完成计算。对于宽依赖，由于有Shuffle的存在，只能在parent RDD处理完成后，才能开始接下来的计算，因此宽依赖是划分Stage的依据。


也就是由原始的RDD经过一系列的转换形成了多个RDD, 多个RDD就形成了DAG. 说白了DAG就是很多个RDD.
每个RDD里有多个分区, 根据RDD之间的依赖关系的不同将DAG划分成不同的Stage. 如上图所示, 一共两个shuffle。
Stage = 1 + shuffle的个数. 所以一共3个Stage.

任务划分

RDD任务划分中间分为: Application, Job, Stage和Task

Job: 一个Action算子就会生成一个Job
Stage: 根据RDD之间的依赖关系的不同将Job划分成不同的Stage, 遇到一个宽依赖则划分一个Stage.

根据一个WordCount例子来说明Job, Stage, Applicatin,到底是说明什么。

Application：就是编写的Spark的应用程序:
比如下面的程序:

object WordCount {
     
  def main(args: Array[String]): Unit = {
     
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("WordCount")
    /// 创建Spark上下文对象
    val sc = new SparkContext(conf)
    
    // 读取文件, 将文件内容一行一行的读取出来
    val lines: RDD[String] = sc.textFile("file:///opt/module/spark-2.0.0-bin-hadoop2.6/in")
    // 将一行一行的数据分解成一个一个的单词
    val words: RDD[String] = lines.flatMap(_.split(" "))
    // 为了统计方便, 将单词数据进行结构的转换
    val wordsToOne: RDD[(String, Int)] = words.map((_,1))
    // 对转换结构后的数据进行分组聚合
    val wordToSum: RDD[(String, Int)] = wordsToOne.reduceByKey((_+_))
    // 将统计结果进行采集
    val result: Array[(String, Int)] = wordToSum.collect()
    // 将结果进行遍历
    result.foreach(println)
  }
}

上面的spark程序代码就是一个Application。说白了, 整个代码就是Spark的应用程序也就是Application.

job： 一个行动算子就是一个Job(作业), 上面的WordCount程序就是一个Job(作业). 代码中只有一个行动算子, 也就是collect。 有几个行动算子就有几个Job。 行动算子和Job是相同的概念!

Stage：一个Job(作业)里有1+n个Stage. n表示是 shuffle的个数。上图中的WordCount程序就是一个Job(作业), 这个Job里有两个2个Stage.

Task： 上图中, 一个Stage里有一个或者多个RDD, 每个RDD里有一个或多个分区,即 一个Stage里有多个分区(partition), 而且每个Stage的任务数取决于最后一个RDD的分区数(partition). Stage: Task = 1 : n

注意:
Application -> Job -> Stage -> Task每一层都是1:n的关系

在上述的WordCount程序一共有2两个分区, 根据 1+shuffle的个数 来分析, 其中只有一个shuffle个数, 所以有2个Stage. 一共有8个任务, 在Stage2中有5个任务, Stage1中有3个任务, 每个Stage的任务数取决于最后一次RDD的分区数, Stage2的最后一次RDD里的分区数为5, Stage1最后一次RDD里的分区数为3个. 一共加起来有8个任务!