【Spark四十】RDD算子逻辑执行图第一部分

最新推荐文章于 2024-10-08 22:01:27 发布

原创

最新推荐文章于 2024-10-08 22:01:27 发布 · 408 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#scala #大数据 #java

本文深入探讨Spark的RDD算子，包括count、groupByKey、join、union和reduceByKey。重点关注Shuffle过程，如ShuffleMapTask和ResultTask的数据交互，以及reduceByKey的map端预reduce操作。通过分析逻辑执行图，揭示了ShuffleDependency如何聚合相同key的数据，并介绍combineByKey函数及其在数据聚合与计算中的作用。

1.count

2.groupByKey

3.join

4.union

5.reduceByKey

Shuffle/Dependency总结

ShuffleMapTask将数据写到内存(或者磁盘）供ResultTask来拉取，那么写的策略是什么？ResultTask怎么知道拉取属于它的数据，那么这里头Mapper和Reducer应该通力协作，工作完成数据的写和读操作。

1. count

  /**
   * Return the number of elements in the RDD.
   */
  def count(): Long = sc.runJob(this, Utils.getIteratorSize _).sum

Utils.getIteratorSize算出一个worker上的elements的数目，然后然后通过sum操作，将所有worker节点上的elements数目进行相加

先在每个 partition 上执行 count，然后执行结果被发送到 driver，最后在 driver 端进行 sum。

2. groupByKey

package spark.examples

import java.util.Random

import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.SparkContext._

/**
 * Usage: GroupByTest [numMappers] [numKVPairs] [valSize] [numReducers]
 */
object SparkGroupByTest {
  def main(args: Array[String]) {
    val sparkConf = new SparkConf().setAppName("GroupBy Test").setMaster("local ")
    val numMappers = 1//100
    val numKVPairs = 100//00
    val valSize = 10//00
    val numReducers = 36

    val sc = new SparkContext(sparkConf)

   ///定义numMappers个元素的集合，对每个元素调用flatMap操作
    val pairs1 = sc.parallelize(0 until numMappers, numMappers).flatMap { p =>

     ///随机数，作为arr1的元素类型(K,V)中的K
      val ranGen = new Random

     ///定义一个数组，长度为numKVPairs。元素类型是(K,V)的二元组，K的类型是Int，V的类型是字节数组(字节长度为valSize)
      val arr1 = new Array[(Int, Array[Byte])](numKVPairs)

     ///对长度为numKVPairs的arr1进行填充值
      for (i <- 0 until numKVPairs) {

        ///创建数组元素的字节数组，数组长度为valSize
        val byteArr = new Array[Byte](valSize)
        ranGen.nextBytes(byteArr)
        //K是随机生成的整数
        arr1(i) = (ranGen.nextInt(Int.MaxValue), byteArr)
      }
      arr1
    }.cache
    // Enforce that everything has been calculated and in cache

   //action操作，将数据缓存，并且返回所有的(K,V)对
    println(pairs1.toDebugString);
    /*cache的是FlatMappedRDD
    FlatMappedRDD[1] at flatMap at SparkGroupbyTest.scala:26 [Memory Deserialized 1x Replicated]
    ParallelCollectionRDD[0] at parallelize at SparkGroupbyTest.scala:26 [Memory Deserialized 1x Replicated]
     */

    pairs1.count

    ///根据Reducer个数做groupBy操作，
    println(pairs1.groupByKey(numReducers).count)

    sc.stop()
  }
}

1. groupByKey的含义是对（K,V）进行合并。

例如:

节点1： (1,2),(1,3),(2,6)

节点2：（1,7），(3,8),(2,9）

那么groupByKey结束后得到的结果是什么？

(1,(2,7)),(1,(3,7)),(2,(6,9)), (3,(_,8))? 不对，最后的结果，应该是Key是唯一的

2. 上面的例子中，reducer的个数是36，那么要做group操作，所以，来自各个worker节点的相同的Key必须由同一个reducer上来处理，这是怎么做到的？即reducer拉取数据时，是按照Key做Hash么？hash(key)%36. 即m个mapper结果，由r个reducer消费，如何消费？每个mapper都有reducer的数据，reducer如何拉取应该由它处理的这些数据？从不同的mapper中拉取数据，这就是Shuffle Write的工作！是分布式计算框架的核心之一

3. 如下图所示：ShuffledRDD存放的时比较合并的结果，只是从FlatMappRDD将原始数据拉取过来？拉取数据时，Mapp端没有做预combine操作？？

4. groupByKey操作是一个根据Key把所有的Value聚合到一起的操作，这跟SQL的groupBy操作不一样，SQL的groupBy操作的结果是，一组的结果是每个占据一行。

5. groupByKey不要是用map端的combine

 /**
   * Group the values for each key in the RDD into a single sequen

最低0.47元/天解锁文章