Spark数据倾斜问题

数据倾斜的危害

1. spark中一个stage的执行时间受限于最后那个执行完的task，因此运行缓慢的任务会拖累整个程序的运行速度
2. 过多的数据在同一个task中执行，将会把executor撑爆，造成OOM，程序终止运行

数据倾斜的原因

1. 数据源数据文件不均匀（包括大量的key为空）
2. 计算过程中key的分布不均
   1） 单个rdd中进行groupby 的时候key分布不均
   2）多个rdd进行join过程中key的不均匀

排查数据倾斜
【数据源文件】
  根据Spark UI查看metrics，input 以及shuffle read 两个metrics判断task的min跟max是否差异较大，如果差异非常大，则存在数据源倾斜。input size统计是从外部数据源读入的大小

【计算过程】
  根据Spark UI，查看该task的input或者shuffle reader的Summary Metrics里面min和max值，可以定位到task所属的stage，通过stage 描述可以定位到所属的代码行或者根据log一般会报是在哪一行代码，导致了OOM异常或者看log，看看是执行到了第几个stage。哪一个stage生成的task特别慢，就能够通过stage定位到你的代码，到底哪里发生了数据倾斜。

数据倾斜的常见解决方法

对于源数据

聚合源数据

适用场景：
  如果Hive表中的数据很不均匀，而且业务场景需要频繁使用Spark对Hive表执行某个分析操作，比较适合使用这种技术方案。将数据倾斜提前到上游的Hive ETL，每天仅执行一次，只有那一次是比较慢的，而之后每次Java调用Spark作业时，执行速度都会很快，能够提供更好的用户体验。
实现思路：
  直接在生成hive表的hive etl中对数据进行聚合。比如按key来分组，将key对应的所有的values全部用一种特殊的格式拼接到一个字符串里面去，比如“key=sessionid, value: action_seq=1|user_id=1|search_keyword=火锅|category_id=001;action_seq=2|user_id=1|search_key
word=涮肉|category_id=001”。
  对key进行group，在spark中，拿到key=sessionid，values< Iterable>。hive etl中，直接对key进行了聚合。那么也就意味着，每个key就只对应一条数据。在spark中，就不需要再去执行groupByKey+map这种操作了，就不需要执行shffule操作了，也就根本不可能导致数据倾斜。

  聚合源数据方案第二种做法是，如果没有办法对每个key聚合出来一条数据。对每个key对应的数据，10万条。有好几个粒度，比如10万条里面包含了几个城市、几天、几个地区的数据，现在放粗粒度。直接就按照城市粒度，做一下聚合，几个城市，几天、几个地区粒度的数据，都给聚合起来。比如说：
city_id date area_id
select … from … group by city_id

  尽量去聚合，减少每个key对应的数量，也许聚合到比较粗的粒度之后，原先有10万数据量的key，现在只有1万数据量。减轻数据倾斜的现象和问题。

过滤导致倾斜的key

适用场景：
  如果发现导致倾斜的key就少数几个，而且对计算本身的影响并不大的话，可使用这种方案。
实现思路：
  在Spark SQL中可以使用where子句过滤掉这些key或者在Spark Core中对RDD执行filter算子过滤掉这些key。如果需要每次作业执行时，动态判定哪些key的数据量最多然后再进行过滤，那么可以使用sample算子对RDD进行采样，然后计算出每个key的数量，取数据量最多的key过滤掉即可。

对于计算过程

提高shuffle操作reduce并行度

  对所有的shuffle算子，如groupByKey、countByKey、reduceByKey。在调用的时候，传入进去一个参数。那个数字，就代表了那个shuffle操作的reduce端的并行度。增加reduce task的数量，让每个reduce task分配到更少的数据量。这样的话也许就可以缓解甚至是基本解决掉数据倾斜的问题。

使用随机key实现双重聚合

适用场景：对于groupByKey、reduceByKey造成的数据倾斜，有比较好的效果。
实现思路：
  第一轮局部聚合，对key进行打散，将原先一样的key，变成不一样的key，相当于是将每个key分为多组，先针对多个组，进行key的局部聚合。第二轮全局聚合，再去除掉每个key的前缀，然后对所有的key进行全局的聚合。

// 第一步，给RDD中的每个key都打上一个随机前缀。
JavaPairRDD<String, Long> randomPrefixRdd = rdd.mapToPair(
        new PairFunction<Tuple2<Long,Long>, String, Long>() {
     
private static final long serialVersionUID = 1L;
@Override
public Tuple2<String, Long> call(Tuple2<Long, Long> tuple)
                    throws Exception {
     
                Random random = new Random();
                int prefix = random.nextInt(10);
return new Tuple2<String, Long>(prefix + "_" + tuple._1, tuple._2);
            }
        });

// 第二步，对打上随机前缀的key进行局部聚合。
JavaPairRDD<String, Long> localAggrRdd = randomPrefixRdd.reduceByKey(
        new Function2<Long, Long, Long>() {
     
private static final long serialVersionUID = 1L;
@Override
public Long call(Long v1, Long v2) throws Exception {
     
return v1 + v2;
            }
        });

// 第三步，去除RDD中每个key的随机前缀。
JavaPairRDD<Long, Long> removedRandomPrefixRdd = localAggrRdd.mapToPair(
        new PairFunction<Tuple2<String,Long>, Long, Long>() {
     
private static final long serialVersionUID = 1L;
@Override
public Tuple2<Long, Long> call(Tuple2<String, Long> tuple)
                    throws Exception {
     
                long originalKey = Long.valueOf(tuple._1.split("_")[1]);
return new Tuple2<Long, Long>(originalKey, tuple._2);
            }
        });

// 第四步，对去除了随机前缀的RDD进行全局聚合。
JavaPairRDD<Long, Long> globalAggrRdd = removedRandomPrefixRdd.reduceByKey(
        new Function2<Long, Long, Long>() {
     
private static final long serialVersionUID = 1L;
@Override
public Long call(Long v1, Long v2) throws Exception {
     
return v1 + v2;
            }
        });

将reduce join转换为map join

适用场景：
  如果两个RDD要进行join，其中一个RDD是比较小的。比如一个RDD是100万数据，一个RDD是1万数据。（一个RDD是1亿数据，一个RDD是100万数据）。
实现思路：
  不使用join算子进行连接操作，而使用Broadcast变量与map类算子实现join操作，进而完全规避掉shuffle类的操作，彻底避免数据倾斜的发生和出现。将较小RDD中的数据直接通过collect算子拉取到Driver端的内存中来，然后对其创建一个Broadcast变量；接着对另外一个RDD执行map类算子，在算子函数内，从Broadcast变量中获取较小RDD的全量数据，与当前RDD的每一条数据按照连接key进行比对，如果连接key相同的话，那么就将两个RDD的数据用你需要的方式连接起来。
  普通的join是会走shuffle过程的，而一旦shuffle，就相当于会将相同key的数据拉取到一个shuffle read task中再进行join，此时就是reduce join。但是如果一个RDD是比较小的，采用广播小RDD全量数据+map算子来实现与join同样的效果，也就是map join，此时就不会发生shuffle操作，也就不会发生数据倾斜。

// 首先将数据量比较小的RDD的数据，collect到Driver中来。
List<Tuple2<Long, Row>> rdd1Data = rdd1.collect()
// 然后使用Spark的广播功能，将小RDD的数据转换成广播变量，这样每个Executor就只有一份RDD的数据。
// 可以尽可能节省内存空间，并且减少网络传输性能开销。
final Broadcast<List<Tuple2<Long, Row>>> rdd1DataBroadcast = sc.broadcast(rdd1Data);

// 对另外一个RDD执行map类操作，而不再是join类操作。
JavaPairRDD<String, Tuple2<String, Row>> joinedRdd = rdd2.mapToPair(
new PairFunction<Tuple2<Long,String>, String, Tuple2<String, Row>>() {
     
            private static final long serialVersionUID = 1L;
@Override
            public Tuple2<String, Tuple2<String, Row>> call(Tuple2<Long, String> tuple)
                    throws Exception {
     
// 在算子函数中，通过广播变量，获取到本地Executor中的rdd1数据。
List<Tuple2<Long, Row>> rdd1Data = rdd1DataBroadcast.value();
// 可以将rdd1的数据转换为一个Map，便于后面进行join操作。
Map<Long, Row> rdd1DataMap = new HashMap<Long, Row>();
for(Tuple2<Long, Row> data : rdd1Data) {
     
                    rdd1DataMap.put(data._1, data._2);
                }
// 获取当前RDD数据的key以及value。
String key = tuple._1;
String value = tuple._2;
// 从rdd1数据Map中，根据key获取到可以join到的数据。
                Row rdd1Value = rdd1DataMap.get(key);
return new Tuple2<String, String>(key, new Tuple2<String, Row>(value, rdd1Value));
            }
        });

// 注意该做法仅仅适用于rdd1中的key没有重复，全部是唯一的场景。
// 如果rdd1中有多个相同的key，那么就得用flatMap类的操作，在进行join的时候不能用map，而是得遍历rdd1所有数据进行join。
// rdd2中每条数据都可能会返回多条join后的数据。

不适合的情况：两个RDD都比较大，那么这个时候，你去将其中一个RDD做成broadcast，很可能导致内存不足。最终导致内存溢出，程序挂掉。

sample采样倾斜key单独进行join

适用场景：
  进行join的时候，如果数据量都比较大，如果出现数据倾斜，是因为其中某一个RDD中的少数几个key的数据量过大，而另一个RDD中的所有key都分布比较均匀，采用该解决方案。

实现思路：
  对于join导致的数据倾斜，如果只是某几个key导致了倾斜，可以将少数几个key分拆成独立RDD，并附加随机前缀打散成n份去进行join，此时这几个key对应的数据就不会集中在少数几个task上，而是分散到多个task进行join了。
对包含少数几个数据量过大的key的那个RDD，通过sample算子采样出一份样本来，然后统计一下每个key的数量，确定数据量最大的几个key。 然后将这几个key对应的数据从原来的RDD中拆分出来，形成一个单独的RDD，并给每个key都打上n以内的随机数作为前缀，而不会导致倾斜的大部分key形成另外一个RDD。 接着将需要join的另一个RDD，也过滤出来那几个倾斜key对应的数据并形成一个单独的RDD，将每条数据膨胀成n条数据，这n条数据都按顺序附加一个0~n的前缀，不会导致倾斜的大部分key也形成另外一个RDD。 再将附加了随机前缀的独立RDD与另一个膨胀n倍的独立RDD进行join，此时就可以将原先相同的key打散成n份，分散到多个task中去进行join了。 而另外两个普通的RDD就照常join即可。 最后将两次join的结果使用union算子合并起来即可，就是最终的join结果。
  对于join导致的数据倾斜，如果只是某几个key导致了倾斜，采用该方式可以用最有效的方式打散key进行join。而且只需要针对少数倾斜key对应的数据进行扩容n倍，不需要对全量数据进行扩容。避免了占用过多内存。如果导致倾斜的key特别多的话，比如成千上万个key都导致数据倾斜，那么这种方式也不适合。

sample(withReplacement : scala.Boolean, fraction : scala.Double，seed scala.Long)
1、withReplacement：元素可以多次抽样(在抽样时替换)

2、fraction：期望样本的大小作为RDD大小的一部分，
当withReplacement=false时：选择每个元素的概率;分数一定是[0,1] ；
当withReplacement=true时：选择每个元素的期望次数; 分数必须大于等于0。

3、seed：随机数生成器的种子

使用随机数以及扩容表进行join

实现思路：
  将该RDD的每条数据都打上一个n以内的随机前缀。同时对另外一个正常的RDD进行扩容，将每条数据都扩容成n条数据，扩容出来的每条数据都依次打上一个0~n的前缀。 最后将两个处理后的RDD进行join即可。将原先一样的key通过附加随机前缀变成不一样的key，然后就可以将这些处理后的“不同key”分散到多个task中去处理，而不是让一个task处理大量的相同key。
  由于处理过程需要扩容RDD，而这一种方案是针对有大量倾斜key的情况，没法将部分key拆分出来进行单独处理，因此只能对整个RDD进行数据扩容，对内存资源要求很高。

// 首先将其中一个key分布相对较为均匀的RDD膨胀100倍。
JavaPairRDD<String, Row> expandedRDD = rdd1.flatMapToPair(
new PairFlatMapFunction<Tuple2<Long,Row>, String, Row>() {
     
            private static final long serialVersionUID = 1L;
@Override
            public Iterable<Tuple2<String, Row>> call(Tuple2<Long, Row> tuple)
                    throws Exception {
     
List<Tuple2<String, Row>> list = new ArrayList<Tuple2<String, Row>>();
for(int i = 0; i < 100; i++) {
     
                    list.add(new Tuple2<String, Row>(0 + "_" + tuple._1, tuple._2));
                }
return list;
            }
        });

// 其次，将另一个有数据倾斜key的RDD，每条数据都打上100以内的随机前缀。
JavaPairRDD<String, String> mappedRDD = rdd2.mapToPair(
new PairFunction<Tuple2<Long,String>, String, String>() {
     
            private static final long serialVersionUID = 1L;
@Override
            public Tuple2<String, String> call(Tuple2<Long, String> tuple)
                    throws Exception {
     
                Random random = new Random();
int prefix = random.nextInt(100);
return new Tuple2<String, String>(prefix + "_" + tuple._1, tuple._2);
            }
        });

// 将两个处理后的RDD进行join即可。
JavaPairRDD<String, Tuple2<String, Row>> joinedRDD = mappedRDD.join(expandedRDD);

补充：窄依赖会不会造成数据倾斜？
会。如果上游数据本身分布不均，每个task中处理的数据量不一致，那么还是会造成数据倾斜。但是上游已经数据倾斜了，就已经OOM了，就需要避免OOM，需要增加内存。