spark优化

1：参考文档

（1）美团技术团队—>文章归档—>2016年4月份
Spark性能优化指南——基础篇
https://tech.meituan.com/2016/04/29/spark-tuning-basic.html
Spark性能优化指南——高级篇
https://tech.meituan.com/2016/05/12/spark-tuning-pro.html
（2）谷歌浏览器
chrome://flags/
搜索：html
设置：Save Page as MHTML将Disabled—>Enable

2：调优

总共分为四点
（1）开发调优
（2）资源调优
（3）数据倾斜
（4）shuffle

3：开发调优

原则一：避免创建重复的RDD
如果是需要对一个文件进行多次的计算，那么最好就只读一次。即对于同一份数据，只应该创建一个RDD，不能创建多个RDD来代表同一份数据。
原则二：尽可能复用同一个RDD
原则三：对多次使用的RDD进行持久化
程序中产生的中间结果是另一个程序需要使用的数据，那么可以把该数据持久化到内存或磁盘中；避免重复计算，直接从磁盘或者内存当中读取。
原则四：尽量避免使用shuffle类算子
shuffle操作有一个特点：就是上一个阶段必须全部执行完毕之后，下一个阶段才能执行。
能避免则尽可能避免使用reduceByKey、join、distinct、repartition等会进行shuffle的算子；
union、join(按照hash分区，分区数还成倍数，就没有shuffle)不会进行shuffle。
rdd1.join(rdd2) —>reduce join会进行shuffle操作；map join不会进行shuffle操作。
spark如何实现mapjoin?

val bc = sc.broadCast(rdd.toList)
rdd1.foreachPartition(data=>{
val data2 = bc.value //小表数据
val data1 = data //大表数的其中一个分区
data1.join(data2) //这个操作是在每个节点上独立执行的
})

原则五：使用map-side预聚合(combiner)的shuffle操作
shuffle类的算子的缺点数据倾斜，在使用shuffle操作的算子时，如果有map-side预聚合操作的话，那么shuffle的代价会小很多；降低数据倾斜的程度或者避免数据倾斜。
没有map-side预聚合的算子：
groupByKey 有shuffle没有聚合
coGroup
有预聚合的shuffle算子：
reduceByKey(相当于groupByKey + reduce)
combineByKey
aggregateByKey
原则六：使用高性能的算子
使用mapPartitions替代普通map

DStreams RDD
dstreams.foreatchRDD(rdd=>{
rdd.foreachPartition(ptn=>{
rdd.foreach(element=>{
connect.insert()
})
})
})

使用reduceByKey/aggregateByKey替代groupByKey
使用foreachPartitions替代foreach
使用filter之后进行coalesce操作
使用coalesce算子，手动减少RDD的partition数量，将RDD中的数据压缩到更少的partition中去。
使用repartitionAndSortWithinPartitions替代repartition与sort类操作
rdd.reparttition.sort先分区后进行排序
rdd.repartitionAndSortWithinPartitions分区和排序同时进行
原则七：广播大变量
目的是让多个task都要使用的在driver中声明的变量都要维持一个独立副本变成让这个executor中的所有task都公用一个副本。
原则是要广播的数据越大，进行广播这个操作得到的效果越好。如果executor的并发读越高，执行广播变量的收益越好。
效果是executor的内存占用量就减少；网络数据传输减少。
原则八：使用Kryo优化序列化性能
序列化：简单的说就是把一个对象变成010101数组；
反序列化：把01010101这中格式的数组还原成一个对象；
Java中创建对象的方式：构造器、静态工厂方法(私有了构造器)、反射、克隆、反序列化。
spark默认情况下支持Java的原生序列化机制；使用KyroSerializer，使用方式是：
// 设置序列化器为KryoSerializer。
conf.set(“spark.serializer”, “org.apache.spark.serializer.KryoSerializer”)
// 注册要序列化的自定义类型。
conf.registerKryoClasses(Array(classOf[MyClass1], classOf[MyClass2]))
原则九：优化数据结构
Java中，有三种类型比较耗费内存：
对象，每个Java对象都有对象头、引用等额外的信息，因此比较占用内存空间。
字符串，每个字符串内部都有一个字符数组以及长度等额外信息。
集合类型，比如HashMap、LinkedList等，因为集合类型内部通常会使用一些内部类来封装集合元素，比如Map.Entry。
优化措施是尽量不要使用上述三种数据结构：
尽量使用字符串替代对象；
使用原始类型（比如Int、Long）替代字符串；
使用数组替代集合类型，这样尽可能地减少内存占用，从而降低GC频率，提升性能。

4： shuffle调优

随机策略：某些业务结果求不出来
Hash策略：按照关键字的hash值进行分区
范围分区：阶梯（通过采样来避免）
数据倾斜发生的原理
产生的原因：shuffle数据之后导致数据的分布不均匀，数据量不一致，决定了task的执行时长。
数据倾斜发生时的现象
一个计算阶段中切分出来的多个计算任务处理的数据量不均衡，而导致这个阶段的计算时长有最缓慢的那个任务决定。最基本的标准是超过2倍或3倍以上。
如何定位导致数据倾斜的代码
（1）数据倾斜只会发生在shuffle过程中。常用的并且可能会触发shuffle操作的算子：distinct、groupByKey、reduceByKey、aggregateByKey、join、cogroup、repartition等。
（2）某个task执行特别慢的情况。
（3）某个task莫名其妙内存溢出的情况。
（4）查看导致数据倾斜的key的数据分布情况。
数据倾斜的解决方案
解决方案一：使用Hive ETL预处理数据
解决方案二：过滤少数导致倾斜的key
解决方案三：提高shuffle操作的并行度
解决方案四：*两阶段聚合（局部聚合+全局聚合）
随机shuffle + hash shuffle
map端预聚合 +
解决方案五：*将reduce join转为map join
mapjoin
优点：完美避免shuffle阶段，没有数据倾斜，应用程序执行效率高
缺点：只适用大小表做关联
reducejoin
优点：通用的join实现
缺点：容易产生数据倾斜
解决方案六：*采样倾斜key并分拆join操作
分拆的标准：
找出数据倾斜key的所有数据，形成一个单独的数据集；
剩下的数据不会出现数据倾斜，单独计算即可；
解决方案七：*使用随机前缀和扩容RDD进行join
解决方案八：*多种方案组合使用

5：资源参数调优

（1）num-executors
用于设置Spark作业总共要用多少个Executor进程来执行。如果不设置的话，默认只会启动少量的Executor进程，Spark作业的运行速度会很慢。
建议：每个Spark作业根据集群资源情况而定，设置太少或太多的Executor进程都不好。
（2）executor-memory
用于设置每个Executor进程的内存。直接决定了Spark作业的性能，常见的JVM OOM异常，也有直接的关联。
建议：每个Executor进程的内存设置4G~8G较为合适。
（3）executor-cores
用于设置每个Executor进程的CPU core数量。决定了每个Executor进程并行执行task线程的能力。因为每个CPU core同一时间只能执行一个task线程，因此每个Executor进程的CPU core数量越多，越能够快速完分配给自己的所有task线程。
建议：Executor的CPU core数量设置为2~4个较为合适。
（4）driver-memory
用于设置Driver进程的内存。
建议：Driver的内存通常来说不设置，或者设置1G左右应该就够了。
（5）spark.default.parallelism
用于设置每个stage的默认task数量。可能会直接影响你的Spark作业性能。
建议：设置该参数为num-executors * executor-cores的2~3倍较为合适。

一个确定的式子
（1）一个spark应用程序：
500个task
50个executor
每个executor执行10个task左右
每个executor分配3 - 5个
总cpu core数：150 - 250
每个executor分配的内存是：2G
整个应用消耗：102G

（2）每个stage中到底有多少个task由谁决定
划分stage的标准：shuffle算子，宽依赖
在一个stage中是有可能有多个RDD的
每一个stage中的task总数，是由这个stage中最后一个RDD的分区数来决定的。

（３）
机器资源配置：
32/64CPU 64G/128G/256G
比如：64 cpu core；128G内存
系统内存（堆外内存）预留：16G，4cpu core；剩余60cpu core，240G内存
每个cpu core 4G内存
每个executor要分配2 - 3 个cpu core，分配的内存8 - 12G