第14课：spark RDD弹性表现和来源，容错

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u012036736/article/details/80214530

hadoop 的MapReduce是基于数据集的,位置感知，容错 负载均衡 
基于数据集的处理：从物理存储上加载数据，然后操作数据，然后写入物理存储设备； 
基于数据集的操作不适应的场景： 
1，不适合于大量的迭代 
2，交互式查询 
重点是：基于数据流的方式 不能够复用曾经的结果或者中间计算结果; 

spark RDD是基于工作集的 
工作流和工作集的共同特点：位置感知，自动容错，负载均衡等。 
spark的位置感知比hadoop的好很多，具体如下： 
hadoop位置感知：hadoop进行partition之后就不管Reducer在哪里了。 
spark的位置感知：spark进行partition后再进行下一步Stage时会确定其位置，是更精致化的。 
RDD：Resillient Distributed Dataset 
RDD的弹性表现: 
1、弹性之一：自动的进行内存和磁盘数据存储的切换； 
2、弹性之二：基于Lineage的高效容错（第n个节点出错，会从第n-1个节点恢复，血统容错）； 
3、弹性之三：Task如果失败会自动进行特定次数的重试（默认4次）； 
4、弹性之四：Stage如果失败会自动进行特定次数的重试（可以只运行计算失败的阶段）；只计算失败的数据分片； 
5、checkpoint和persist 
6、数据调度弹性：DAG TASK 和资源 管理无关 
7、数据分片的高度弹性(人工自由设置分片函数),repartition 

Spark RDD来源：1，使用程序中的集合创建RDD（用于小量测试）;  2，使用本地文件系统创建RDD（测试大数据）;  3，使用HDFS创建RDD（生产环境最常用的RDD创建方式）;  4，基于DB创建RDD;  5，基于NoSQL，例如HBase;  6，基于S3创建RDD;  7，基于数据流创建RDD; 前三种是比较基本的，后面4种是基于数据库的，要注意数据本地性（getPreferedLocations）; 

1.集合创建RDD方式 的Java代码  

1. package com.imf.spark.rdd  
2.   
3. import org.apache.spark.{SparkConf, SparkContext}  
4.   
5. /** 
6.   * Created by lujinyong168 on 2016/2/2. 
7.   * DT大数据梦工厂-IMF 
8.   * 使用程序中的集合创建RDD（用于小量测试） 
9.   */  
10. object RDDCreateByCollections {  
11. def main(args: Array[String]) {  
12. val conf = new SparkConf()//创建SparkConf对象  
13. conf.setAppName("RDDCreateByCollections")//设置应用名称  
14. conf.setMaster("local")  
15. val sc = new SparkContext(conf)//创建SparkContext对象  
16.     //创建一个Scala集合  
17. val numbers = 1 to 100  
18. val rdd = sc.parallelize(numbers)  
19. //    val rdd = sc.parallelize(numbers,10)//设置并行度为10  
20. val sum = rdd.reduce(_+_)  
21. println("1+2+3+...+99+100="+sum)  
22.   }  
23. }  

2.local模式创建RDD  的Java代码  

1. package com.imf.spark.rdd  
2.   
3. import org.apache.spark.{SparkConf, SparkContext}  
4.   
5. /** 
6.   * Created by lujinyong168 on 2016/2/2. 
7.   * DT大数据梦工厂-IMF 
8.   * 使用本地文件系统创建RDD（测试大量数据） 
9.   * 统计文本中的字符个数 
10.   */  
11. object RDDCreateByLocal {  
12. def main(args: Array[String]) {  
13. val conf = new SparkConf()//创建SparkConf对象  
14. conf.setAppName("RDDCreateByLocal")//设置应用名称  
15. conf.setMaster("local")  
16. val sc = new SparkContext(conf)//创建SparkContext对象  
17. val rdd = sc.textFile("D://testspark//WordCount.txt")  
18. val linesLen = rdd.map(line=>line.length)  
19. val sum = linesLen.reduce(_+_)  
20. println("The total characters of the file is : "+sum)  
21.   }  
22. }  

3.HDFS模式创建RDD  的Java代码  

1. package com.imf.spark.rdd  
2.   
3. import org.apache.spark.{SparkConf, SparkContext}  
4.   
5. /** 
6.   * Created by lujinyong168 on 2016/2/2. 
7.   * DT大数据梦工厂-IMF 
8.   * 使用HDFS创建RDD（生产环境最常用的RDD创建方式） 
9.   */  
10. object RDDCreateByHDFS {  
11. def main(args: Array[String]) {  
12. val conf = new SparkConf()//创建SparkConf对象  
13. conf.setAppName("RDDCreateByHDFS")//设置应用名称  
14. conf.setMaster("local")  
15. val sc = new SparkContext(conf)//创建SparkContext对象  
16. val rdd = sc.textFile("/library/")  
17. val linesLen = rdd.map(line=>line.length)  
18. val sum = linesLen.reduce(_+_)  
19. println("The total characters of the file is : "+sum)  
20.   }  
21. }  

4.对数据进行分片

使用coalesce，不要用repartition

Spark容错方式

a.数据检查点和记录数据的更新

数据检查点会每次都进行数据的靠背，这个需要很大的内存

rdd通过记录数据的更新的方式为什么会更高效？

1.rdd是不可变的，且加上lazy

   a.不存在全局修改的问题，控制难度就会大大下降，在此基础上有控制链条，如果有100个步骤，在第99个不走失败了，可以直接从第99个步骤上开始恢复

   b.对于rdd的操作写都是粗粒度的，rdd的读操作既可以是粗粒度的也可以是细粒度的

   c.lazy级别的进行链式展开式，不会产生那个多的中间结果

参考：

https://blog.csdn.net/zdy0_2004/article/details/50132509

https://www.cnblogs.com/dt-zhw/p/5664663.html

https://www.2cto.com/net/201711/697288.html

https://www.csdn.net/article/2015-06-21/2825011