spark—RDD

1.什么是RDD
RDD(Resilient Distributed Dataset)叫做弹性分布式数据集，是Spark中最基本的数据抽象，它代表一个不可变、可分区、里面的元素可并行计算的集合。RDD具有数据流模型的特点：自动容错、位置感知性调度和可伸缩性。RDD允许用户在执行多个查询时显式地将工作集缓存在内存中，后续的查询能够重用工作集，这极大地提升了查询速度。

2.RDD属性
(1)一组分片(Partition)，即数据集的基本组成单位。对于RDD来说，每个分片都会被一个计算任务处理，并决定并行计算的粒度。用户可以在创建RDD时指定RDD的分片个数，如果没有指定，那么就会采用默认值。默认值就是程序所分配到的CPU Core的数目。

(2)一个计算每个分区的函数。Spark中RDD的计算是以分片为单位的，每个RDD都会实现compute函数以达到这个目的。compute函数会对迭代器进行复合，不需要保存每次计算的结果。

(3)RDD之间的依赖关系。RDD的每次转换都会生成一个新的RDD，所以RDD之间就会形成类似于流水线一样的前后依赖关系。在部分分区数据丢失时，Spark可以通过这个依赖关系重新计算丢失的分区数据，而不是对RDD的所有分区进行重新计算。

(4)一个Partitioner，即RDD的分片函数。当前Spark中实现了两种类型的分片函数，一个是基于哈希的HashPartitioner，另外一个是基于范围的RangePartitioner。只有对于于key-value的RDD，才会有Partitioner，非key-value的RDD的Parititioner的值是None。Partitioner函数不但决定了RDD本身的分片数量，也决定了parent RDD Shuffle输出时的分片数量。

(5)一个列表，存储存取每个Partition的优先位置(preferred location)。对于一个HDFS文件来说，这个列表保存的就是每个Partition所在的块的位置。按照“移动数据不如移动计算”的理念，Spark在进行任务调度的时候，会尽可能地将计算任务分配到其所要处理数据块的存储位置。

3.RDD操作

• 转换操作(Transformation)
  返回一个新的RDD操作。

1.map(func)
返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成
2.filter(func)
返回一个新的RDD，该RDD由经过func函数计算后返回值为true的输入元素组成
3.flatMap(func)
类似于map，但是每一个输入元素可以被映射为0或多个输出元素(所以func应该返回一个序列，而不是单一元素)
4.mapPartitions(func)
类似于map，但独立地在RDD的每一个分片上运行，因此在类型为T的RDD上运行时，func的函数类型必须是Iterator[T] => Iterator[U]
5.mapPartitionsWithIndex(func)
类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是
(Int, Interator[T]) => Iterator[U]
6.sample(withReplacement, fraction, seed)
根据fraction指定的比例对数据进行采样，可以选择是否使用随机数进行替换，seed用于指定随机数生成器种子
7.union(otherDataset)
对源RDD和参数RDD求并集后返回一个新的RDD
8.intersection(otherDataset)
对源RDD和参数RDD求交集后返回一个新的RDD
9.distinct([numTasks]))
对源RDD进行去重后返回一个新的RDD
10.groupByKey([numTasks])
在一个(K,V)的RDD上调用，返回一个(K, Iterator[V])的RDD
11.reduceByKey(func, [numTasks])
在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，与groupByKey类似，reduce任务的个数可以通过第二个可选的参数来设置
aggregateByKey(zeroValue)(seqOp, combOp, [numTasks])
先按分区聚合 再总的聚合 每次要跟初始值交流 例如：aggregateByKey(0)(+,+) 对k/y的RDD进行操作
12.sortByKey([ascending], [numTasks])
在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD
13.sortBy(func,[ascending], [numTasks])
与sortByKey类似，但是更灵活 第一个参数是根据什么排序 第二个是怎么排序 false倒序 第三个排序后分区数 默认与原RDD一样
14.join(otherDataset, [numTasks])
在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD 相当于内连接(求交集)
15.cogroup(otherDataset, [numTasks])
在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable<V>,Iterable<W>))类型的RDD
16.cartesian(otherDataset)
两个RDD的笛卡尔积 的成很多个K/V
17.pipe(command, [envVars])
调用外部程序
18.coalesce(numPartitions)
重新分区 第一个参数是要分多少区，第二个参数是否shuffle 默认false 少分区变多分区 true 多分区变少分区 false
19.repartition(numPartitions)
重新分区 必须shuffle 参数是要分多少区 少变多
20.repartitionAndSortWithinPartitions(partitioner)
重新分区+排序 比先分区再排序效率高 对K/V的RDD进行操作
21.foldByKey(zeroValue)(seqOp)
该函数用于K/V做折叠，合并处理 ，与aggregate类似 第一个括号的参数应用于每个V值 第二括号函数是聚合例如：+
22.combineByKey
合并相同的key的值 rdd1.combineByKey(x => x, (a: Int, b: Int) => a + b, (m: Int, n: Int) => m + n)
23.partitionBy(partitioner)
对RDD进行分区 partitioner是分区器 例如new HashPartition(2
cache
RDD缓存，可以避免重复计算从而减少时间，区别：cache内部调用了persist算子，cache默认就一个缓存级别MEMORY-ONLY ，而persist则可以选择缓存级别
persist
24.Subtract(rdd)
返回前rdd元素不在后rdd的rdd
25.leftOuterJoin
leftOuterJoin类似于SQL中的左外关联left outer join，返回结果以前面的RDD为主，关联不上的记录为空。只能用于两个RDD之间的关联，如果要多个RDD关联，多关联几次即可。
26.rightOuterJoin
rightOuterJoin类似于SQL中的有外关联right outer join，返回结果以参数中的RDD为主，关联不上的记录为空。只能用于两个RDD之间的关联，如果要多个RDD关联，多关联几次即可
27.subtractByKey
substractByKey和基本转换操作中的subtract类似只不过这里是针对K的，返回在主RDD中出现，并且不在otherRDD中出现的元素

• 行动操作(Action)
  向驱动程序返回结果，或把结果写入外部系统。

1.reduce(func)
通过func函数聚集RDD中的所有元素，这个功能必须是课交换且可并联的
2.collect()
在驱动程序中，以数组的形式返回数据集的所有元素
3.count()
返回RDD的元素个数
4.first()
返回RDD的第一个元素(类似于take(1))
5.take(n)
返回一个由数据集的前n个元素组成的数组
6.takeSample(withReplacement,num, [seed])
返回一个数组，该数组由从数据集中随机采样的num个元素组成，可以选择是否用随机数替换不足的部分，seed用于指定随机数生成器种子
7.takeOrdered(n, [ordering])
8.saveAsTextFile(path)
将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本
9.saveAsSequenceFile(path)
将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。
10.saveAsObjectFile(path)
11.countByKey()
针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。
12.foreach(func)
在数据集的每一个元素上，运行函数func进行更新。
13.aggregate
先对分区进行操作，在总体操作
14.reduceByKeyLocally
15.lookup
16.top
17.fold

4.一个spark实例

public static void main(String[] args) {
        // 使用local模式，不需要启动spark集群
        SparkConf sparkConf = new SparkConf().setAppName("wordCount ").setMaster("local[2]");
        JavaSparkContext ctx = new JavaSparkContext(sparkConf);
        JavaRDD<String> file = ctx.textFile("分析的文件路径", 6);
        file.persist(StorageLevel.MEMORY_ONLY());
        file.cache();
        Comparator<Tuple2<String, Integer>> orderCompare = new TupleComparator();
        List<Tuple2<String, Integer>> wordToCounts = file
                // 转换操作，将每行以空格分割
                .flatMap(line -> Arrays.asList(line.split(" ")).iterator())
                // 转换操作
                .mapToPair(word -> new Tuple2<String, Integer>(word, 1))
                // 转换操作
                .reduceByKey((s1, s2) -> s1 + s2)// 将相同的key进行reduce，并将value相加
                // 行动操作
                .takeOrdered(50, orderCompare);
        wordToCounts.forEach(line -> System.out.println(line._1() + ":" + line._2()));
    }

5.RDD依赖关系
由于RDD是粗粒度的操作数据集，每个Transformation操作都会生成一个新的RDD，所以RDD之间就会形成类似流水线的前后依赖关系；RDD和它依赖的父RDD(s)的关系有两种不同的类型，即窄依赖(narrow dependency)和宽依赖(wide dependency)。如图所示显示了RDD之间的依赖关系。

image

从图中可知：

窄依赖：是指每个父RDD的一个Partition最多被子RDD的一个Partition所使用，例如map、filter、union等操作都会产生窄依赖；(独生子女)

宽依赖：是指一个父RDD的Partition会被多个子RDD的Partition所使用，例如groupByKey、reduceByKey、sortByKey等操作都会产生宽依赖；(超生)

需要特别说明的是对join操作有两种情况：

(1)图中左半部分join：如果两个RDD在进行join操作时，一个RDD的partition仅仅和另一个RDD中已知个数的Partition进行join，那么这种类型的join操作就是窄依赖，例如图1中左半部分的join操作(join with inputs co-partitioned)；

(2)图中右半部分join：其它情况的join操作就是宽依赖,例如图1中右半部分的join操作(join with inputs not co-partitioned)，由于是需要父RDD的所有partition进行join的转换，这就涉及到了shuffle，因此这种类型的join操作也是宽依赖。

为什么需要依赖关系
(1) 窄依赖(narrow dependencies)可以支持在同一个集群Executor上，以pipeline管道形式顺序执行多条命令，例如在执行了map后，紧接着执行filter。分区内的计算收敛，不需要依赖所有分区的数据，可以并行地在不同节点进行计算。所以它的失败恢复也更有效，因为它只需要重新计算丢失的parent partition即可

(2)宽依赖(shuffle dependencies) 则需要所有的父分区都是可用的，必须等RDD的parent partition数据全部ready之后才能开始计算，可能还需要调用类似MapReduce之类的操作进行跨节点传递。从失败恢复的角度看，shuffle dependencies 牵涉RDD各级的多个parent partition。

5.RDD分区
我们分析这样一个应用，它在内存中保存着一张很大的用户信息表(UserData)——也就是一个由(UserId, UserInfo)对组成的RDD，其中UserInfo包含一个该用户所订阅的主题列表。该应用会周期性性地将这张表与一个小文件进行组合，这个小文件中存着过去五分钟内发生的事件(events)——其实就是一个由(UserID, LinkInfo)对组成的表。如果我们要进行对用户访问情况的统计，就需要对这两个表进行join操作，以获得(UserID,UserInfo,LinkInfo)信息。

如图默认情况下，join操作会将两个数据集中的所有的键的哈希值都求出来，将哈希值相同的记录传送到同一台机器上，之后在该机器上对所有键相同的记录进行join操作。

image.png

所以这种情况之下，每次进行join都会有数据混洗的问题。造成了很大的网络传输开销。

这种情况之下由于UserData表比events表要大得多，所以选择将UserData进行分区。如果对UserData进行分区，之后Spark就会知晓该RDD是根据键的哈希值来分区的，这样在调用join()时，Spark就会利用这一点。当调用UserData.join(events)时，Spark只会对events进行数据混洗操作，将events中特定的UserID的记录发送到userData的对应分区所在的那台机器上。如下图：

image.png

自定义分区
我们都知道Spark内部提供了HashPartitioner和RangePartitioner两种分区策略，这两种分区策略在很多情况下都适合我们的场景。但是有些情况下，Spark内部不能符合咱们的需求，这时候我们就可以自定义分区策略。为此，Spark提供了相应的接口，我们只需要扩展Partitioner抽象类，然后实现里面的三个方法：

abstract class Partitioner extends Serializable {
  int numPartitions()
  int getPartition()
  boolean equals(String s)
}

ps:HashPartitioner和RangePartitionerhttps://www.cnblogs.com/liuming1992/p/6377540.html