Spark学习总结

1、Spark简介

Spark是基于内存计算的通用大规模数据处理框架。Spark已经融入了Hadoop生态系统,可支持的作业类型和应用场景比MapReduce 更为广泛,并且具备了MapReduce所有的高容错性和高伸缩性特点。Spark支持离线批处理、流式计算和实时分析。

2、Spark为何快

   MapReduce慢的原因:

  • 多个MapReduce串联执行时,依赖于HDFS输出的中间结果
  • MapReduce在处理复杂的DAG(有向无环图)时会产生大量的数据序列化、数据copy和磁盘I/O开销

   Spark快的原因:

  • Spark基于内存,尽可能的减少了中间结果写入磁盘和不必要的sort、shuffle
  • Spark对于反复用到的数据进行了缓存
  • Spark对于DAG进行了高度的优化,具体在于Spark划分了不同的stage和使用了延迟计算技术

3、弹性数据分布集RDD

Spark将数据保存分布式内存中,对分布式内存的抽象理解,提供了一个高度受限的内存模型,他是逻辑上集中,物理上是存储再集群的堕胎机器上。

4、RDD的属性和特点

   只读

  • 通过HDFS或者其他持久化系统创建RDD
  • 通过transformation将父RDD转换得到新的RDD
  • RDD上保存着前后之间的依赖关系

   Partition

  • 基本组成单位,RDD在逻辑上按照Partition分块
  • 分布在各个节点,分片个数决定并行计算的粒度
  • RDD保存如何计算每个分区的函数

   容错

  • 失败后可自动创建
  • 如果发生部分分区数据丢失,可以通过依赖关系重新计算

   RDD的创建

  • var lines = sc.textFile("文件路径")//sc是SparkContent对象
  • lines.filter(x => x.contains("error")).count()//filter是transformation算子不触发计算,count是action算子,会触发计算

Spark学习总结_第1张图片

5、RDD的窄依赖和宽依赖

   窄依赖:没有数据的shuffling,所有的父RDD的partition会一一映射到子RDD的partition中

Spark学习总结_第2张图片

   宽依赖:发生数据的shuffling,父RDD中的partition会根据key的不同进行切分,划分到子RDD中对应的partition中

Spark学习总结_第3张图片

6、stage

  • 什么是stage:一个job会被拆分成多组task,每组task为一个stage
  • 划分依据:是否有数据shuffle,遇到宽依赖则划分一个stage,划分顺序为从后往前划分
  • stage执行优化:对窄依赖进行流水线划分、相互依赖的stage必须要等到依赖的执行后再执行不依赖的可以并行执行、stage的执行成都和资源有关

Spark学习总结_第4张图片

7、Spark的执行流程

  1. 用户创建Spark程序并提交
  2. 每个action会生成一个job,包含了一系列的RDD和对其如何进行操作的transformation
  3. 每个job生成一个DAG(有向无环图)
  4. DAGScheduler根据宽依赖对DAG进行划分stage并生成task组(一个stage对应一组task,一个partition对应一个task)
  5. Spark集群在worker上以一组Task为单位进行执行计算

Spark学习总结_第5张图片

8、Spark编程模型

   四种类型算子:

  • create:SparkContext.textFile(...)、SparkContext.parallelize(...)
  • transformation:作用于一个或多个RDD,输出转换后的RDD。如:map、flatMap、filter
  • action:触发RDD的执行结果,触发Spark提交作业将结果返回。如:count、countByKey
  • cache:cache缓存和persist持久化

   惰性运算:遇到action算子才会计算

   运行Spark的方式:在CDH集群使用Spark-Shell、使用Spark-Submit提交作业

9、Spark内存结构

     Spark运行在yarn中,运行内存受NodeManager管理的容器的大小限制,设置运行内存的时候,大小要小于容器的大小。Executors的内存又分为off-heap和heap,off-heap存放创建java对象的额外开销、native方法的调用和NIO Buffer,heap的大小受spark共享。

    heap共享内存中可以分为三部分:reserved memory 、user memory 、Spark memory。reserved memory默认为300M,不可以比这个小;user memory存放的是用户定义的数据结构和Spark元数据,占用剩余25%;Spark memory可分为storage memory和Execution memory,两部分空间可相互借用,storage memory存储缓存的数据,Execution memory用于存储执行过程的中间object和shuff的结构。

Spark学习总结_第6张图片

Spark学习总结_第7张图片

10、面对OOM(内存溢出)问题的解决方法及优化

   OOM产生原因

  • Map执行中内存溢出:map执行中内存溢出代表了所有map类型的操作,包括:flatMap,filter,mapPatitions等。
  • shuffle后内存溢出:shuffle后内存溢出的shuffle操作包括join,reduceByKey,repartition等操作。

   内存溢出解决方法:

  1. map过程产生大量对象导致内存溢出:这种溢出的原因是在单个map中产生了大量的对象导致的,针对这种问题,在不增加内存的情况下,可以通过减少每个Task的大小,以便达到每个Task即使产生大量的对象Executor的内存也能够装得下。具体做法可以在会产生大量对象的map操作之前调用repartition方法,分区成更小的块传入map。例如:rdd.repartition(10000).map(x=>for(i <- 1 to 10000) yield i.toString)。面对这种问题注意,不能使用rdd.coalesce方法,这个方法只能减少分区,不能增加分区,不会有shuffle的过程。
  2. 数据不平衡导致内存溢出:数据不平衡除了有可能导致内存溢出外,也有可能导致性能的问题,解决方法和上面说的类似,就是调用repartition重新分区。
  3. coalesce调用导致内存溢出:coalesce并不是shuffle操作,这意味着coalesce并不是按照我原本想的那样先执行100个Task,再将Task的执行结果合并成10个,而是从头到位只有10个Task在执行,原本100个文件是分开执行的,现在每个Task同时一次读取10个文件,使用的内存是原来的10倍,这导致了OOM。可以通过repartition解决,调用repartition(10),因为这就有一个shuffle的过程,shuffle前后是两个Stage,一个100个分区,一个是10个分区,就能按照我们的想法执行。
  4. shuffle后内存溢出:shuffle内存溢出的情况可以说都是shuffle后,单个文件过大导致的。在Spark中,join,reduceByKey这一类型的过程,都会有shuffle的过程,在shuffle的使用,需要传入一个partitioner,大部分Spark中的shuffle操作,默认的partitioner都是HashPatitioner,默认值是父RDD中最大的分区数,这个参数通过spark.default.parallelism控制(在spark-sql中用spark.sql.shuffle.partitions) , spark.default.parallelism参数只对HashPartitioner有效,所以如果是别的Partitioner或者自己实现的Partitioner就不能使用spark.default.parallelism这个参数来控制shuffle的并发量了。如果是别的partitioner导致的shuffle内存溢出,就需要从partitioner的代码增加partitions的数量。
  5. standalone模式下资源分配不均匀导致内存溢出:在standalone的模式下如果配置了--total-executor-cores 和 --executor-memory 这两个参数,但是没有配置--executor-cores这个参数的话,就有可能导致,每个Executor的memory是一样的,但是cores的数量不同,那么在cores数量多的Executor中,由于能够同时执行多个Task,就容易导致内存溢出的情况。这种情况的解决方法就是同时配置--executor-cores或者spark.executor.cores参数,确保Executor资源分配均匀。

   代码优化:

  1. 使用mapPartitions代替大部分map操作,或者连续使用的map操作。
  2. broadcast join和普通join:在大数据分布式系统中,大量数据的移动对性能的影响也是巨大的。基于这个思想,在两个RDD进行join操作的时候,如果其中一个RDD相对小很多,可以将小的RDD进行collect操作然后设置为broadcast变量,这样做之后,另一个RDD就可以使用map操作进行join,这样能够有效的减少相对大很多的那个RDD的数据移动。
  3. 先filter在join:这个就是谓词下推,这个很显然,filter之后再join,shuffle的数据量会减少
  4. groupByKey转换为reduceByKey 
  5. 在内存不足的使用,使用rdd.persist(StorageLevel.MEMORY_AND_DISK_SER)代替rdd.cache(): rdd.cache()和rdd.persist(Storage.MEMORY_ONLY)是等价的,在内存不足的时候rdd.cache()的数据会丢失,再次使用的时候会重算,而rdd.persist(StorageLevel.MEMORY_AND_DISK_SER)在内存不足的时候会存储在磁盘,避免重算,只是消耗点IO时间。
  6. 在spark使用hbase的时候,spark和hbase搭建在同一个集群

   参数优化:

  1. spark.driver.memory (default 1g):这个参数用来设置Driver的内存。在Spark程序中,SparkContext,DAGScheduler都是运行在Driver端的。对应rdd的Stage切分也是在Driver端运行,如果用户自己写的程序有过多的步骤,切分出过多的Stage,这部分信息消耗的是Driver的内存,这个时候就需要调大Driver的内存。
  2. spark.rdd.compress (default false) :这个参数在内存吃紧的时候,又需要persist数据有良好的性能,就可以设置这个参数为true,这样在使用persist(StorageLevel.MEMORY_ONLY_SER)的时候,就能够压缩内存中的rdd数据。减少内存消耗,就是在使用的时候会占用CPU的解压时间。
  3. spark.memory.storageFraction (default 0.5):这个参数设置内存表示 Executor内存中 storage/(storage+execution),虽然spark-1.6.0+的版本内存storage和execution的内存已经是可以互相借用的了,但是借用和赎回也是需要消耗性能的,所以如果明知道程序中storage是多是少就可以调节一下这个参数。
  4. spark.speculation (default false): 一个大的集群中,每个节点的性能会有差异,spark.speculation这个参数表示空闲的资源节点会不会尝试执行还在运行,并且运行时间过长的Task,避免单个节点运行速度过慢导致整个任务卡在一个节点上。这个参数最好设置为true。与之相配合可以一起设置的参数有spark.speculation.×开头的参数。参考中有文章详细说明这个参数。

 

 

 

 

 

你可能感兴趣的:(Spark学习总结)