Spark系列七：Spark 任务执行的流程详解及相关概念

目录

spark总体流程图示

图解

详解DAG（Directed Acyclic Graph）

详解Stage

总结

细节流程

总体流程

线程池

序列化

---

spark总体流程图示：

图解：

四个步骤
1.RDD Objects:构建DAG（调用RDD上的方法）
2.DAGScheduler将DAG切分Stage（切分的依据是Shuffle），将Stage中生成的Task以TaskSet集合的形式给TaskScheduler
3.TaskScheduler调度Task（根据资源情况将Task调度到相应的Executor中）
4.Work:Executor接收Task，然后将Task丢入到线程池中执行

详解DAG（Directed Acyclic Graph）:

1. DAG 有向无环图,表示数据执行过程，有方法，无闭环
2. DAG描述多个RDD的转换过程，任务执行时，可以按照DAG的描述，执行真正的计算（数据被操作的一个过程）
3. DAG是有边界的：开始（通过SparkContext创建的RDD），结束（触发Action，调用run Job就是一个完整的DAG就形成了，一旦触发Action就形成了一个完整的DAG）
4. 一个RDD只是描述了数据计算过程中的一个环节，而DGA由一到多个RDD组成，描述了数据计算过程中的所有环节
5. 一个Spark Application中是有多少个DAG：一到多个（取决于触发了多少次Action）

shuffle的定义

    shuffle的含义是洗牌，将数据打散，父RDD一个分区中的数据如果给了子RDD的多个分区（只有存在这种可能），就是shuffle
    shuffle会有网络传输数据，但是有网络传输，并不意味着就是shuffle

详解Stage

1. 一个DAG中可能有产生多种不同类型和功能的Task，会有不同的阶段
2. DAGScheduler：将一个DAG切分成一到多个Stage，DAGScheduler切分的依据是Shuffle（宽依赖）
3. RDD的依赖关系：窄依赖（narrow dependency）和宽依赖（wide dependency）

               

 从图中可以总结出：窄依赖指的是每一个父RDD的Partition最多被子RDD的一个Partition使用（独生子女）

                                  宽依赖指的是多个子RDD的Partition会依赖同一个父RDD的Partition（超生）

 

上图中有个特殊的join,下图进行解释一下：下图这个join为宽依赖。存在一个分区里面的数据给了不同的分区，

上面那幅图中，一个分区的数据都给了一个分区。因为它下游就只有一个分区。

同一个分区不能join

有三个Stage,6个task,前两个stage都是把数据写到磁盘，并行化

所以join大部分是宽依赖，但也会有窄依赖

在看另一种情况：为窄依赖，先分组再join.

有三个Stage,6个task,前两个stage都是把数据写到磁盘，并行化,第三个stage包含groupByKey和join

jion的时候改变分区数时，会有5个stage,这个RDD的分区器和他所有父依赖的分区器一样，并且分区数量一样，那么就是窄依赖，否则是宽依赖

 

RDD只支持粗粒度转换，即在大量记录上执行的单个操作。将创建RDD的一系列Lineage（即血统）记录下来，以便恢复丢失的分区。RDD的Lineage会记录RDD的元数据信息和转换行为，当该RDD的部分分区数据丢失时，它可以根据这些信息来重新运算和恢复丢失的数据分区。

为什么要切分Stage？

    一个复杂的业务逻辑（将多台机器上具有相同属性的数据聚合到一台机器上：shuffle）
    如果有shuffle，那么就意味着前面阶段产生的结果后，才能执行下一个阶段，下一个阶段的计算要依赖上一个阶段的数据。
    在同一个Stage中，会有多个算子，可以合并在一起，我们称其为pipeline（流水线：严格按照流程、顺序执行）

总结

细节流程

总体流程

线程池

这里介绍了三种线程池

public class ThreadPoolDemo {

    public static void main(String[] args) {

        //创建一个单线程的线程池
        //ExecutorService pool = Executors.newSingleThreadExecutor();

        //固定大小的线程池
        //ExecutorService pool = Executors.newFixedThreadPool(5);


        //可缓冲的线程词(可以有多个线程)，看计算机性能，4核8线程池
        ExecutorService pool = Executors.newCachedThreadPool();

        for(int i = 1; i <= 20; i ++) {

            pool.execute(new Runnable() {
                @Override
                public void run() {
                    //打印当前线程的名字
                    System.out.println(Thread.currentThread().getName());
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " is over");
                }
            });

        }

        System.out.println("all Task is submitted");
        //pool.shutdownNow();

    }
}

序列化

总体思路，序列化之前打印一下地址，序列化之后再读取两次，分别打印地址，三次地址都不一样，说明被实例化多次
序列化：可以写入文件，可以在网络之间传输

Task序列化在Spark中应用：在Driver端创建这个实例，序列化后发送出去（序列化的时候知道了以后从哪里了读取数据，假如是HDFS，则知道以后在哪个切片读数据；并且知道以后该如何执行，根据RDD的转换关系（调用那个方法，传入了什么函数）’），发生给Executor，Executor接收后，反序列化，用一个实现了Runnable接口一个类包装一下，然后丢到线程池中，包装的run方法就会执行

class MapTask extends Serializable{

  def m1(path: String): String = {
    path.toString
  }

  def m2(line: String): Array[String] = {
    line.split(" ")
  }
}

object SerTask {

  def main(args: Array[String]): Unit = {

    //new一个实例，然后打印她的hashcode值
    val t = new MapTask
    println(t)  //打印的是内存地址
    
    序列化，可以把这个流对象写在文件中
    val oos = new ObjectOutputStream(new FileOutputStream("./t"))
    oos.writeObject(t)
    oos.flush()
    oos.close()
    
	//反序列化两次
    val ois1 = new ObjectInputStream(new FileInputStream("./t"))
    val o1 = ois1.readObject()
    println(o1)
    ois1.close()

    val ois2 = new ObjectInputStream(new FileInputStream("./t"))
    val o2 = ois2.readObject()
    println(o2)
    ois2.close()

  }
}