spark性能调优（三）之数据倾斜

最新推荐文章于 2024-06-23 16:11:38 发布

置顶 moshang_find

最新推荐文章于 2024-06-23 16:11:38 发布

阅读量432

点赞数 2

分类专栏： spark 文章标签： spark数据倾斜 spark常见数据倾斜和解决办法 spark调优之数据倾斜

本文链接：https://blog.csdn.net/moshang_3377/article/details/93513211

版权

spark 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

一、什么是数据倾斜

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

二、常见现象

1、个别task作业运行缓慢

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

2、莫名其妙的OOM异常

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

三、发生数据倾斜的原因

针对上述第一种情况，来探究一下发生数据倾斜的原因是什么？大多数正常，极个别运行缓慢，也就说，大多数正常的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的若干倍。

请问，shuffle操作是发生数据倾斜的什么条件？
答：必要条件。

四、如何解决数据倾斜

1、解决思路

我们已经知晓发生的原因是由于某些key对应的数据量过多导致的，所以我们首先需要找到这些key，问题在于如何找到这些key？显然不能基于全量的数据找，只能抽样，使用sample算子进行处理。找到这些key之后，需要进行分拆（最常见的处理思路：加随机前缀），最后进行全局处理。

2、在Hive ETL中做预处理

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

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

3、过滤掉发生数据倾斜的key

找到哪些发生数据倾斜的key，同时必须要想业务人员确认这些key是否有用，如果没用直接使用filter算子过滤掉就行。
在工作中，切忌，但凡是删除、过滤、更新等待操作，一定慎重。

4、提高程序并行度

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

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

1）spark.default.parallelism 设置spark程序全局并行度

在这里插入图片描述

2）shuffle操作的第二个参数进行设置(局部)并行度

在这里插入图片描述

5、进行两阶段聚合

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

?:
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkContext, SparkConf}

import scala.util.Random


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

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

    val pairsRDD:RDD[(String,Int)]=listRDD.flatMap(line =>{
      line.split("\\s+")
    }).map((_,1))
    //1.确认发生数据倾斜的key
    val sorted = pairsRDD.sample(true,0.6).countByKey().toList.sortWith((m1,m2) => m1._2 > m2._2)
    println("抽样后排序结果:")
    println(sorted.mkString("\n"))

    //获取发生数据倾斜的key
    val dataSkewKey=sorted.head._1
    println("发生数据倾斜的数据是:"+dataSkewKey)

    //2.加随机前缀
    val prefixRDD=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("加随机前缀数据")
    prefixRDD.foreach(println)
    //3.局部聚合
    val partAgg:RDD[(String,Int)] = prefixRDD.reduceByKey(_+_)
    println("局部聚合之后的结果:")
    partAgg.foreach(println)

    //4.去掉前缀
    val unPrefixRDD=partAgg.map{case(word,count)=>{
      if(word.contains("_")){
        (word.substring(word.indexOf("_")+1),count)
      }else{
        (word,count)
      }
    }}
    println("去掉随机数前缀之后的结果:")
    unPrefixRDD.foreach(println)

    //5.进行全局聚合
    val finalRDD = unPrefixRDD.reduceByKey(_+_)
    println("最终结果:")
    finalRDD.foreach(println)
	sc.stop()
  }
}

运行结果：
在这里插入图片描述

6、使用map-join代替reduce-join

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

所谓reduce-join操作就是很直白的调用join算子，执行操作，这个过程是有shuffle的；而所谓map-join操作就是将小表广播到各个executor，在map类算子中完成关联操作。
map-join这个操作，从根本上解决了数据倾斜，因为有map-join代替reduce-join没有shuffle操作，肯定就没有数据倾斜了。

代码参见（不再重复写啦~）：https://blog.csdn.net/moshang_3377/article/details/93122732

7、使用采样key并分拆进行聚合

在这里插入图片描述
如上图所示：

有两张表数据，其中左表的某个字段会对聚合造成数据倾斜的问题，这个key我们暂且称之为异常数据，但是右表是正常的，没有会造成数据倾斜的数据。
那我们想要实现他们的聚合那就需要为左表中的异常数据添加随机前缀，但是这样还是没办法跟右表进行关联，因为key不一样了，那怎么办呢？给右表的相对应的数据也加上随机数前缀是不是就可以了呢？yes，这么操作完之后就相当于对右表做了一次扩容，扩容的倍数关系是左边加了N以内随机数，右表就扩容N倍。

下面来看看代码实现吧~

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

        val sc = new SparkContext(conf)
        val left = List(
            ("hello", 1),
            ("hello", 2),
            ("hello", 3),
            ("you", 1),
            ("me", 1),
            ("you", 2),
            ("hello", 4),
            ("hello", 5)
        )
        val right = List(
            ("hello", 11),
            ("hello", 12),
            ("you", 11),
            ("me", 12)
        )
        val leftListRDD:RDD[(String, Int)] = sc.parallelize(left)
        val rightListRDD:RDD[(String, Int)] = sc.parallelize(right)
        //step 1、采样找到异常的key
        val sampledRDD = leftListRDD.sample(true, 0.8)
        val sorted = sampledRDD.countByKey().toList.sortWith((m1, m2) => m1._2 > m2._2)
        println("排序之后的采样数据：" + sorted.mkString("\n"))
        val dataskewKey = sorted.head._1
        /*
            step 2、根据异常的key将左右表都拆分正常的数据和异常的数据
         */
        val dsLeftRDD:RDD[(String, Int)] = leftListRDD.filter{case (word, count) => word == dataskewKey}
        val commonLeftRDD:RDD[(String, Int)] = leftListRDD.filter{case (word, count) => word != dataskewKey}

        val dsRightRDD:RDD[(String, Int)] = rightListRDD.filter{case (word, count) => word == dataskewKey}
        val commonRightRDD:RDD[(String, Int)] = rightListRDD.filter{case (word, count) => word != dataskewKey}

        println("step 2、根据异常的key将左右表都拆分正常的数据和异常的数据")
        println("左表异常数据：")
        dsLeftRDD.foreach(println)
        println("左表正常数据：")
        commonLeftRDD.foreach(println)
        //step 3、对左表异常数据添加N以内的随机前缀
        println("step 3、对左表异常数据添加N以内的随机前缀")
        val prefixLeftRDD = dsLeftRDD.map{case (word, count) => {
            val random = new Random()
            val prefix = random.nextInt(2)
            (s"${prefix}_${word}", count)
        }}
        prefixLeftRDD.foreach(println)
        //step 4、对右表异常数据进行N倍的扩容
        println("step 4、对右表异常数据进行N倍的扩容")
        val prefixRightRDD = dsRightRDD.flatMap{case (word, count) => {
            val ab = ArrayBuffer[(String, Int)]()
            for(i <- 0 until 2) {
                ab.append((s"${i}_${word}", count))
            }
            ab
        }}
        prefixRightRDD.foreach(println)
        /**
          * step 5、分别对异常数据和正常数据进行join操作
          */
        println("step 5、分别对异常数据和正常数据进行join操作")
        val commonJoinedRDD = commonLeftRDD.join(commonRightRDD)

        val dsJoinedRDD = prefixLeftRDD.join(prefixRightRDD)
        println("5.1 正常数据join的结果")
        commonJoinedRDD.foreach(println)
        println("5.2 异常数据join的结果")
        dsJoinedRDD.foreach(println)
        //5.3 去掉异常数据的随机前缀
        val dsFinalJoinedRDD = dsJoinedRDD.map{case (word, count) => {
            (word.substring(word.indexOf("_") + 1), count)
        }}
        //step 6、全局的union操作，前提是去掉step5中的异常数据的前缀
        val finalJoinedRDD = dsFinalJoinedRDD.union(commonJoinedRDD)
        println("step 6、全局的union操作，前提是去掉step5中的异常数据的前缀")
        finalJoinedRDD.foreach(println)

        sc.stop()
    }
}

运行结果：
在这里插入图片描述

扩展，两张大表，左表全量异常，右表正常。
这种没有好的解决方案，左表全量加N以内的随机前缀，右表全量进行N倍的扩容。可能会有的问题，扩容之后的存储压力非常大，可能发生OOM异常。

本案例中实际上是以空间换时间。

moshang_find

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
spark性能调优（三）之数据倾斜

一、什么是数据倾斜所谓数据倾斜(data skew)是由于数据分布不均匀造成计算时间差异很大，产生了一些列异常现象。二、常见现象1、个别task作业运行缓慢大多数的task运行都很快速，但是极个别的task运行非常缓慢，甚至是正常task运行时间好多倍。而一个作业运行的最终时间是由时间最短的那些task决定还是有哪些时间最长的task决定。2、莫名其妙的OOM异常这是一种相对比较少见...
复制链接

扫一扫

专栏目录