SparkCore-RDD编程详解

1.编程模型

    在Spark中，RDD被表示为对象，通过对象上的方法调用来对RDD进行转换。经过一系列的transformations定义RDD之后，就可以调用actions触发RDD的计算，action可以是向应用程序返回结果(count, collect等)，或者是向存储系统保存数据(saveAsTextFile等)。在Spark中，只有遇到action，才会执行RDD的计算(即延迟计算)，这样在运行时可以通过管道的方式传输多个转换。

    要使用Spark，开发者需要编写一个Driver程序，它被提交到集群以调度运行Worker，如下图所示。Driver中定义了一个或多个RDD，并调用RDD上的action，Worker则执行RDD分区计算任务。

 

2.创建RDD

    在Spark中创建RDD的创建方式大概可以分为三种：

    • 从集合中创建RDD；

    • 从外部存储创建RDD；

    • 从其他RDD创建。

2.1 从集合中创建RDD

    从集合中创建RDD，Spark主要提供了两种函数：parallelize和makeRDD,我们可以先看看这两个函数.

def parallelize[T: ClassTag](
      seq: Seq[T],
      numSlices: Int = defaultParallelism): RDD[T]

def makeRDD[T: ClassTag](
      seq: Seq[T],
      numSlices: Int = defaultParallelism): RDD[T]

def makeRDD[T: ClassTag](seq: Seq[(T, Seq[String])]): RDD[T]

    我们可以从上面看出makeRDD有两种实现，而且第一个makeRDD函数接收的参数和parallelize完全一致。其实第一种makeRDD函数实现是依赖了parallelize函数的实现，来看看Spark中是怎么实现这个makeRDD函数的：

def parallelize[T: ClassTag](
    seq: Seq[T],
    numSlices: Int = defaultParallelism): RDD[T] = withScope {
  assertNotStopped()
  new ParallelCollectionRDD[T](this, seq, numSlices, Map[Int, Seq[String]]())
}

def makeRDD[T: ClassTag](
    seq: Seq[T],
    numSlices: Int = defaultParallelism): RDD[T] = withScope {
  parallelize(seq, numSlices)
}

    我们可以看出，这个makeRDD函数完全和parallelize函数一致。但是我们得看看第二种makeRDD函数函数实现了，它接收的参数类型是Seq[(T, Seq[String])]，Spark文档的说明是：

   Distribute a local Scala collection to form an RDD, with one or more location preferences (hostnames of Spark nodes) for each object. Create a new partition for each collection item.

   原来，这个函数还为数据提供了位置信息，来看看我们怎么使用：

scala> val test= sc.parallelize(List(1,2,3))
test1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[10] at parallelize at :21
 
scala> val test2 = sc.makeRDD(List(1,2,3))
Test2: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[11] at makeRDD at :21
 
scala> val seq = List((1, List("slave01")),| (2, List("slave02")))
seq: List[(Int, List[String])] = List((1,List(slave01)),
 (2,List(slave02)))
 
scala> val test3 = sc.makeRDD(seq)
Test3: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[12] at makeRDD at :23
 
scala> test3.preferredLocations(guigu3.partitions(1))
res26: Seq[String] = List(slave02)
 
scala> test3.preferredLocations(guigu3.partitions(0))
res27: Seq[String] = List(slave01)
 
scala> test1.preferredLocations(guigu1.partitions(0))
res28: Seq[String] = List()

    我们可以看到，makeRDD函数有两种实现，第一种实现其实完全和parallelize一致；而第二种实现可以为数据提供位置信息，而除此之外的实现和parallelize函数也是一致的，如下：

def parallelize[T: ClassTag](
    seq: Seq[T],
    numSlices: Int = defaultParallelism): RDD[T] = withScope {
  assertNotStopped()
  new ParallelCollectionRDD[T](this, seq, numSlices, Map[Int, Seq[String]]())
}

def makeRDD[T: ClassTag](seq: Seq[(T, Seq[String])]): RDD[T] = withScope {
  assertNotStopped()
  val indexToPrefs = seq.zipWithIndex.map(t => (t._2, t._1._2)).toMap
  new ParallelCollectionRDD[T](this, seq.map(_._1), math.max(seq.size, 1), indexToPrefs)
}

    都是返回ParallelCollectionRDD，而且这个makeRDD的实现不可以自己指定分区的数量，而是固定为seq参数的size大小。

2.2 从外部存储创建RDD；

    由外部存储系统的数据集创建，包括本地的文件系统，还有所有Hadoop支持的数据集，比如HDFS、Cassandra、HBase等

scala> test = sc.textFile("hdfs://hadoop103:9000/user/hive/export/student1/month=201805/000000_0")

test: org.apache.spark.rdd.RDD[String] = hdfs://hadoop103:9000/user/hive/export/student1/month=201805/000000_0 MapPartitionsRDD[3] at textFile at :24

2.3 从其他RDD创建(RDD之间的相互转换)。

 

3.编程RDD

    RDD的操作可分为转换操作和行动操作，操作的数据类型可分为数值型RDD和键值对RDD(本章不进行具体区分，先统一来看，下一章会对键值对RDD做专门说明)。

3.1 转换操作：

    • 对于数值型RDD  操作定义在RDD类中

    • 对于kv型RDD， 操作定义在 PairRDDFunctions 类中

    • 所有数值型RDD的方法都可以用于 kv型RDD， kv型RDD的方法不可以用于数值型RDD

3.2 常用的Transformation：

    RDD中的所有转换都是延迟加载的，也就是说，它们并不会直接计算结果。相反的，它们只是记住这些应用到基础数据集（例如一个文件）上的转换动作。只有当发生一个要求返回结果给Driver的动作时，这些转换才会真正运行。这种设计让Spark更加有效率地运行。

（1）map(func)：对于一种类型转换为另外一种类型的RDD

def map[U: ClassTag](f: T => U): RDD[U] = withScope {
  val cleanF = sc.clean(f)
  new MapPartitionsRDD[U, T](this, (context, pid, iter) => iter.map(cleanF))
}

scala> val rdd = sc.makeRDD(1 to 10)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[2] at makeRDD at :24

scala> rdd.collect
res10: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> rdd.map(_.toString).collect
res11: Array[String] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> rdd.map(_.toString)
res12: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[4] at map at :27

scala> rdd.map((_,1)).collect
res14: Array[(Int, Int)] = Array((1,1), (2,1), (3,1), (4,1), (5,1), (6,1), (7,1), (8,1), (9,1), (10,1))

（2）filter(func)：过滤RDD数据集，返回满足条件的数据形成新的数据集

def filter(f: T => Boolean): RDD[T] = withScope {
  val cleanF = sc.clean(f)
  new MapPartitionsRDD[T, T](
    this,
    (context, pid, iter) => iter.filter(cleanF),
    preservesPartitioning = true)
}

scala> rdd.filter(_%3!=0).collect
res15: Array[Int] = Array(1, 2, 4, 5, 7, 8, 10)

（3）flatMap(func)：将T拆分为可迭代的U类型，然后压平。类似于map，但是每一个输入元素可以被映射为0或多个输出元素（所以func应该返回一个序列，而不是单一元素）

def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U] = withScope {
  val cleanF = sc.clean(f)
  new MapPartitionsRDD[U, T](this, (context, pid, iter) => iter.flatMap(cleanF))
}

scala> val rdd = sc.makeRDD(Array("a b,c","d,e,f"))
rdd: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[12] at makeRDD at :24

scala> rdd.map(_.split(" ")).collect
res21: Array[Array[String]] = Array(Array(a, b,c), Array(d,e,f))

scala> rdd.flatMap(_.split(" ")).collect
res22: Array[String] = Array(a, b,c, d,e,f)

 

（4）mapPartitions(func)==>是对Map的优化。

    类似于map，但独立地在RDD的每一个分片上运行，因此在类型为T的RDD上运行时，func的函数类型必须是Iterator[T] => Iterator[U]。假设有N个元素，有M个分区，那么map的函数将被调用N次,而mapPartitions被调用M次,一个函数一次处理所有分区。

def mapPartitions[U: ClassTag](
    f: Iterator[T] => Iterator[U],
    preservesPartitioning: Boolean = false): RDD[U] = withScope {
  val cleanedF = sc.clean(f)
  new MapPartitionsRDD(
    this,
    (context: TaskContext, index: Int, iter: Iterator[T]) => cleanedF(iter),
    preservesPartitioning)
}

scala> val rdd = sc.makeRDD(Array(1,2,3,4,5,6,7,8,9,10))
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[7] at makeRDD at :24

scala> rdd.mapPartitions(items=>items.map(_+1)).collect
res2: Array[Int] = Array(2, 3, 4, 5, 6, 7, 8, 9, 10, 11)

scala> rdd.mapPartitions(items=>Iterator(items.mkString("|"))).collect
res10: Array[String] = Array(1|2, 3|4|5, 6|7, 8|9|10)

 

（5）mapPartitionsWithIndex(func)：类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是(Int, Interator[T]) => Iterator[U]

def mapPartitionsWithIndex[U: ClassTag](
      f: (Int, Iterator[T]) => Iterator[U],
      preservesPartitioning: Boolean = false): RDD[U] = withScope {
    val cleanedF = sc.clean(f)
    new MapPartitionsRDD(
      this,
      (context: TaskContext, index: Int, iter: Iterator[T]) => cleanedF(index, iter),
      preservesPartitioning)
  }


scala> rdd.mapPartitionsWithIndex((x,y)=>Iterator(x+":"+y.mkString("|"))).collect

res15: Array[String] = Array(0:1|2, 1:3|4|5, 2:6|7, 3:8|9|10)

（6）sample(withReplacement, fraction, seed)

def sample(
      withReplacement: Boolean,
      fraction: Double,
      seed: Long = Utils.random.nextLong): RDD[T] = {
    require(fraction >= 0,
      s"Fraction must be nonnegative, but got ${fraction}")


    withScope {
      require(fraction >= 0.0, "Negative fraction value: " + fraction)
      if (withReplacement) {
        new PartitionwiseSampledRDD[T, T](this, new PoissonSampler[T](fraction), true, seed)
      } else {
        new PartitionwiseSampledRDD[T, T](this, new BernoulliSampler[T](fraction), true, seed)
      }
    }
}


scala> val rdd = sc.parallelize(1 to 10)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[20] at parallelize at :24

scala> rdd.collect()
res15: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> var sample1 = rdd.sample(true,0.4,2)
sample1: org.apache.spark.rdd.RDD[Int] = PartitionwiseSampledRDD[21] at sample at :26

scala> sample1.collect()
res16: Array[Int] = Array(1, 2, 2, 7, 7, 8, 9)

scala> var sample2 = rdd.sample(false,0.2,3)
sample2: org.apache.spark.rdd.RDD[Int] = PartitionwiseSampledRDD[22] at sample at :26

scala> sample2.collect()
res17: Array[Int] = Array(1, 9)

    以指定的随机种子随机抽样出数量为fraction的数据，withReplacement表示是抽出的数据是否放回，true为有放回的抽样，false为无放回的抽样，seed用于指定随机数生成器种子。例子从RDD中随机且有放回的抽出50%的数据，随机种子值为3（即可能以1 2 3的其中一个起始值）

 

（7）takeSample：和Sample的区别是 takeSample返回的是最终的结果集合。

scala> rdd.collect()
res15: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> var sample1 = rdd.takeSample(true,2)
sample1: Array[Int] = Array(10, 1)

 

（8）union(otherDataset)：对源RDD和参数RDD求并集后返回一个新的RDD

scala> val rdd1 = sc.parallelize(1 to 5).collect
rdd1: Array[Int] = Array(1, 2, 3, 4, 5)

scala> val rdd2 = sc.parallelize(5 to 10).collect
rdd2: Array[Int] = Array(5, 6, 7, 8, 9, 10)

scala> val rdd3 = rdd1.union(rdd2)
rdd3: Array[Int] = Array(1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10)

 

（9）intersection(otherDataset)：对源RDD和参数RDD求交集后返回一个新的RDD

scala> val rdd1 = sc.parallelize(1 to 5).collect
rdd1: Array[Int] = Array(1, 2, 3, 4, 5)

scala> val rdd2 = sc.parallelize(5 to 10).collect
rdd2: Array[Int] = Array(5, 6, 7, 8, 9, 10)

scala> val rdd3 = rdd1.intersection(rdd2)
rdd4: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[45] at intersection at :28

scala> rdd3.collect()
res26: Array[Int] = Array(5, 6, 7)

 

（10）distinct([numTasks]))：对源RDD进行去重后返回一个新的RDD. 默认情况下，只有8个并行任务来操作，但是可以传入一个可选的numTasks参数改变它。

scala> val distinctRdd = sc.parallelize(List(1,2,1,5,2,9,6,1))
distinctRdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[47] at parallelize at :24

scala> val unionRDD = distinctRdd.distinct()
unionRDD: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[50] at distinct at :26

scala> unionRDD.collect()
res27: Array[Int] = Array(1, 9, 5, 6, 2)

 

（11）partitionBy 对RDD进行分区操作，如果原有的partionRDD和现有的partionRDD是一致的话就不进行分区，否则会生成ShuffleRDD.

def partitionBy(partitioner: Partitioner): RDD[(K, V)] = self.withScope {
  if (keyClass.isArray && partitioner.isInstanceOf[HashPartitioner]) {
    throw new SparkException("HashPartitioner cannot partition array keys.")
  }

  if (self.partitioner == Some(partitioner)) {
    self
  } else {
    new ShuffledRDD[K, V, V](self, partitioner)
  }
}

scala> val rdd = sc.parallelize(Array((1,"aaa"),(2,"bbb"),(3,"ccc"),(4,"ddd")),4)
rdd: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[51] at parallelize at :24

scala> rdd.partitions.size
res28: Int = 4

scala> var rdd2 = rdd.partitionBy(new org.apache.spark.HashPartitioner(2))
rdd2: org.apache.spark.rdd.RDD[(Int, String)] = ShuffledRDD[52] at partitionBy at :26

scala> rdd2.partitions.size
res29: Int = 2

 

（12）reduceByKey(func, [numTasks])    在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，reduce任务的个数可以通过第二个可选的参数来设置（有预聚合功能）

def reduceByKey(partitioner: Partitioner, func: (V, V) => V): RDD[(K, V)] = self.withScope {
  combineByKeyWithClassTag[V]((v: V) => v, func, func, partitioner)
}
  
scala> val rdd = sc.parallelize(List(("female",1),("male",5),("female",5),("male",2)))
rdd: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[0] at parallelize at :24

scala> val reduce = rdd.reduceByKey((x,y) => x+y)
reduce: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[1] at reduceByKey at :26

scala> reduce.collect()
res0: Array[(String, Int)] = Array((female,6), (male,7))

 

（13）groupByKey    groupByKey也是对每个key进行操作，但只生成一个sequence。(相对于上面的reduceByKey少来一步操作。所以不能做预聚合功能)

def groupByKey(partitioner: Partitioner): RDD[(K, Iterable[V])] = self.withScope {
  val createCombiner = (v: V) => CompactBuffer(v)
  val mergeValue = (buf: CompactBuffer[V], v: V) => buf += v
  val mergeCombiners = (c1: CompactBuffer[V], c2: CompactBuffer[V]) => c1 ++= c2
  val bufs = combineByKeyWithClassTag[CompactBuffer[V]](
    createCombiner, mergeValue, mergeCombiners, partitioner, mapSideCombine = false)
  bufs.asInstanceOf[RDD[(K, Iterable[V])]]
}

scala> val rdd = sc.parallelize(List(("female",1),("male",5),("female",5),("male",2)))
rdd: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[0] at parallelize at :24

scala> val reduce = rdd.groupByKey()
reduce: org.apache.spark.rdd.RDD[(String, Iterable[Int])] = ShuffledRDD[3] at groupByKey at :26

scala> reduce.collect()
res0: Array[(String, Int)] = Array((female,6), (male,7))

 

（14）

def combineByKey[C](
    
createCombiner: V => C,  【每一个分区，当第一次遇到某一个key的时候】
    
mergeValue: (C, V) => C, 【每一个分区，当不是第一次遇到某一个key的时候】
    
mergeCombiners: (C, C) => C  【所有分区结果】将所有分区的最终结果数据

    对相同K，把V合并成一个集合

    createCombiner: combineByKey() 会遍历分区中的所有元素，因此每个元素的键要么还没有遇到过，要么就和之前的某个元素的键相同。如果这是一个新的元素,combineByKey() 会使用一个叫作 createCombiner() 的函数来创建

那个键对应的累加器的初始值

    mergeValue: 如果这是一个在处理当前分区之前已经遇到的键， 它会使用 mergeValue() 方法将该键的累加器对应的当前值与这个新的值进行合并

    mergeCombiners: 由于每个分区都是独立处理的， 因此对于同一个键可以有多个累加器。如果有两个或者更多的分区都有对应同一个键的累加器， 就需要使用用户提供的 mergeCombiners() 方法将各个分区的结果进行合并。

def combineByKey[C](
    createCombiner: V => C,
    mergeValue: (C, V) => C,
    mergeCombiners: (C, C) => C): RDD[(K, C)] = self.withScope {
  combineByKeyWithClassTag(createCombiner, mergeValue, mergeCombiners)(null)
}

scala> val scores = Array(("Fred", 88), ("Fred", 95), ("Fred", 91), ("Wilma", 93), ("Wilma", 95), ("Wilma", 98))
scores: Array[(String, Int)] = Array((Fred,88), (Fred,95), (Fred,91), (Wilma,93), (Wilma,95), (Wilma,98))


scala> val input = sc.parallelize(scores)
input: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[7] at parallelize at :26



scala> val combine = input.combineByKey(
      (v)=>(v,1),
      (acc:(Int,Int),v)=>(acc._1+v,acc._2+1),
      (acc1:(Int,Int),acc2:(Int,Int))=>(acc1._1+acc2._1,acc1._2+acc2._2))
combine: org.apache.spark.rdd.RDD[(String, (Int, Int))] = ShuffledRDD[8] at combineByKey at :28

scala> val result = combine.map{case (key,value) => (key,value._1/value._2.toDouble)}
result: org.apache.spark.rdd.RDD[(String, Double)] = MapPartitionsRDD[9] at map at :30



scala> result.collect()
res6: Array[(String, Double)] = Array((Wilma,95.33333333333333), (Fred,91.33333333333333))

 

（15）aggregateByKey(zeroValue:U,[partitioner: Partitioner]) (seqOp: (U, V) => U,combOp: (U, U) => U)

    在kv对的RDD中，，按key将value进行分组合并，合并时，将每个value和初始值作为seq函数的参数，进行计算，返回的结果作为一个新的kv对，然后再将结果按照key进行合并，最后将每个分组的value传递给combine函数进行计算（先将前两个value进行计算，将返回结果和下一个value传给combine函数，以此类推），将key与计算结果作为一个新的kv对输出。

    seqOp函数用于在每一个分区中用初始值逐步迭代value，combOp函数用于合并每个分区中的结果。

def aggregateByKey[U: ClassTag](zeroValue: U, partitioner: Partitioner)(seqOp: (U, V) => U,
    combOp: (U, U) => U): RDD[(K, U)] = self.withScope {
  val zeroBuffer = SparkEnv.get.serializer.newInstance().serialize(zeroValue)
  val zeroArray = new Array[Byte](zeroBuffer.limit)
  zeroBuffer.get(zeroArray)
  lazy val cachedSerializer = SparkEnv.get.serializer.newInstance()
  val createZero = () => cachedSerializer.deserialize[U](ByteBuffer.wrap(zeroArray))

  val cleanedSeqOp = self.context.clean(seqOp)
  combineByKeyWithClassTag[U]((v: V) => cleanedSeqOp(createZero(), v),
    cleanedSeqOp, combOp, partitioner)
}

scala> val rdd = sc.parallelize(List((1,3),(1,2),(1,4),(2,3),(3,6),(3,8)),3)
rdd: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[11] at parallelize at :24

scala> rdd.collect
res9: Array[(Int, Int)] = Array((1,3), (1,2), (1,4), (2,3), (3,6), (3,8))

scala> val agg = rdd.aggregateByKey(0)(math.max(_,_),_+_)
agg: org.apache.spark.rdd.RDD[(Int, Int)] = ShuffledRDD[12] at aggregateByKey at :26

scala> agg.collect()
res10: Array[(Int, Int)] = Array((3,8), (1,7), (2,3))

scala> agg.partitions.size
res11: Int = 3

scala> val rdd = sc.parallelize(List((1,3),(1,2),(1,4),(2,3),(3,6),(3,8)),1)
rdd: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[13] at parallelize at :24

scala>  val agg = rdd.aggregateByKey(0)(math.max(_,_),_+_).collect()
agg: Array[(Int, Int)] = Array((1,4), (3,8), (2,3))

 

（16）foldByKey(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]    

    aggregateByKey的简化操作，seqop和combop相同（比较少用）

def foldByKey(
    zeroValue: V,
    partitioner: Partitioner)(func: (V, V) => V): RDD[(K, V)] = self.withScope {
  // Serialize the zero value to a byte array so that we can get a new clone of it on each key
  val zeroBuffer = SparkEnv.get.serializer.newInstance().serialize(zeroValue)
  val zeroArray = new Array[Byte](zeroBuffer.limit)
  zeroBuffer.get(zeroArray)
  // When deserializing, use a lazy val to create just one instance of the serializer per task
  lazy val cachedSerializer = SparkEnv.get.serializer.newInstance()
  val createZero = () => cachedSerializer.deserialize[V](ByteBuffer.wrap(zeroArray))
  val cleanedFunc = self.context.clean(func)
  combineByKeyWithClassTag[V]((v: V) => cleanedFunc(createZero(), v),
    cleanedFunc, cleanedFunc, partitioner)
}

scala> val rdd = sc.parallelize(List((1,3),(1,2),(1,4),(2,3),(3,6),(3,8)),3)
rdd: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[15] at parallelize at :24

scala> val agg = rdd.foldByKey(0)(_+_)
agg: org.apache.spark.rdd.RDD[(Int, Int)] = ShuffledRDD[16] at foldByKey at :26

scala> agg.collect()
res12: Array[(Int, Int)] = Array((3,14), (1,9), (2,3))

 

（17）sortByKey([ascending], [numTasks])    在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD

def sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length)
      : RDD[(K, V)] = self.withScope
  {
    val part = new RangePartitioner(numPartitions, self, ascending)
    new ShuffledRDD[K, V, V](self, part)
      .setKeyOrdering(if (ascending) ordering else ordering.reverse)
  }

scala> val rdd = sc.parallelize(Array((3,"aa"),(6,"cc"),(2,"bb"),(1,"dd")))
rdd: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[17] at parallelize at :24

scala> rdd.sortByKey(true).collect()
res13: Array[(Int, String)] = Array((1,dd), (2,bb), (3,aa), (6,cc))

scala> rdd.sortByKey(false).collect()
res14: Array[(Int, String)] = Array((6,cc), (3,aa), (2,bb), (1,dd))

（18）sortBy(func,[ascending], [numTasks])    与sortByKey类似，但是更灵活,可以用func先对数据进行处理，按照处理后的数据比较结果排序。

scala> val rdd = sc.parallelize(List(1,2,3,4))
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[24] at parallelize at :24

scala> rdd.sortBy(x => x).collect()
res15: Array[Int] = Array(1, 2, 3, 4)

scala> rdd.sortBy(x => x%3).collect()
res16: Array[Int] = Array(3, 4, 1, 2)

 

（19）join(otherDataset, [numTasks])    

    在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD

scala> val rdd = sc.parallelize(Array((1,"a"),(2,"b"),(3,"c")))
rdd: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[35] at parallelize at :24

scala> val rdd1 = sc.parallelize(Array((1,4),(2,5),(3,6)))
rdd1: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[36] at parallelize at :24

scala> rdd.join(rdd1).collect()
res17: Array[(Int, (String, Int))] = Array((1,(a,4)), (2,(b,5)), (3,(c,6)))

 

（20）cogroup(otherDataset, [numTasks])    在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable,Iterable))类型的RDD

scala> sc.parallelize(Array((1,"a"),(2,"b"),(3,"c"))).cogroup(rdd1).collect()
res19: Array[(Int, (Iterable[String], Iterable[Int]))] = Array((1,(CompactBuffer(a),CompactBuffer(4))), (2,(CompactBuffer(b),CompactBuffer(5))), (3,(CompactBuffer(c),CompactBuffer(6))))

 

（21）cartesian(otherDataset)    笛卡尔积

scala> val rdd1 = sc.parallelize(1 to 3)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[45] at parallelize at :24

scala> val rdd2 = sc.parallelize(2 to 5)
rdd2: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[46] at parallelize at :24

scala> rdd1.cartesian(rdd2).collect()
res20: Array[(Int, Int)] = Array((1,2), (1,3), (1,4), (1,5), (2,2), (2,3), (2,4), (2,5), (3,2), (3,3), (3,4), (3,5))

（22）pipe(command, [envVars])    对于每个分区，都执行一个perl或者shell脚本，返回输出的RDD

scala> val rdd = sc.parallelize(List("hi","Hello","how","are","you"),1)
rdd: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[50] at parallelize at :24

scala> rdd.pipe("/home/bigdata/pipe.sh").collect()
res18: Array[String] = Array(AA, >>>hi, >>>Hello, >>>how, >>>are, >>>you)

scala> val rdd = sc.parallelize(List("hi","Hello","how","are","you"),2)
rdd: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[52] at parallelize at :24

scala> rdd.pipe("/home/bigdata/pipe.sh").collect()
res19: Array[String] = Array(AA, >>>hi, >>>Hello, AA, >>>how, >>>are, >>>you)

pipe.sh:
#!/bin/sh
echo "AA"
while read LINE; do
   echo ">>>"${LINE}
done

    注意：shell脚本需要集群中的所有节点都能访问到。

 

（23）coalesce(numPartitions) : 缩减分区数，用于大数据集过滤后，提高小数据集的执行效率。

scala> val rdd = sc.parallelize(1 to 16,4)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[2] at parallelize at :24

scala> rdd.partitions.size
res2: Int = 4

scala> val coalesceRDD = rdd.coalesce(3)
coalesceRDD: org.apache.spark.rdd.RDD[Int] = CoalescedRDD[3] at coalesce at :26

scala> coalesceRDD.partitions.size
res4: Int = 3

 

（24）repartition(numPartitions)    根据分区数，从新通过网络随机洗牌所有数据。

scala> val rdd = sc.parallelize(1 to 16,4)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[9] at parallelize at :24

scala> rdd.partitions.size
res8: Int = 4

scala> val rerdd = rdd.repartition(2)
rerdd: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[13] at repartition at :26

scala> rerdd.partitions.size
res9: Int = 2

scala> val rerdd = rdd.repartition(4)
rerdd: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[17] at repartition at :26

scala> rerdd.partitions.size
res10: Int = 4

（25） repartitionAndSortWithinPartitions(partitioner)

    repartitionAndSortWithinPartitions函数是repartition函数的变种，与repartition函数不同的是，repartitionAndSortWithinPartitions在给定的partitioner内部进行排序，性能比repartition要高。

 

（26）glom ： 将每一个分区形成一个数组，形成新的RDD类型时RDD[Array[T]]

scala> val rdd = sc.parallelize(1 to 16,4)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[20] at parallelize at :24


scala> rdd.glom().collect()
res12: Array[Array[Int]] = Array(Array(1, 2, 3, 4), Array(5, 6, 7, 8), Array(9, 10, 11, 12), Array(13, 14, 15, 16))

（27）mapValues    针对于(K,V)形式的类型只对V进行操作

scala>  val rdd3 = sc.parallelize(Array((1,"a"),(1,"d"),(2,"b"),(3,"c")))
rdd3: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[22] at parallelize at :24


scala> rdd3.mapValues(_+"|||").collect()
res13: Array[(Int, String)] = Array((1,a|||), (1,d|||), (2,b|||), (3,c|||))

（28）subtract：计算差的一种函数去除两个RDD中相同的元素，不同的RDD将保留下来

scala>  val rdd = sc.parallelize(3 to 8)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[24] at parallelize at :24

scala> val rdd1 = sc.parallelize(1 to 5)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[25] at parallelize at :24

scala> rdd.subtract(rdd1).collect()
res14: Array[Int] = Array(8, 6, 7)

 

3.3 常用的Action：

（1）reduce(func)    通过func函数聚集RDD中的所有元素，这个功能必须是可交换且可并联的

def reduce(f: (T, T) => T): T = withScope {
  val cleanF = sc.clean(f)
  val reducePartition: Iterator[T] => Option[T] = iter => {
    if (iter.hasNext) {
      Some(iter.reduceLeft(cleanF))
    } else {
      None
    }
  }
  var jobResult: Option[T] = None
  val mergeResult = (index: Int, taskResult: Option[T]) => {
    if (taskResult.isDefined) {
      jobResult = jobResult match {
        case Some(value) => Some(f(value, taskResult.get))
        case None => taskResult
      }
    }
  }

  sc.runJob(this, reducePartition, mergeResult)
  // Get the final result out of our Option, or throw an exception if the RDD was empty
  jobResult.getOrElse(throw new UnsupportedOperationException("empty collection"))
}


scala>  val rdd1 = sc.makeRDD(1 to 10,2)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[30] at makeRDD at :24

scala> rdd1.reduce(_+_)
res15: Int = 55

scala> val rdd2 = sc.makeRDD(Array(("a",1),("a",3),("c",3),("d",5)))
rdd2: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[31] at makeRDD at :24

scala> rdd2.reduce((x,y)=>(x._1 + y._1,x._2 + y._2))
res16: (String, Int) = (daac,12)

 

（2）collect()    在驱动程序中，以数组的形式返回数据集的所有元素

val rdd = sc.parallelize(3 to 8)
scala> rdd.collect
res19: Array[Int] = Array(3, 4, 5, 6, 7, 8)

 

（3）count()    返回RDD的元素个数

scala> rdd.count
res17: Long = 6

 

（4）first()    返回RDD的第一个元素（类似于take(1)）

scala> rdd.first
res20: Int = 3

 

（5）take(n)    返回一个由数据集的前n个元素组成的数组

scala> rdd.take(2)
res21: Array[Int] = Array(3, 4)

 

（6）takeSample(withReplacement,num, [seed])

    返回一个数组，该数组由从数据集中随机采样的num个元素组成，可以选择是否用随机数替换不足的部分，seed用于指定随机数生成器种子

val rdd = sc.parallelize(1 to 12)
scala> rdd.takeSample(true,3,2)
res22: Array[Int] = Array(2, 10, 6)

 

（7）takeOrdered(n)    返回前几个的排序

scala> rdd.takeOrdered(5)
res23: Array[Int] = Array(1, 2, 3, 4, 5)

 

（8）aggregate (zeroValue: U)(seqOp: (U, T) ⇒ U, combOp: (U, U) ⇒ U)

    aggregate函数将每个分区里面的元素通过seqOp和初始值进行聚合，然后用combine函数将每个分区的结果和初始值(zeroValue)进行combine操作。这个函数最终返回的类型不需要和RDD中元素类型一致。

scala> var rdd1 = sc.makeRDD(1 to 10,2)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[36] at makeRDD at :24

scala> rdd1.aggregate(1)(

     | {(x : Int,y : Int) => x + y},

     | {(a : Int,b : Int) => a + b}

     | )

res24: Int = 58


scala> rdd1.aggregate(1)(

     |       {(x : Int,y : Int) => x * y},

     |       {(a : Int,b : Int) => a + b}

     |       )

res25: Int = 30361

 

（9）fold(num)(func):折叠操作，aggregate的简化操作，seqop和combop一样。

scala>  var rdd1 = sc.makeRDD(1 to 4,2)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[37] at makeRDD at :24

scala> rdd1.aggregate(1)(

     |      | {(x : Int,y : Int) => x + y},

     |      | {(a : Int,b : Int) => a + b}

     |      | )

res26: Int = 13

scala> rdd1.fold(1)(_+_)

res27: Int = 13

 

（10）saveAsTextFile(path) :将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本

scala> val add = sc.makeRDD(1 to 20)
add: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)

add.saveAsTextFile("hdfs://10.211.55.103:9000/WorldCount_Out2")

 

（11）saveAsSequenceFile(path):将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。

scala> val rdd = sc.parallelize(List((1,3)))
rdd: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[15] at parallelize at :24

scala> rdd.saveAsSequenceFile("hdfs://10.211.55.103:9000/WorldCount_Out3")

 

（12）countByKey()    针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。

scala> val rdd = sc.parallelize(List((1,3),(1,2),(1,4),(2,3),(3,6),(3,8)),3)
rdd: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[41] at parallelize at :24


scala> rdd.countByKey()
res33: scala.collection.Map[Int,Long] = Map(3 -> 2, 1 -> 3, 2 -> 1)

 

（13）foreach(func)    在数据集的每一个元素上，运行函数func进行更新。

scala> var rdd = sc.makeRDD(1 to 10,2)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[44] at makeRDD at :24

scala>  var sum = sc.accumulator(0)
warning: there were two deprecation warnings; re-run with -deprecation for details
sum: org.apache.spark.Accumulator[Int] = 0

scala> rdd.foreach(sum+=_)
scala>  sum.value
res35: Int = 55


scala> rdd.collect().foreach(println)
1
2
3
4
5
6
7
8
9
10

 

（14）collectAsMap

    功能和collect函数类似。该函数用于Pair RDD，最终返回Map类型的结果。

scala> val data = sc.parallelize(List((1, "www"), (1, "iteblog"), (1, "com"), (2, "bbs"), (2, "iteblog"), (2, "com"), (3, "good")))
data: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[0] at parallelize at :24

scala> data.collectAsMap
res0: scala.collection.Map[Int,String] = Map(2 -> com, 1 -> com, 3 -> good)

3.4 数值RDD的统计操作

    Spark 对包含数值数据的 RDD 提供了一些描述性的统计操作。 Spark 的数值操作是通过流式算法实现的，允许以每次一个元素的方式构建出模型。这些 统计数据都会在调用 stats() 时通过一次遍历数据计算出来，并以 StatsCounter 对象返回。

scala> var rdd1 = sc.makeRDD(1 to 100)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[2] at makeRDD at :24

scala> rdd1.sum()
res2: Double = 5050.0

scala> rdd1.max()
res3: Int = 100

 

3.5 向RDD操作传递函数注意

    Spark 的大部分转化操作和一部分行动操作，都需要依赖用户传递的函数来计算。 在 Scala 中，我们可以把定义的内联函数、方法的引用或静态方法传递给 Spark，就像 Scala 的其他函数式 API 一样。我们还要考虑其他一些细节，比如所传递的函数及其引用 的数据需要是可序列化的(实现了 Java 的 Serializable 接口)。 传递一个对象的方法或者字段时，会包含对整个对象的引用。

  def isMatch(s: String): Boolean = {

    s.contains(query)

  }

  def getMatchesFunctionReference(rdd: org.apache.spark.rdd.RDD[String]): org.apache.spark.rdd.RDD[String] = {

    // 问题:"isMatch"表示"this.isMatch"，因此我们要传递整个"this"

    rdd.filter(isMatch)

  }

  def getMatchesFieldReference(rdd: org.apache.spark.rdd.RDD[String]): org.apache.spark.rdd.RDD[String] = {

// 问题:"query"表示"this.query"，因此我们要传递整个"this"

rdd.filter(x => x.contains(query))

  }

  def getMatchesNoReference(rdd: org.apache.spark.rdd.RDD[String]): org.apache.spark.rdd.RDD[String] = {

    // 安全:只把我们需要的字段拿出来放入局部变量中

val query_ = this.query

    rdd.filter(x => x.contains(query_))

  }

}

    如果在 Scala 中出现了 NotSerializableException，通常问题就在于我们传递了一个不可序列 化的类中的函数或字段。

 

3.6 在不同RDD类型间转换

    有些函数只能用于特定类型的 RDD，比如 mean() 和 variance() 只能用在数值 RDD 上， 而 join() 只能用在键值对 RDD 上。在 Scala 和 Java 中，这些函数都没有定义在标准的 RDD 类中，所以要访问这些附加功能，必须要确保获得了正确的专用 RDD 类。

    在 Scala 中，将 RDD 转为有特定函数的 RDD(比如在 RDD[Double] 上进行数值操作)是 由隐式转换来自动处理的。

 

4.SparkCore-RDD持久化(缓存)

    如前所述，Spark RDD 是惰性求值的，而有时我们希望能多次使用同一个 RDD。如果简单 地对 RDD 调用行动操作，Spark 每次都会重算 RDD 以及它的所有依赖。这在迭代算法中 消耗格外大，因为迭代算法常常会多次使用同一组数据。例 3-39 就是先对 RDD 作一次计 数、再把该 RDD 输出的一个小例子。

val result = input.map(x => x*x)
println(result.count())
println(result.collect().mkString(","))

    为了避免多次计算同一个 RDD，可以让 Spark 对数据进行持久化。当我们让 Spark 持久化 存储一个 RDD 时，计算出 RDD 的节点会分别保存它们所求出的分区数据。如果一个有持 久化数据的节点发生故障，Spark 会在需要用到缓存的数据时重算丢失的数据分区。如果 希望节点故障的情况不会拖累我们的执行速度，也可以把数据备份到多个节点上。

    出于不同的目的，我们可以为 RDD 选择不同的持久化级别。在 Scala和 Java 中，默认情况下 persist() 会把数据以序列化的形式缓存在 JVM 的堆空 间中。在 Python 中，我们会始终序列化要持久化存储的数据，所以持久化级别默认值就是 以序列化后的对象存储在 JVM 堆空间中。当我们把数据写到磁盘或者堆外存储上时，也 总是使用序列化后的数据。

    org.apache.spark.storage.StorageLevel和pyspark.StorageLevel中的持久化级 别;如有必要，可以通过在存储级别的末尾加上“_2”来把持久化数据存为两份

    在 Scala 中使用 persist()

val result = input.map(x => x * x)
result.persist(StorageLevel.DISK_ONLY)
println(result.count())
println(result.collect().mkString(","))

    注意：

    我们在第一次对这个 RDD 调用行动操作前就调用了 persist() 方法。persist() 调 用本身不会触发强制求值。

    如果要缓存的数据太多，内存中放不下，Spark 会自动利用最近最少使用(LRU)的缓存 策略把最老的分区从内存中移除。对于仅把数据存放在内存中的缓存级别，下一次要用到 已经被移除的分区时，这些分区就需要重新计算。但是对于使用内存与磁盘的缓存级别的 分区来说，被移除的分区都会写入磁盘。不论哪一种情况，都不必担心你的作业因为缓存 了太多数据而被打断。不过，缓存不必要的数据会导致有用的数据被移出内存，带来更多 重算的时间开销。

    最后，RDD 还有一个方法叫作 unpersist()，调用该方法可以手动把持久化的 RDD 从缓 存中移除。

     

5.SparkCore-RDD 检查点机制

    Spark中对于数据的保存除了持久化操作之外，还提供了一种检查点的机制，检查点（本质是通过将RDD写入Disk做检查点）是为了通过lineage做容错的辅助，lineage过长会造成容错成本过高，这样就不如在中间阶段做检查点容错，如果之后有节点出现问题而丢失分区，从做检查点的RDD开始重做Lineage，就会减少开销。检查点通过将数据写入到HDFS文件系统实现了RDD的检查点功能。

    cache 和 checkpoint 是有显著区别的，  缓存把 RDD 计算出来然后放在内存中，但是RDD 的依赖链也不能丢掉， 当某个点某个 executor 宕了，上面cache 的RDD就会丢掉， 需要通过依赖链重放计算出来。不同的是， checkpoint 是把 RDD 保存在 HDFS中， 是多副本可靠存储，所以依赖链就可以丢掉了，就斩断了依赖链， 是通过复制实现的高容错。

    如果存在以下场景，则比较适合使用检查点机制：

    • DAG中的Lineage过长，如果重算，则开销太大（如在PageRank中）。

    • 在宽依赖上做Checkpoint获得的收益更大。

    为当前RDD设置检查点。该函数将会创建一个二进制的文件，并存储到checkpoint目录中，该目录是用SparkContext.setCheckpointDir()设置的。在checkpoint的过程中，该RDD的所有依赖于父RDD中的信息将全部被移出。对RDD进行checkpoint操作并不会马上被执行，必须执行Action操作才能触发。

scala> val data = sc.parallelize(1 to 100 , 5)
data: org.apache.spark.rdd.RDD[Int] =
　　ParallelCollectionRDD[12] at parallelize at :12
scala> sc.setCheckpointDir("hdfs://master01:9000/checkpoint")
scala> data.checkpoint
scala> data.count

scala> val ch1 = sc.parallelize(1 to 2)
ch1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[33] at parallelize at :25

scala> val ch2 = ch1.map(_.toString+"["+System.currentTimeMillis+"]")
ch2: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[36] at map at :27

scala> val ch3 = ch1.map(_.toString+"["+System.currentTimeMillis+"]")
ch3: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[37] at map at :27

scala> ch3.checkpoint

scala> ch2.collect
res62: Array[String] = Array(1[1505480940726], 2[1505480940243])

scala> ch2.collect
res63: Array[String] = Array(1[1505480941957], 2[1505480941480])

scala> ch2.collect
res64: Array[String] = Array(1[1505480942736], 2[1505480942257])

scala> ch3.collect
res65: Array[String] = Array(1[1505480949080], 2[1505480948603])

scala> ch3.collect
res66: Array[String] = Array(1[1505480948683], 2[1505480949161])

scala> ch3.collect
res67: Array[String] = Array(1[1505480948683], 2[1505480949161])

 

6.RDD的依赖关系(血统机制)

    RDD和它依赖的父RDD（s）的关系有两种不同的类型，即窄依赖（narrow dependency）和宽依赖（wide dependency）。

6.1 窄依赖

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

    总结：窄依赖我们形象的比喻为独生子女

6.2 宽依赖

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

    总结：宽依赖我们形象的比喻为超生

6.3 Lineage

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

scala> val text = sc.textFile("README.md")
text: org.apache.spark.rdd.RDD[String] = README.md MapPartitionsRDD[1] at textFile at :24

scala> val words = text.flatMap(_.split)
split   splitAt

scala> val words = text.flatMap(_.split(" "))
words: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[2] at flatMap at :26

scala> words.map((_,1))
res0: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[3] at map at :29

scala> res0.reduceByKey
reduceByKey   reduceByKeyLocally

scala> res0.reduceByKey(_+_)
res1: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[4] at reduceByKey at :31

scala> res1.dependencies
res2: Seq[org.apache.spark.Dependency[_]] = List(org.apache.spark.ShuffleDependency@6cfe48a4)


scala> res0.dependencies
res3: Seq[org.apache.spark.Dependency[_]] = List(org.apache.spark.OneToOneDependency@6c9e24c4)

7.DAG的生成

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