spark里面的RDD基本知识

一、spark core

      RDD：Resilient Distributed Dataset

           弹性分布式数据集

                 不可变

                      如果需要在一个RDD进行转换操作则会生成一个新的RDD

                 可分区

                      RDD里面的具体数据是分布在多台机器上的Executor里面的

堆内内存和堆外内存+磁盘

                 弹性

                      RDD的弹性表现

                            存储的弹性

                                  内存与磁盘的自动切换

                            容错的弹性

                                  数据丢失可以自动恢复

                            计算的弹性

                                  计算是分层的，由应用--Job--Stage--Taskset--Task，每一层都有对应的计算的保障与重复机制。保障你的计算不会由于一些突发因素而终止

                                  计算出错重试机制

                            分片的弹性

                                  根据需要重新分片

           spark计算的基石，为用户屏蔽了底层数据的复杂抽象和处理，为用户提供了一组方便的数据转换与求值方法

      spark SQL结构化数据

      spark streaming实时计算

      MLib机器学习

      GraghX图计算

二、RDD

      spark core操作RDD

           输入算子

textFile、parallelize等

           变换算子

filter、map等

           缓存算子

cache算子

           行动算子

action

           输出

三、RDD的创建

      从集合中创建RDD

           sc.parallelize（seq）

                 把seq这个数据并行化分片到节点

                 scala> val prdd = sc.parallelize(1 to 10)

                      scala> prdd.collect

                 scala> val lrdd = sc.parallelize(List("a","b","c"))

           sc.makeRDD(seq)

                 把seq这个数据并行化分片到节点，就是parallelize的实现

                 scala> val mrdd = sc.makeRDD(0 to 10)

           sc.makeRDD(seq[T , seq])

                 这种方式可以指定RDD的存放位置

           scala> val aa = sc.makeRDD(List((1,List("a","b")),(2,List("c","d"))))

                      aa. +tab

                       aa.partition +tab

                      aa.partitions.size

                      aa.preferredLocations(aa.partitions(0))

      从外部存储创建RDD

           比如sc.textFile("path")

      从其它RDD转换

四、RDD的操作

      转换（transformations）

           通过操作将一个RDD转换成另一个RDD

           filter

                 val filter = sc.makeRDD(Array("aa1","bb1","aa2","cc1"))

                 filter.filter(_.startsWith("aa")).collect

map

                 val sourceRdd = sc.makeRDD(1 to 10)

                 sourceRdd.map(_ * 2)

                 res12.collect

 

           flatMap

                 val flat = sc.makeRDD(1 to 3)

                 scala> flat.flatMap((1 to _)).collect

res15: Array[Int] = Array(1, 1, 2, 1, 2, 3)

           mapPartitions

                 scala> val person = sc.makeRDD(List(("a","female"),("b","male"),("c","female")))

person: org.apache.spark.rdd.RDD[(String, String)] = ParallelCollectionRDD[10] at makeRDD at <console>:24

 

scala> :paste

// Entering paste mode (ctrl-D to finish)

 

def partitionsFun(iter : Iterator[(String,String)]) : Iterator[String] = {

  var woman = List[String]()

  while (iter.hasNext){

    val next = iter.next()

    next match {

       case (_,"female") => woman = next._1 :: woman

       case _ =>

    }

  }

  woman.iterator

}

 

// Exiting paste mode, now interpreting.

 

partitionsFun: (iter: Iterator[(String, String)])Iterator[String]

 

scala> person.mapPartitions

mapPartitions   mapPartitionsWithIndex

 

scala> person.mapPartitions(par)

parquet   partitionsFun

 

scala> person.mapPartitions(partitionsFun).collect

res16: Array[String] = Array(a, c)

 

                 mapPartitionsWithIndex

                 sample（withReplacement、fraction、seed）

                      scala> val sample = sc.makeRDD(1 to 100)

sample: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[12] at makeRDD at <console>:24

 

scala> sample.sample(false,0.1,4).collect

res17: Array[Int] = Array(6, 14, 26, 63, 75, 77, 78, 94)

 

scala> sample.sample(true,0.1,4).collect

res18: Array[Int] = Array(6, 14, 17, 26, 30, 63, 77, 87, 95, 95)

                 union

                      并集，将两个RDD中的元素进行合并返回一个新的RDD

                 intersection

                      交集，将两个RDD做交集并返回一个新的RDD

                 distinct

                      去重，对原RDD进行去重后返回一个新的RDD

                 partitionBy

                      重新分区

      行动（action）

                 将一个RDD进行求值或者输出

                 takeSample

                      是一个action操作，不是转换操作，不能collect

                      scala> sample.takeSample(false,20,4)

res20: Array[Int] = Array(89, 75, 3, 17, 5, 71, 35, 68, 96, 7, 95, 65, 99, 23, 86, 46, 32, 94, 27, 43)

                 reduce(func)

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

                 collect()

                      在驱动程序中，以数组的形式返回数据集的所有元素

                 count()

                      返回RDD的元素个数

                 first()

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

                 take(n)

                      返回一个由数据集的前n个元素组成的数组

           所有的操作主要是针对两种类型

                 1）数值RDD

                 2）键值对RDD

           RDD的所有操作都是懒执行的，只有当行动操作出现的时候spark才会真的运行