Spark性能调优（三）

1.数据倾斜

1.1. 什么是数据倾斜，现象是什么？

所谓数据倾斜(data skew)，其实说白了，由于数据分布不均匀造成计算时间差异很大，产生了一些列异常现象。

​ 常见的现象有两种：

1. 个别task作业运行缓慢

   ​ 大多数的task运行都很快速，但是极个别的task运行非常缓慢，甚至是正常task运行时间好多倍。
   
   而一个作业运行的最终时间是由时间最短的那些task决定还是有哪些时间最长的task决定。

2.莫名其妙的OOM异常

这是一种相对比较少见的现象，正常运行的task作业，突发发生了一个OOM异常。但是这只是一种假设，需要验证，因为流量的突然暴增也会经常导致OOM异常。

1.2. 发生数据倾斜的原因是什么？

针对第一种情况，来探究发生数据倾斜的原因是什么？大多数正常，个把运行缓慢，也就说，大多数正常的task计算的数据量正常，个把运行缓慢的task计算的数据量异常。为什么？为什么这个别task的计算的数据量会超过其他task？

​ spark作业运行的时候，主要有两种类型，一种基于窄依赖，一种是基于宽依赖；spark作业的运行就是基于stage提供的task来运行，而stage的划分就是基于前面的宽依赖。

​ 针对于spark作业的开始执行，是基于输入算子进行分区的范围划分或者block对应一个partition，那么此时每一个partition中的数据量分布均匀吗？均匀，基于这个的窄依赖的计算，请问每个分区的计算量均匀不？均匀，没有夸网络的数据的传输，所以也就不可能在窄依赖对应的stage阶段发生数据倾斜。

​ 那现在问题简单了，只剩下宽依赖了，也就是shuffle操作。shuffle操作说白了就是将key相同的数据经过网络拉取到同一个节点上的同一个partition中进行聚合操作。加入绝大多数key都对应10条数据，但是有个别key对应的数据量10w条，所以经过shuffle操作之后，这特殊key的10w+的数据会到一个分区中去，而其它分区数据量相对正常，可不就造成了个别task任务执行时间是其它普通task的若干倍。

​

1.3 如何解决数据倾斜

我们已经知道发生的原因是由于某些key对应的数据量过多操作的，所以我们首先需要找到这些key，问题在于如何找到这些key？显然不能基于全量的数据找，只能抽样，使用sample算子进行处理。

​ 找到这些key之后，需要进行分拆（最常见的处理思路：加随机前缀），最后进行全局处理。

1.3.1 在Hive ETL中做预处理

这个处理的方法，主要在于Spark作业加载hive表中的数据，进行业务处理。加入hive的数据有倾斜现象，在spark中的处理，自然会出现dataskew。而如果spark作业一般只是想web 端提供查询服务，针对这种情况就比较适合这个解决方法。

​ Hive ETL预处理，数据倾斜的现象在hive中提前被处理，这样加载到spark中的数据有倾斜吗？没有！此时spark给web服务端只提供一个查询服务，所以没有的数据倾斜，效率非常高！只不过此时将数据倾斜解决掉了吗？是把spark端的dataskew转移到hive中。

1.3.2 过滤掉发生数据倾斜的key

找到哪些发生数据倾斜的key，同时必须要想业务人员确认这些key是否有用，如果没用直接使用filter算子过滤掉就行。

​ 但凡是删除、过滤、更新等待操作，一定慎重。

1.3.3 提高程序并行度

程序运行缓慢，第一反应大多是资源分配不足，并行度不够。提高并行度是我们做数据倾斜调优的第一步尝试，提高并行度会在一定程度上减轻数据倾斜的压力，但是并不能从彻底上根除数据倾斜。因为一旦发生数据倾斜，倾斜的key无论如何提高并行度，经过shuffle操作都会直到一个分区中去。

​ 如何提高并行度？两个地方进行设置。

• spark.default.parallelism 设置spark程序全局并行度
• shuffle操作的第二个参数进行设置(局部)并行度

1.3.4 进行两阶段聚合

两阶段聚合操作，指的是局部聚合+全局聚合。该方法适合于哪些XxxxByKey的操作，比如groupByKey、reduceByKey的聚合操作。

object _01TwoStageDataskewOps {
def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
        .setAppName("_01TwoStageDataskewOps")
        .setMaster("local[2]")

    val sc = new SparkContext(conf)

    val list = List(
        "hello hello hello hello you you hello",
        "hello hello hello you you hei hei hello hello hello"
    )
    val listRDD = sc.parallelize(list)

    val pairsRDD:RDD[(String, Int)] = listRDD.flatMap(line => {
        line.split("\\s+")
    }).map((_, 1))
    //step 1、确认发生数据倾斜的key --->sample算子
    val sorted = pairsRDD.sample(true, 0.6).countByKey().toList.sortWith((m1, m2) => m1._2 > m2._2)
    println("抽样数据排序之后的结果：")
    println(sorted.mkString("\n"))
    //step 1.1 获取发生数据倾斜key
    val dataskewKey = sorted.head._1
    println("发生数据倾斜的key为：" + dataskewKey)
    //step 2、加随机前缀
    val prefixPairsRDD = pairsRDD.map{case (word, count) => {
        if(word == dataskewKey) {
            val random = new Random()
            val prefix = random.nextInt(2)
            (s"${prefix}_${word}", count)
        } else {
            (word, count)
        }
    }}
    println("=============step 2、加随机前缀数据===================")
    prefixPairsRDD.foreach(println)
    //step 3、局部聚合
    val partAggrRDD:RDD[(String, Int)] = prefixPairsRDD.reduceByKey(_+_)
    println("=============3、局部聚合结果===================")
    partAggrRDD.foreach(println)
    //step 4、去掉随机前缀
    val unPrefixPairsRDD = partAggrRDD.map{case (word, count) => {
        if(word.contains("_")) {
            (word.substring(2), count)
        } else {
            (word, count)
        }
    }}
    println("=============step 4、去掉随机前缀的数据===================")
    unPrefixPairsRDD.foreach(println)
    //step 5、进行全局聚合
    val fullAggrRDD = unPrefixPairsRDD.reduceByKey(_+_)
    println("=============step 5、进行全局聚合===================")
    fullAggrRDD.foreach(println)
    sc.stop()
}
}

1.3.5 使用map-join代替reduce-join

这个操作主要是针对join类的聚合操作，多表关联，前提条件是大小表关联。

​所谓reduce-join操作就是很直白的调用join算子，执行操作，这个过程是有shuffle的。

​所谓map-join操作呢，将小表广播到各个executor，在map类算子中完成关联操作。

​这个操作从根本上解决了数据倾斜，因为有map-join代替reduce-join没有shuffle操作，肯定就没有数据倾斜了。

1.3.6 使用采样key并分拆进行聚