第8章SparkCore--RDD键值对
Spark并行计算模型：RDD
Spark并⾏计算模型：RDDSpark 允许⽤户为driver（或主节点）编写运⾏在计算集群上，并⾏处理数据的程序。
在Spark中，它使⽤RDDs代表⼤型的数据集，RDDs 是⼀组不可变的分布式的对象的集合，存储在executors中（或从节点）。
组成RDDs的对象称为partitions，并可能（但是也不是必须的）在分布式系统中不同的节点上进⾏计算。
Spark cluster manager根据Spark application设置的参数配置，处理在集群中启动与分布Spark executors，⽤于计算，如下图：Spark 并不会⽴即执⾏driver 程序中的每个RDD 变换，⽽是懒惰执⾏：仅在最后的RDD数据需要被计算时（⼀般是在写出到存储系统，或是收集⼀个聚合数据给driver时）才触发计算RDD变换。
Spark可以将⼀个RDD加载到executor节点的内存中（在整个Spark 应⽤的⽣命周期），以在进⾏迭代计算时，达到更快的访问速度。
因为RDDs是不可变的，由Spark实现，所以在转换⼀个RDD时，返回的是⼀个新的RDD，⽽不是已经存在的那个RDD。
Spark的这些性质（惰性计算，内存存储，以及RDD不可变性）提供了它易于使⽤、容错、可扩展、以及⾼效运⾏的特点。
惰性计算许多其他系统，对in-memory 存储的⽀持，基于的是：对可变（mutable）对象的细粒度更新。
例如：对内存中存储的某个条⽬的更新。
⽽在Spark中，RDDs是完全惰性的。
直到⼀个action被调⽤之前，Spark不会开始计算partition。
这⾥的action是⼀个Spark操作，除了返回⼀个RDD以外，还会触发对分区的计算，或是可能返回⼀些输出到⾮Spark系统中（如outside of the Spark executors）。
例如，将数据发送回driver（使⽤类似count或collect 操作），或是将数据写⼊到外部存储系统（例如copyToHadoop）。
带你入门使用Spark进行大数据分析
带你入门使用Spark进行大数据分析一、介绍Spark大数据分析Apache Spark是一个开源的、快速通用的集群计算系统，也是当前最流行的大数据处理框架之一。
Spark以其高效的内存计算和丰富的API支持，成为大数据处理和分析的首选工具之一。
本文将带你入门使用Spark进行大数据分析，介绍Spark的基本概念、结构和常用功能，帮助你开始使用Spark进行大数据分析。
二、Spark基本概念和架构1. Spark基本概念Spark由以下几个基本概念组成：- Resilient Distributed Dataset（RDD）：Spark的核心数据结构，是一个分布式的、不可变的弹性数据集。
RDD可以并行计算，自动容错和恢复。
RDD可以从Hadoop、本地文件系统等数据源创建。
- DataFrame：Spark中的一种丰富的数据结构，类似于数据库中的表。
DataFrame支持结构化数据处理和SQL查询。
它是由多个RDD组成的分布式数据集合。
- Spark Core：Spark的核心模块，提供了RDD的实现和基本功能。
- Spark SQL：Spark的SQL和数据处理模块，提供了对结构化数据的处理和查询能力。
- Spark Streaming：Spark的流式处理模块，支持实时数据流处理。
- Machine Learning Library（MLlib）：Spark的机器学习库，提供了丰富的机器学习算法和工具。
- Graph Processing System（GraphX）：Spark的图处理模块，支持图数据的处理和分析。
2. Spark架构Spark的核心架构由以下几个组件组成：- Driver：Spark应用的驱动程序，负责定义Spark上的任务执行、创建RDD和提交Spark作业。
- Cluster Manager：集群管理器，用于在集群上启动和管理Spark应用程序。
常见的集群管理器包括Standalone、YARN和Mesos。
Spark之RDD的定义及五大特性
Spark之RDD的定义及五⼤特性 RDD是分布式内存的⼀个抽象概念，是⼀种⾼度受限的共享内存模型，即RDD是只读的记录分区的集合，能横跨集群所有节点并⾏计算，是⼀种基于⼯作集的应⽤抽象。
RDD底层存储原理：其数据分布存储于多台机器上，事实上，每个RDD的数据都以Block的形式存储于多台机器上，每个Executor会启动⼀个BlockManagerSlave，并管理⼀部分Block；⽽Block的元数据由Driver节点上的BlockManagerMaster 保存，BlockManagerSlave⽣成Block后向BlockManagerMaster注册该Block，BlockManagerMaster管理RDD与Block的关系，当RDD不再需要存储的时候，将向BlockManagerSlave发送指令删除相应的Block。
BlockManager管理RDD的物理分区，每个Block就是节点上对应的⼀个数据块，可以存储在内存或者磁盘上。
⽽RDD中的Partition是⼀个逻辑数据块，对应相应的物理块Block。
本质上，⼀个RDD在代码中相当于数据的⼀个元数据结构，存储着数据分区及其逻辑结构映射关系，存储着RDD之前的依赖转换关系。
BlockManager在每个节点上运⾏管理Block(Driver和Executors)，它提供⼀个接⼝检索本地和远程的存储变量，如memory、disk、off-heap。
使⽤BlockManager前必须先初始化。
BlockManager.scala的部分源码如下所⽰：private[spark] class BlockManager(executorId: String,rpcEnv: RpcEnv,val master: BlockManagerMaster,serializerManager: SerializerManager,val conf: SparkConf,memoryManager: MemoryManager,mapOutputTracker: MapOutputTracker,shuffleManager: ShuffleManager,val blockTransferService: BlockTransferService,securityManager: SecurityManager,numUsableCores: Int)extends BlockDataManager with BlockEvictionHandler with Logging { BlockManagerMaster会持有整个Application的Block的位置、Block所占⽤的存储空间等元数据信息，在Spark的Driver 的DAGScheduler中，就是通过这些信息来确认数据运⾏的本地性的。
Spark学习之RDD编程总结
Spark学习之RDD编程总结 Spark 对数据的核⼼抽象——弹性分布式数据集（Resilient Distributed Dataset，简称 RDD）。
RDD 其实就是分布式的元素集合。
在 Spark 中，对数据的所有操作不外乎创建 RDD、转化已有 RDD 以及调⽤ RDD 操作进⾏求值。
⽽在这⼀切背后，Spark 会⾃动将RDD 中的数据分发到集群上，并将操作并⾏化执⾏。
⼀、RDD基础 Spark 中的 RDD 就是⼀个不可变的分布式对象集合。
每个 RDD 都被分为多个分区，这些分区运⾏在集群中的不同节点上。
RDD 可以包含 Python、Java、Scala 中任意类型的对象，甚⾄可以包含⽤户⾃定义的对象。
⽤户可以使⽤两种⽅法创建 RDD：读取⼀个外部数据集，或在驱动器程序⾥分发驱动器程序中的对象集合（⽐如 list 和 set）。
创建出来后，RDD ⽀持两种类型的操作：转化操作（transformation）和⾏动操作（action）。
转化操作会由⼀个 RDD ⽣成⼀个新的 RDD。
另⼀⽅⾯，⾏动操作会对 RDD 计算出⼀个结果，并把结果返回到驱动器程序中，或把结果存储到外部存储系统（如 HDFS）中。
转化操作和⾏动操作的区别在于 Spark 计算 RDD 的⽅式不同。
虽然你可以在任何时候定义新的 RDD，但 Spark 只会惰性计算这些 RDD。
它们只有第⼀次在⼀个⾏动操作中⽤到时，才会真正计算。
这种策略刚开始看起来可能会显得有些奇怪，不过在⼤数据领域是很有道理的。
例如 Spark 在我们运⾏ lines = sc.textFile(...) 时就把⽂件中所有的⾏都读取并存储起来，就会消耗很多存储空间，⽽我们马上就要筛选掉其中的很多数据。
相反，⼀旦 Spark 了解了完整的转化操作链之后，它就可以只计算求结果时真正需要的数据。
事实上，在⾏动操作 first() 中，Spark 只需要扫描⽂件直到找到第⼀个匹配的⾏为⽌，⽽不需要读取整个⽂件。
Spark学习总结
Spark学习总结Spark是用于大数据处理的集群计算框架，没有使用MapReduce作为执行引擎，而是使用了自研的分布式运行环境（DAG引擎）在集群上执行工作。
Spark可以在YARN上运行，并支持Hadoop文件及HDFS。
Spark最突出的表现在于它能将作业与作业之间产生的大规模的工作数据集存储在内存中，在性能上要优于等效的MapReduce工作流，通常可以高出一个数量级。
因为MapReduce的数据集始终需要从磁盘上加载。
•Spark与MapReduce一样，也有作业（job）的概念，Spark的作业比MapReduce的作业更为通用，Spark作业是由任意的多阶段（stages）有向无环图（DAG）构成，其中每个阶段相当于MapReduce中的map阶段或者reduce阶段。
•这些阶段在Spark运行环境中被分解成多个任务（task），任务并行运行在分布于集群中的RDD（弹性分布式数据集Resilient Distributed Dataset）分区上。
像MapReduce中的任务一样。
•Spark作业始终运行在应用上下文中（applicationContext，用实例SparkContext表示），它提供了RDD分组以及共享变量。
一个应用（application）可以串行或者并行运行多个作业，并为这些作业提供访问由同一应用的先前作业所缓存的RDD的机制。
弹性分布式数据集RDDRDD是Spark最核心的概念，它是在集群中跨多个机器分区存储的一个只读的对象集合。
在典型的Spark程序中，首先要加载一个或多个RDD，作为输入再通过一系列转换得到一组目标RDD，然后对这些目标RDD执行一个动作，如计算出结果或者写入持久存储器。
“弹性分布式数据集”中的“弹性”指的是Spark可以通过重新安排计算来自动重建丢失的分区。
加载RDD或者执行转换不会立即触发任何数据处理操作，只是重建了一个计算的计划。
大数据平台技术智慧树知到答案章节测试2023年山东交通学院
第一章测试1.数据，就是所有能输入到计算机，并被计算机程序处理的符号的总称为（）。
A:对B:错答案:A2.大数据的4V特征包括（）。
A:种类繁多B:规模庞大C:变化频繁D:价值巨大但价值密度低答案:ABCD3.2TB数据等于多少GB（）。
A:1024B:2048C:2000D:1000答案:B4.大数据包含下面类型（）。
A:非结构化数据B:结构化数据C:纯文本数据D:半结构化数据答案:ABCD5.大数据的生命周期一般会经历这么几个阶段（）。
A:可视化B:采集与预处理C:分析与挖掘D:存储与管理答案:ABCD6.大数据平台的基本架构，从技术架构的角度，可划分为这几个层次（）。
A:服务封装层B:数据处理层C:数据存储层D:数据采集层答案:ABCD7.linux系统中cd命令的作用是（）。
A:移动文件或修改文件名B:将源文件复制至目标文件C:进入指定目录D:删除一个目录中的一个或多个文件答案:C8.vi编辑器的操作模式共分为（）。
A:输入模式B:命令模式C:底线命令模式D:编辑模式答案:BCD第二章测试1.Flume的Agent包含这些组成部分（）。
A:SinkB:EventC:SourceD:Channel答案:ACD2.Event由这两部分组成（）。
A:BodyB:HeadC:ArrayD:K-V答案:AB3.Source是Flume中事件的源头，负责接收数据到Flume Agent，可以处理多种类型、多种格式的数据（）A:对B:错答案:A4.Channel是位于Source和Sink之间的缓冲区，对Source和Sink进行一对一处理（）A:错B:对答案:A5.在Flume的配置文件中，对某个目录下文件进行监控的命令是（）。
A:flume-ngB:/bin/bash -cC:execD:tail -f答案:D第三章测试1.以下说法有误的是（）。
A:“元数据”中不包含真正的文件数据B:分布式存储系统需要考虑数据的分块问题C:分布式存储系统可以实现数据容灾D:传统单机存储方式扩容成本较低答案:D2.Hadoop 2.x中HDFS默认的block的大小为（）。
Spark Core技术平台详解
println("Input had " + badLinesRDD.count() + " concerning lines")
An RDD has enough information about how it was derived from other datasets(its lineage)
val rdd = sc.textFile("hdfs://***") rdd.persist(StorageLevel.MEMORY_AND_D ISK_SER) rdd.filter(...).count rdd.filter(...).count
Spark 优化——代码
合理使用broadcast——map join
Spark 优化——代码
尽量减少shuffle，如reduceByKey、join 能使用reduceByKey，不用groupByKey 合理使用coalesce，如filter后
Spark 优化——参数
Driver进程内存 Driver进程CPU Executor进程内存
运行task，Executor总内存20% shuffle进行聚合，Executor总内存20% RDD持久化，Executor总内存60% Executor进程CPU core数影响并行执行的 task数量
Spark RDD Lineage
val inputRDD = sc.textFile("log.txt")
val errorsRDD = inputRDD.filter(line => line.contains("error"))
Spark编程基础Python版-第8章-Spark-MLlib
8.2.2 流水线工作过程
• 流水线的各个阶段按顺序运行，输入的DataFrame在 它通过每个阶段时被转换
《Spark编程基础(Python版)》
8.2.2 流水线工作过程
值得注意的是，流水线本身也可以看做是一个估计器。在 流水线的fit（）方法运行之后，它产生一个PipelineModel， 它是一个Transformer。 这个管道模型将在测试数据的时 候使用。 下图说明了这种用法。
《Spark编程基础(Python版)》
8.1.3 Spark 机器学习库MLlib
•需要注意的是，MLlib中只包含能够在集群上运行良好 的并行算法，这一点很重要 •有些经典的机器学习算法没有包含在其中，就是因为它 们不能并行执行 •相反地，一些较新的研究得出的算法因为适用于集群， 也被包含在MLlib中，例如分布式随机森林算法、最小交 替二乘算法。这样的选择使得MLlib中的每一个算法都适 用于大规模数据集 •如果是小规模数据集上训练各机器学习模型，最好还是 在各个节点上使用单节点的机器学习算法库（比如Weka）
《Spark编程基础(Python版)》
8.2.1 机器学习流水线概念
Transformer：翻译成转换器，是一种可以将一个 DataFrame转换为另一个DataFrame的算法。比如一个模 型就是一个 Transformer。它可以把一个不包含预测标签 的测试数据集 DataFrame 打上标签，转化成另一个包含 预测标签的 DataFrame。 技术上，Transformer实现了一个方法transform()，它通 过附加一个或多个列将一个DataFrame转换为另一个 DataFrame
《Spark编程基础(Python版)》
Spark大数据分析与实战：RDD编程初级实践Spark大数据分析与实战：RDD编程初级实践
Spark⼤数据分析与实战：RDD编程初级实践Spark⼤数据分析与实战：RDD编程初级实践Spark⼤数据分析与实战：RDD编程初级实践⼀、安装Hadoop和Spark具体的安装过程在我以前的博客⾥⾯有，⼤家可以通过以下链接进⼊操作：** 提⽰：如果IDEA未构建Spark项⽬，可以转接到以下的博客： **⼆、启动Hadoop与Spark查看3个节点的进程master slave1 slave2Spark shell命令界⾯与端⼝页⾯三、spark-shell交互式编程请到教程官⽹的“下载专区”的“数据集”中下载chapter5-data1.txt，该数据集包含了某⼤学计算机系的成绩，数据格式如下所⽰： Tom,DataBase,80 Tom,Algorithm,50 Tom,DataStructure,60 Jim,DataBase,90 Jim,Algorithm,60 Jim,DataStructure,80 …… 请根据给定的实验数据，在spark-shell中通过编程来计算以下内容：** 如果找不到数据可以从这下载：数据集链接：提取码：z49l **（1）该系总共有多少学⽣；shell命令：val lines = sc.textFile("file:///opt/software/Data01.txt")lines.map(row=>row.split(",")(0)).distinct().count运⾏截图：（2）该系共开设来多少门课程；shell命令：lines.map(row=>row.split(",")(1)).distinct().count运⾏截图：（3）Tom同学的总成绩平均分是多少；shell命令：lines.filter(row=>row.split(",")(0)=="Tom").map(row=>(row.split(",")(0),row.split(",")(2).toInt)) .mapValues(x=>(x,1)).reduceByKey((x,y) => (x._1+y._1,x._2 + y._2)).mapValues(x => (x._1 / x._2)).collect()运⾏截图：（4）求每名同学的选修的课程门数；shell命令：lines.map(row=>(row.split(",")(0),1)).reduceByKey((x,y)=>x+y).collect运⾏截图：（5）该系DataBase课程共有多少⼈选修；shell命令：lines.filter(row=>row.split(",")(1)=="DataBase").count运⾏截图：（6）各门课程的平均分是多少；shell命令：lines.map(row=>(row.split(",")(1),row.split(",")(2).toInt)).mapValues(x=>(x,1)).reduceByKey((x,y) => (x._1+y._1,x._2 + y._2)).mapValues(x => (x._1 / x._2)).collect()运⾏截图：（7）使⽤累加器计算共有多少⼈选了DataBase这门课。
Spark大数据技术与应用智慧树知到课后章节答案2023年下山西职业技术学院
Spark大数据技术与应用智慧树知到课后章节答案2023年下山西职业技术学院山西职业技术学院绪论单元测试1.大数据的起源是以下哪个领域（）A:互联网 B:金融 C:公共管理 D:电信答案:互联网第一章测试1.与MapReduce相比，Spark更适合处理以下哪种类型的任务（）A:较少迭代次数的长任务 B:较少迭代次数的短任务 C:较多迭代次数的短任务 D:较多迭代次数的长任务答案:较多迭代次数的短任务2.Standalone模式下配置Spark集群时，master节点的工作端口号需要在conf文件夹下的哪个文件指明（）A:regionserver B:slaves C:spark-defaults.conf D:spark-env.sh答案:spark-env.sh3.以下关于SPARK中的spark context，描述错误的是：（）A:可以控制dagsheduler组件 B:可以控制task scheduler组件 C:控制整个application的生命周期 D:SparkContext为Spark的主要入口点答案:控制整个application的生命周期4.以下对Spark中Work的主要工作描述错误的是（）A:不会运行业务逻辑代码 B:会运行业务逻辑代码 C:管理当前节点内存 D:接收master分配过来的资源指令答案:会运行业务逻辑代码5.配置Standalone模式下的Spark集群，Worker节点需要在conf文件夹下的哪个文件中指明（）A:spark-env.sh B:spark-defaults.conf C:slaves D:regionserver答案:slaves6.Spark支持的分布式部署方式中哪个是错误的（）A:Spark on local B:spark on YARN C:spark on mesos D:standalone答案:Spark on local7.Spark单机伪分布式模式，它的特点是在一台节点上既有Master服务，又有Worker服务（）A:对 B:错答案:对8.在部署Spark独立模式时，配置spark内部通信的端口为（）A:16010 B:7070 C:9870 D:7077答案:70779.在部署Spark独立模式时，配置spark的web端口为（）A:7077 B:8080 C:9870 D:4040答案:707710.Spark的bin目录是spark运行脚本目录，该目录中包含了加载spark的配置信息，提交作业等执行命令的脚本（）A:错 B:对答案:对第二章测试1.valrdd=sc.parallelize(1 to 10).filter(_%2== 0)rdd.collect上述代码的执行结果为（）A:Array(1, 3, 5,7,9) B:Array(2, 4, 6, 8, 10) C:Array(1,2,3,4,5,6,7,8,9,10)D:Array(1,10)答案:Array(2, 4, 6, 8, 10)2.下面哪个操作是窄依赖（）A:filter B:sort C:group D:join答案:filter3.下面哪个操作肯定是宽依赖（）A:map B:sample C:flatMap D:reduceByKey答案:reduceByKey4.以下操作中，哪个不是Spark RDD编程中的操作。
Spark性能调优-RDD算子调优篇
Spark性能调优-RDD算子调优篇Spark调优之RDD算子调优不废话，直接进入正题！1. RDD复用在对RDD进行算子时，要避免相同的算子和计算逻辑之下对RDD进行重复的计算，如下图所示：对上图中的RDD计算架构进行修改，得到如下图所示的优化结果：2. 尽早filter获取到初始RDD后，应该考虑尽早地过滤掉不需要的数据，进而减少对内存的占用，从而提升Spark作业的运行效率。
3. 读取大量小文件-用wholeTextFiles当我们将一个文本文件读取为 RDD 时，输入的每一行都会成为RDD的一个元素。
也可以将多个完整的文本文件一次性读取为一个pairRDD，其中键是文件名，值是文件内容。
val input:RDD[String] = sc.textFile("dir/*.log")如果传递目录，则将目录下的所有文件读取作为RDD。
文件路径支持通配符。
但是这样对于大量的小文件读取效率并不高，应该使用wholeTextFiles返回值为RDD[(String, String)]，其中Key是文件的名称，Value是文件的内容。
def wholeTextFiles(path: String, minPartitions: Int = defaultMinPartitions): RDD[(String, String)])wholeTextFiles读取小文件:val filesRDD: RDD[(String, String)] =sc.wholeTextFiles("D:\\data\\files", minPartitions = 3)val linesRDD: RDD[String] = filesRDD.flatMap(_._2.split("\\r\\n"))val wordsRDD: RDD[String] = linesRDD.flatMap(_.split(" "))wordsRDD.map((_, 1)).reduceByKey(_ + _).collect().foreach(println)4. mapPartition和foreachPartition•mapPartitionsmap(_….) 表示每一个元素mapPartitions(_….) 表示每个分区的数据组成的迭代器普通的map算子对RDD中的每一个元素进行操作，而mapPartitions算子对RDD中每一个分区进行操作。
Spark键值对RDD操作
Spark键值对RDD操作键值对的RDD操作与基本RDD操作⼀样，只是操作的元素由基本类型改为⼆元组。
概述键值对RDD是Spark操作中最常⽤的RDD，它是很多程序的构成要素，因为他们提供了并⾏操作各个键或跨界点重新进⾏数据分组的操作接⼝。
创建Spark中有许多中创建键值对RDD的⽅式，其中包括⽂件读取时直接返回键值对RDD通过List创建键值对RDD在Scala中，可通过Map函数⽣成⼆元组val listRDD = sc.parallelize(List(1,2,3,4,5))val result = listRDD.map(x => (x,1))result.foreach(println)//结果(1,1)(2,1)(3,1)(4,1)(5,1)键值对RDD的转化操作基本RDD转化操作在此同样适⽤。
但因为键值对RDD中包含的是⼀个个⼆元组，所以需要传递的函数会由原来的操作单个元素改为操作⼆元组。
下表总结了针对单个键值对RDD的转化操作，以 { (1,2) , (3,4) , (3,6) }为例，f表⽰传⼊的函数函数名⽬的⽰例结果reduceByKey(f)合并具有相同key的值rdd.reduceByKey( ( x,y) => x+y){ (1,2) , (3,10) }groupByKey()对具有相同key的值分组rdd.groupByKey(){ (1,2) , (3, [4,6] ) }mapValues(f)对键值对中的每个值(value)应⽤⼀个函数，但不改变键(key)rdd.mapValues(x => x+1){ (1,3) , (3,5) , (3,7) }combineBy Key( createCombiner, mergeValue, mergeCombiners, partitioner)使⽤不同的返回类型合并具有相同键的值下⾯有详细讲解-flatMapValues(f)对键值对RDD中每个值应⽤返回⼀个迭代器的函数，然后对每个元素⽣成⼀个对应的键值对。
Spark中的键值对操作
Spark中的键值对操作1.PairRDD介绍Spark为包含键值对类型的RDD提供了⼀些专有的操作。
这些RDD被称为PairRDD。
PairRDD提供了并⾏操作各个键或跨节点重新进⾏数据分组的操作接⼝。
例如，PairRDD提供了reduceByKey()⽅法，可以分别规约每个键对应的数据，还有join()⽅法，可以把两个RDD中键相同的元素组合在⼀起，合并为⼀个RDD。
2.创建Pair RDD程序⽰例：对⼀个英语单词组成的⽂本⾏，提取其中的第⼀个单词作为key，将整个句⼦作为value，建⽴ PairRDDList<String> list=new ArrayList<String>();list.add("this is a test");list.add("how are you?");list.add("do you love me?");list.add("can you tell me?");JavaRDD<String> lines=sc.parallelize(list);JavaPairRDD<String,String> map =lines.mapToPair(new PairFunction<String, String, String>() {public Tuple2<String, String> call(String s) throws Exception {return new Tuple2<String, String>(s.split(" ")[0],s);//获取第⼀个单词作为key,s为value}});3.PairRDD的转化操作PairRDD可以使⽤所有标准RDD上可⽤的转化操作。
Spark笔记：RDD基本操作（下）
Spark笔记：RDD基本操作（下） 上⼀篇⾥我提到可以把RDD当作⼀个数组，这样我们在学习spark的API时候很多问题就能很好理解了。
上篇⽂章⾥的API也都是基于RDD是数组的数据模型⽽进⾏操作的。
Spark是⼀个计算框架，是对mapreduce计算框架的改进，mapreduce计算框架是基于键值对也就是map的形式，之所以使⽤键值对是⼈们发现世界上⼤部分计算都可以使⽤map这样的简单计算模型进⾏计算。
但是Spark⾥的计算模型却是数组形式，RDD如何处理Map的数据格式了？本篇⽂章就主要讲解RDD是如何处理Map的数据格式。
Pair RDD及键值对RDD，Spark⾥创建Pair RDD也是可以通过两种途径，⼀种是从内存⾥读取，⼀种是从⽂件读取。
⾸先是从⽂件读取，上篇⾥我们看到使⽤textFile⽅法读取⽂件，读取的⽂件是按⾏组织成⼀个数组，要让其变成map格式就的进⾏转化，代码如下所⽰：/** 测试⽂件数据:* x01,1,4x02,11,1 x01,3,9 x01,2,6x02,18,12x03,7,9** */val rddFile:RDD[(String,String)] = sc.textFile("file:///F:/sparkdata01.txt", 1).map { x => (x.split(",")(0),x.split(",")(1) + "," + x.split(",")(2)) }val rFile:RDD[String] = rddFile.keysprintln("=========createPairMap File=========")println(rFile.collect().mkString(","))// x01,x02,x01,x01,x02,x03println("=========createPairMap File=========") 我们由此可以看到以读取⽂件⽅式构造RDD，我们需要使⽤map函数进⾏转化，让其变成map的形式。
SparkCore的常用算子
SparkCore的常⽤算⼦SparkCore算⼦简介SparkCore中的算⼦可以分为2类：Transformations Operation 和 Action Operation在Spark的提交过程中，会将RDD及作⽤于其上的⼀系列算⼦（即：RDD及其之间的依赖关系）构建成⼀个DAG有向⽆环视图。
当遇到action算⼦的时候就会触发⼀个job的提交，⽽Driver程序则会将触发的job提交给DAGScheduler，由DAGSchedule将job构建成⼀张DAG因此，action类算⼦就是spark application程序分为job的依据，也就是触发job提交的决定性因素Spark的RDD空间Stage：stage是对job的划分，遇到shuffle就划分，⼀个stage有多个tasks，同⼀个job间的stage具有依赖关系，前者必须结束才能进⾏后者的计算。
RDD的创建（1）通过集合创建ＲＤＤ，主要⽤于进⾏测试，可以在实际部署到集群运⾏之前，⾃⼰使⽤集合构造测试数据，来测试后⾯的spark应⽤的流程（２）使⽤本地⽂件创建RDD ，在本地临时性地处理⼀些存储了⼤量数据的⽂件（3）HDFS⽂件创建RDD，主要⽤于测试⼤量数据其实本地创建RDD和HDFS⽂件创建RDD是⼀样的，只是在路径上，要指明是HDFShdfs://spark1:9000/data.txtscala> val linesLength = sc.textFile("hdfs://spark1:9000/rdd.txt").map(line => line.length).reduce(_+_)linesLength: Int=9常⽤的算⼦将worker / executor中的RDD数据或其计算数据拉取到Driver程序中来，形成Scala的集合或变量的操作算⼦描述collect()⽆参，以数组的形式返回RDD中的所有的元素：本质上：是将executor中运算得到的RDD--->拉取到Driver程序中来，形成Scala的集合take(n)返回RDD中的前n个元素，⽆参时，默认为前10个takeOrdered(n, [ordering])和top类似，先排序（升序/降序），再取前n，不过获取的元素的顺序与top相反takeSample(withReplacement, num, [seed])返回⼀个随机采样数组，该数组由从RDD中采样获得，可以选择是否⽤随机数来替换不⾜的部分，seed⽤于指定随机数⽣成器的种⼦first()返回RDD的第⼀个元素（并不⼀定是最⼤的，看RDD是否排序，类似于take(1)）top(n)返回由RDD前n个最⼤的元素构成的数组（最⼤：元素具备可⽐性，默认取字典顺序最⼤的）reduce(func)通过func函数来聚集RDD中的所有元素，且要求func必须满⾜：1.可交换；2.可并联。
Spark之RDD容错原理及四大核心要点
Spark之RDD容错原理及四⼤核⼼要点⼀、Spark RDD容错原理 RDD不同的依赖关系导致Spark对不同的依赖关系有不同的处理⽅式。
对于宽依赖⽽⾔，由于宽依赖实质是指⽗RDD的⼀个分区会对应⼀个⼦RDD的多个分区，在此情况下出现部分计算结果丢失，单⼀计算丢失的数据⽆法达到效果，便采⽤重新计算该步骤中的所有数据，从⽽会导致计算数据重复；对于窄依赖⽽⾔，由于窄依赖实质是指⽗RDD的分区最多被⼀个⼦RDD使⽤，在此情况下出现部分计算的错误，由于计算结果的数据只与依赖的⽗RDD的相关数据有关，所以不需要重新计算所有数据，只重新计算出错部分的数据即可。
⼆、RDD容错的四⼤核⼼要点 Spark框架层⾯的容错机制，主要分为三⼤层⾯（调度层、RDD⾎统层、Checkpoint层），在这三⼤层⾯中包括Spark RDD容错四⼤核⼼要点。
（1）Stage输出失败，上层调度器DAGScheduler重试。
（2）Spark计算中，Task内部任务失败，底层调度器重试。
（3）RDD Lineage⾎统中窄依赖、宽依赖计算。
（4）Checkpoint缓存。
1．调度层（包含DAG⽣成和Task重算两⼤核⼼） 从调度层⾯讲，错误主要出现在两个⽅⾯，分别是在Stage输出时出错和在计算时出错。
1）DAG⽣成层 Stage输出失败，上层调度器DAGScheduler会进⾏重试，DAGScheduler.scala的resubmitFailedStages的源码如下。
/*** Resubmit any failed stages. Ordinarily called after a small amount of time has passed since* the last fetch failure.*/private[scheduler] def resubmitFailedStages() {// 判断是否存在失败的Stagesif (failedStages.size > 0) {// Failed stages may be removed by job cancellation, so failed might be empty even if// the ResubmitFailedStages event has been scheduled.// 失败的阶段可以通过作业取消删除，如果ResubmitFailedStages事件已调度，失败将是空值logInfo("Resubmitting failed stages")clearCacheLocs()// 获取所有失败Stage的列表val failedStagesCopy = failedStages.toArray// 清空failedStagesfailedStages.clear()// 对之前获取所有失败的Stage，根据jobId排序后逐⼀重试for (stage <- failedStagesCopy.sortBy(_.firstJobId)) {submitStage(stage)}}submitWaitingStages()} 2）Task计算层 Spark计算过程中，计算内部某个Task任务出现失败，底层调度器会对此Task进⾏若⼲次重试（默认4次）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据排序
• sortByKey
• 很多时候，让数据排好序是很有用的，如果键有已定义的顺序，就可 以对这种键值对RDD进行排序。
• sortByKey() 函数接收一个boolean的参数，表示我们是否想要让结
果按升序排序（默认值为 true）。
Pair RDD行动操作
• countByKey
– 对每个键对应的元素分别计数
• 在Scala中使用第一个单词作为键创建出一个pair RDD：
• 在 Scala中，为了让提取键之后的数据能够在函数中使用，需要返回 二元组。隐式转换可以让二元组RDD支持附加的键值对函数。
创建Pair RDD 2
• 在Java中使用第一个单词作为键创建出一个pair RDD：
• •
Java没有自带的二元组类型，因此Spark的Java API让用户使用Tuple2类来创建二元组。 并且可以通过._1()和._2()方法访问其中的元素。
统计是很常见的操作。 • reduceByKey
• reduceByKey()与reduce()相当类似，它们都接收一个函数，并使用
该函数对值进行合并。 • reduceByKey()会把数据集中将键相同的值合并起来，它会返回一个 由各键和对应键合并出来的结果值组成的新的RDD。
单集合转化Pair RDD 3-2
SparkCore
键值对
本 键值对概述 创建Pair RDD 章 单集合转化Pair RDD 多集合转化Pair RDD 内 数据的分组和排序 RDD行动操作 容
键值对概述
• 键值对RDD是Spark中许多操作所需要的常见数据类型。键值对RDD
通常用来进行聚合计算。 • Spark为包含键值对类型的RDD提供了一些专有的操作，这些RDD被
创建Pair RDD 3
• 我们也可以从一个内存中的数据集创建pair RDD。
• 使用Scala的从内存中pair RDD：
• 使用Java，需要把parallelize替换为parallelizePairs
单集合转化Pair RDD 1-1
• filter
• Pair RDD可以使用所有标准RDD上的可用的转化操作，由于 pair RDD中包含二元组，所以需要传递的函数应当操作二元组而不是独立
countByValue、combineByKey等。
常用的多集合操作包括join、leftOuterJoin、rightOuterJoin等。 我们可以通过groupByKey对数据分组，通过sortByKey对数据排序。 和转化操作一样，所有基础RDD支持的传统行动操作也都在pair RDD上可用。 和转化操作一样，所有基础RDD支持的传统行动操作也都在pair RDD上可用。
的元素。
• 使用filter函数，我们可以转化得到一个Pair RDD。
单集合转化Pair RDD 1-2
单集合转化Pair RDD 2•Fra bibliotekmapValues
• 就像map一样，如果我们只想使用values部分，我们可以使用 mapValues。
单集合转化Pair RDD 3-1
• 当数据集以键值对形式组织的时候，聚合具有相同键的元素进行一些
• lookup
– 返回给定键对应的所有值
总结
• • • • • • • 键值对RDD是Spark中许多操作所需要的常见数据类型。键值对RDD 通常用来进 行聚合计算。 Pair RDD可以通过磁盘文件创建，也可以通过内存创建。 单集合转化Pair RDD常用的函数有filter、mapValues、reduceByKey、
多集合转化Pair RDD 2
数据分组
• groupByKey
• 对于有键的数据，一个常见的用例是将数据根据键进行分组，比如查 看一个顾客的所有订单。
• groupByKey可以对已经提取了键的RDD中的键来对数据进行分组。
• 对于一个由类型K的键和类型V的值组成的RDD，所得到的结果RDD 类型会是[K, Iterable[V]]。
每一组相对应的记录。
多集合转化Pair RDD 1-2
• leftOuterJoin
• rightOuterJoin • 有时，我们不希望结果中的键必须在两个RDD中都存在，
leftOuterJoin(other)和rightOuterJoin(other) 都会根据键连接两个
RDD，但是允许结果中存在其中的一个pair RDD所缺失的键。
•
需要注意的是，这一过程会在每个分区中发生，而不是在整个RDD中发
生，由于每个分区都是独立处理的，因此对于同一个键可以有多个累加 器，就需要使用用户提供的 mergeCombiners() 方法将各个分区的结果 进行合并。
单集合转化Pair RDD 4-2
• 求每个键对应的平均值
单集合转化Pair RDD 4-3
称为Pair RDD。
• Pair RDD是很多程序的构成要素，因为它们提供了并行操作各个键或 跨节点重新进行数据分组的操作接口。
创建Pair RDD 1
• Spark中有很多种创建pair RDD的方式。当需要把一个普通的RDD
转为pair RDD时，可以调用map()函数来实现，传递的函数需要返回 键值对。
单集合转化Pair RDD 5-2
单集合转化Pair RDD 5-3
多集合转化Pair RDD 1-1
• join
• 连接数据可能是pair RDD最常用的操作之一。 • join操作符表示内连接，只有在两个pair RDD中都存在的键才输出。
• 当某个键有多个值时，生成的pair RDD会包括来自两个输入 RDD 的
单集合转化Pair RDD 4-4
单集合转化Pair RDD 4-5
单集合转化Pair RDD 4-6
单集合转化Pair RDD 5-1
• Pair RDD可以使用所有标准RDD上的可用的转化操作，由于 pair
RDD中包含二元组，所以需要传递的函数应当操作二元组而不是独立 的元素。
• Pair RDD的转化操作（以键值对集合{(1, 2), (3, 4), (3, 6)}为例）
• Spark有一个countByValue函数，速度更快。
单集合转化Pair RDD 4-1
• • • combineByKey combineByKey是最为常用的基于键进行聚合的函数，它可以让用户返 回与输入数据的类型不同的返回值。 combineByKey遍历分区中的所有元素时，如果这是一个新的元素， combineByKey会创建（createCombiner）那个键对应的累加器的初始 值。如果这是一个在处理当前分区之前已经遇到的键，它会将该键的累 加器对应的当前值与这个新的值进行合并（mergeValue）。