之前学习spark的时候很多资料介绍Spark Pipeline管道计算模式就是说类似水的管道一样，一条数据计算除了结束后，再进行下一条数据的处理。

问题来了，如果一个job有很多个stage，每个stage会有很多个task任务。

那么这个一条数据有怎么处理呢？

 

引用一下美团调优化资料的一段话，看完后对上述的问题更加懵逼了。然后就写了一段代码进行测试。

美团调优化资料-----我们使用spark-submit提交一个Spark作业之后，这个作业就会启动一个对应的Driver进程。根据你使用的部署模式（deploy-mode）不同，Driver进程可能在本地启动，也可能在集群中某个工作节点上启动。Driver进程本身会根据我们设置的参数，占有一定数量的内存和CPU core。而Driver进程要做的第一件事情，就是向集群管理器（可以是Spark Standalone集群，也可以是其他的资源管理集群，美团•大众点评使用的是YARN作为资源管理集群）申请运行Spark作业需要使用的资源，这里的资源指的就是Executor进程。YARN集群管理器会根据我们为Spark作业设置的资源参数，在各个工作节点上，启动一定数量的Executor进程，每个Executor进程都占有一定数量的内存和CPU core。在申请到了作业执行所需的资源之后，Driver进程就会开始调度和执行我们编写的作业代码了。Driver进程会将我们编写的Spark作业代码分拆为多个stage，每个stage执行一部分代码片段，并为每个stage创建一批task，然后将这些task分配到各个Executor进程中执行。task是最小的计算单元，负责执行一模一样的计算逻辑（也就是我们自己编写的某个代码片段），只是每个task处理的数据不同而已。一个stage的所有task都执行完毕之后，会在各个节点本地的磁盘文件中写入计算中间结果，然后Driver就会调度运行下一个stage。下一个stage的task的输入数据就是上一个stage输出的中间结果。如此循环往复，直到将我们自己编写的代码逻辑全部执行完，并且计算完所有的数据，得到我们想要的结果为止。

测试代码：

object RDDPipelineAnalyse {
   def main(args: Array[String]): Unit = {
     val spark = SparkSession.builder().appName("检测spark数据处理pipeline")
      .master("local[2]").getOrCreate()

     val sc = spark.sparkContext
    sc.setLogLevel("WARN")
     val rdd01 = sc.parallelize(Array((1,1),(2,1),(3,1),(4,1),(5,1),(6,1)),1)
     val rdd02 = sc.parallelize(Array((1,100),(2,100),(3,100),(4,100),(5,100),(6,100)),1)
     val rdd1 = rdd01.map{ x => {
       println("map01--------"+x)
      x
    }}
     val rdd_1 = rdd1.filter(x=>{
       println("filter01--------"+x)
       true
    })
     val rdd2 = rdd02.map{ x => {
       println("map02--------"+x)
      x
    }}
     val rdd_2 = rdd1.filter(x=>{
       println("filter02--------"+x)
       true
    })
     val rdd3: RDD[(Int, (Int, Int))] = rdd_1.join(rdd_2)

     val rdd4 = rdd3.map(x=>{
       println("map01 join map02--------"+x)
      x
    })

    rdd4.collect()
    sc.stop()



  }

}

 

测试结果：

map01--------(1,1)
filter01--------(1,1)
map01--------(1,1)
filter02--------(1,1)
map01--------(2,1)
map01--------(2,1)
filter02--------(2,1)
filter01--------(2,1)
map01--------(3,1)
map01--------(3,1)
filter02--------(3,1)
filter01--------(3,1)
map01--------(4,1)
map01--------(4,1)
filter02--------(4,1)
filter01--------(4,1)
map01--------(5,1)
map01--------(5,1)
filter02--------(5,1)
filter01--------(5,1)
map01--------(6,1)
map01--------(6,1)
filter02--------(6,1)
filter01--------(6,1)
map01 join map02--------(4,(1,1))
map01 join map02--------(1,(1,1))
map01 join map02--------(6,(1,1))
map01 join map02--------(3,(1,1))
map01 join map02--------(5,(1,1))
map01 join map02--------(2,(1,1))

 

结论：Pipeline管道计算模式只是针对的同一个stage的RDD数据。如果进过了shuffle那么就要按照这个结论执行，一个stage的所有task都执行完毕之后，会在各个节点本地的磁盘文件中写入计算中间结果，然后Driver就会调度运行下一个stage。下一个stage的task的输入数据就是上一个stage输出的中间结果。如此循环往复，直到将我们自己编写的代码逻辑全部执行完，并且计算完所有的数据，得到我们想要的结果为止。

 

同时又有一个疑问冒出，如果遇到mapPartition这个的算子操作，那么每条数据处理的顺序又是什么样的呢？

 

测试代码：

object RDDPipelineAnalyse {
   def main(args: Array[String]): Unit = {
     val spark = SparkSession.builder().appName("检测spark数据处理pipeline")
      .master("local[2]").getOrCreate()

     val sc = spark.sparkContext
    sc.setLogLevel("WARN")
     val rdd01 = sc.parallelize(Array((1,1),(2,1),(3,1),(4,1),(5,1),(6,1)),1)
     val rdd02 = sc.parallelize(Array((1,100),(2,100),(3,100),(4,100),(5,100),(6,100)),1)

     println("rdd partition size : " + rdd01.partitions.length)
     val rdd1 = rdd01.mapPartitions{ x => {
       println("map01--------"+x)
      x
    }}
     val rdd_1 = rdd1.filter(x=>{
       println("filter01--------"+x)
       true
    })
     val rdd2 = rdd02.mapPartitions{ x => {
       println("map02--------"+x)
      x
    }}
     val rdd_2 = rdd1.filter(x=>{
       println("filter02--------"+x)
       true
    })
     val rdd3: RDD[(Int, (Int, Int))] = rdd_1.join(rdd_2)

     val rdd4 = rdd3.map(x=>{
       println("map01 join map02--------"+x)
      x
    })

    rdd4.collect()
    sc.stop()



  }

}

测试结果：

map01--------non-empty iterator
filter01--------(1,1)
map01--------non-empty iterator
filter02--------(1,1)
filter01--------(2,1)
filter02--------(2,1)
filter01--------(3,1)
filter02--------(3,1)
filter01--------(4,1)
filter02--------(4,1)
filter01--------(5,1)
filter02--------(5,1)
filter01--------(6,1)
filter02--------(6,1)
map01 join map02--------(4,(1,1))
map01 join map02--------(1,(1,1))
map01 join map02--------(6,(1,1))
map01 join map02--------(3,(1,1))
map01 join map02--------(5,(1,1))
map01 join map02--------(2,(1,1))

 

结论：“使用mapPartitions替代map”，也是一次函数调用处理一个partition的所有数据，而不是一次函数调用处理一条数据。这是调优的一个知识点。