Spark性能调优--

spark性能调优
数据倾斜调优

1.绝大多数task执行的都非常快，但是个别task执行极慢

2.原本能够正常执行的spark作业，突然某天出现oom（内存溢出）异常，观察异常栈，是我们写的业务代码造成的（情况少见）

数据倾斜发生的原理

在进行shuffle的时候，必须降各个节点上相同的key拉取到某个节点上的一个task来进行处理，比如按照key进行聚合或join等操作。此时如果某个key对应的数据量特别大的话，就会发生数据倾斜。（运行时间符合木桶效应）

如何定位导致数据倾斜的代码

数据倾斜只会发生在shuffle中。常用可能会触发shuffle操作的算子：distinct、groupByKey、reduceByKey、aggregateBykey、join、cogroup、repartition等。出现数据倾斜时，可能是代码中使用课这些算子中的某一个所导致

知道了数据倾斜发生在哪一个stage之后，接着就需要根据stage划分原理。推算出来发生倾斜的那个stage与代码的对应关系，需要对spark源码有深入的了解，介绍一个简单使用的推算方法：只要看到spark代码中出现了一个shuffle类算子或者是spark sql 的sql语句中出现了会导致shuffle的语句（比如group by 语句）。那么就可以判定，以那个地方为分界线划分出前后两个stage

某个task执行特别慢的情况

                 首先确定数据倾斜发生在第几个stage阶段

                 如果是使用yarn-client模式提交，那么本地就是直接可以看到log的，可以在log中找到当前运行到了第几个stage。此外，无论是使用yarn-client模式还是yarn-cluster模式。我们都可以在sparkj web ui上深入看一下当前这个stage各个task分配的数据量，从而进一步确定是不是task分配的数据不均匀导致了数据倾斜

某个task莫名其妙内存溢出的情况

                 此情况定位出问题的代码比较容易，查看yarn-client模式下的本地log的异常栈，或者通过yarn-cluster模式下的log中异常栈。一般来讲，通过异常栈信息就可以定位到代码中的那行代码发生了内存溢出。然后在那行代码附近，一般会有shuffle类算子，此时很有可能就是这个算子导致了数据倾斜。但是我们应该注意的是，不能单靠偶然的内存溢出判断发生了数据倾斜，因为自己编写的代码的bug，以及偶然出现的数据异常，也可能会导致内存溢出，因此还是需要通过spark web

ui查看报错的那个stage的各个task的运行时间以及分配的数据量，才能确定是否由于数据倾斜才导致了这次内存的溢出

查看导致数据倾斜的key的数据分布情况

知道了数据倾斜发生在哪里之后，通常需要分析一下那个执行了shuffle操作并且导致了数据倾斜的RDD/Hive表，查看一下其中key的分布情况。这主要是为之后的选择哪一种技术方案提供依据。针对不同的key分布与不同的shuffle算子组合起来的各种情况，可能需要选择不同的技术方案来解决

此时根据你执行操作的情况不同，可以有多种查看key分布的方式：

如果是spark sql 中的group by、join语句导致的数据倾斜，那么就查询一下sql中使用的表的key分布情况

如果是对spark rdd执行shuffle算子导致的数据倾斜，那么可以在spark作业中加入查看key分布的代码，比如rdd.countByKey（）。然后对统计出来的各个key出现的次数。Collect/take到客户端打印一下

倾斜数据的解决方案

解决方案一：使用Hive ETC预处理数据

方案使用场景：导致数据倾斜的是Hive表。如果该Hive表中的数据本身很不均匀，而且业务场景需要频繁使用spark对hive表执行某个分析操作

方案实现是思路：此时可以评估一下，是否可以通过hive来进行数据预处理（即通过hive etc 预先对数据按照key进行聚合，或者是预先和其他表进行join），然后在spark作业中针对数据源就不是原来的hive表了，而是预处理后的hive表。此时由于数据已经预先进行过聚合或join操作了，那么在spark作业中也就不需要使用原先的shuffle类算子执行这类操作

方案实现原理：这种方案从根源上解决了数据倾斜，因为彻底避免了spark中执行shuffle类算子，那么肯定就不会有数据倾斜的问题。但是，这种方法属于治标不治本。因为数据本身就存在分布不均匀的问题，所以Hive ETL的速度很慢。我们只是把数据倾斜的发生提前到了Hive ETC中，避免spark程序发生数据倾斜而已

方案优点：实现起来简单便捷，效果还非常好，完全规避掉了数据倾斜，spark作业的性能会大幅度提高

方案缺点：治标不治本，Hive ETL中还是会发生数据倾斜

方案实践经验：在一些java系统与spark代码频繁调用spark作业的场景，而且对spark作业的执行性能要求非常高，就比较适合使用这种方案。将数据倾斜提前到上游的Hive
ETL，每天仅执行一次，只有那一次是比较慢的，而之后每次Java调用spark作业时，执行速度都会很快，鞥狗提供更好的用户体验

项目实际经验：在美团·点评的交互式用户行为分析系统中使用了这种方案，该系统主要是允许用户通过Java web 系统提交数据分析统计任务，后端通过Java提交spark作业进行数据分析统计。要求spark作业速度必须要快，尽量在10分钟以内，否则速度太慢，用户体验会很差。所以我们将有些spark作业的shuffle操作提前到了Hive ETL中，从而让spark直接使用预处理的Hive中间表，尽可能减少spark的shuffle操作，大幅度提升了性能，将部分作业的性能提升6倍以上

解决方案二：过滤少数导致数据倾斜的key

方案使用场景：如果发现导致倾斜的key就少数几个，而且对计算本身的影响并不大的话，适用此方案。比如99%的key就对应10条数据，但是只有一个key对应了100万数据，从而导致了数据倾斜

方案实现思路：如果我们判断那少数几个数据量特别多的key，对作业的执行和计算结果不是特别重要的话，那么我们就干脆直接过滤掉那少数几个key，比如，在spark sql中使用where子句过滤掉这些key或者在spark core中对rdd执行filter算子过滤掉这些key。如果需要每次作业执行时，动态判定哪些key的数据量最多然后再进行过滤，那么可以使用sample算子对rdd进行采样，然后计算出每个key的数量，取数据量最多的key过滤掉即可

方案实现原理：将导致数据倾斜的key’给过滤掉之后，这些key 就不会参与计算，将不会产生数据倾斜

方案优点：实现简单，效果好，可以完全规避掉数据倾斜

方案缺点：适用场景不多，大多数情况下，导致倾斜的key还是比较多的，并不是只有少数的几个

方案实践经验：在项目中，有一次发现某一天的spark作业运行的时候突然oom了，追查之后发现，是Hive表中的某一个key在那天数据异常，导致数据量暴增。因此就采用每次执行前先进行数据采样，计算出样本数据量最大的几个key之后，直接在程序中将那些key给过滤掉

解决方案三：提高shuffle操作的并行度

方案适用场景：如果我们必须要对数据倾斜迎难而上，那么建议优先使用这种方案，因为这是处理数据倾斜的最简单的一种方案

方案实现思路：在对rdd执行shuffle算子时，给shuffle算子传入一个参数，比如reduceByKey（1000），该参数就设置了这个shuffle算子执行时shuffle read task的数量。对于spark sql中的shuffle类语句，比如group by、join等，需要设置一个参数，即spark.sql.shuffle.partitions，该参数就代表了shuffle read
task的并行度，该值默认值是200，对于很多场景来说都有点过于小

方案实现原理：增加shuffle read task的数量，可以让原本分配给一个task的多个key分配给多个task，从而让每个task处理比原来更少的数据，举例来说，比如原本有5个key，每个key对应10条数据，这5 个key都是分配一个task的，那么这个task就要处理50条数据。从而增加了shuffle read task以后，每个task就分配到一个key，即每个task就处理10条数据，那么每个task执行的时间就变短了

方案优点：实现起来比较简单，可以有效减缓和减轻数据倾斜的影响

方案缺点：只是缓解了数据倾斜，未彻底根除问题，效果有限

方案实践经验：该方案无法彻底解决数据倾斜，因为如果一旦出现一些极端情况，比如某个key对应的数据量有100万，那么无论你的task数量增加到多少，这个对应着100万数据的key肯定还是会分配到一个task中去处理，因此注定还是会发生数据倾斜的。所以这种方案只能说是在发现数据倾斜时尝试使用的第一种手段，尝试去使用最简单的方法缓解数据倾斜而已，或者是和其他方案结合起来使用。

解决方案四：两阶段聚合（局部聚合+全局聚合）

方案适用场景：对rdd执行reduceByKey等聚合类shuffle算子或者在spark sql中使用group by语句进行分组聚合时，比较适合这种方案

方案实现思路：此方案的核心实现思路就是进行两阶段聚合。第一次是局部聚合，先给每个key都打上一个随机数，比如10以内的随机数，此时原先一样的key就变成不一样的了，比如(hello, 1) (hello, 1)
(hello, 1) (hello, 1)，就会变成(1_hello, 1) (1_hello, 1)
(2_hello, 1) (2_hello, 1)。接着对打上随机数后的数据，执行reduceByKey等聚合操作，进行局部聚合，那么局部聚合结果就会变成（1_hello,2）（2_hello,2）。然后将各个key的前缀给去掉，就会变成（hello,2）（hello,2），再次进行全局聚合操作，就可以的到最终的聚合结果

方案实现原理：将原本相同的key通过附加随机前缀的方式，变成多个不同的key，就可以让原本被一个task处理的数据分散到多个task上去做局部聚合，进而解决单个task处理数据量过多的问题。接着去除掉随机前缀，再次进行全局聚合，就可以的到最终的结果

方案优点：对于聚合类的shuffl操作导致的倾斜，效果非常明显。通常都可以解决掉数据倾斜，或者说是大幅度缓解数据倾斜，将spark作业进行的性能提升数倍以上

方案缺点：仅仅适用聚合类的shuffle操作，适用范围相对较窄，如果是join类的shuffle操作，还的使用其他的解决方案

解决方案五：将reduce join 转化为map join

方案使用场景：在对rdd使用join类操作，或者是在spark sql中使用join语句时，而且join操作中的一个rdd或者表中的数据量比较小（比如说几百兆或者是一两g），比较适用此方案

方案实现思路：不适用join算子进行连接操作，而使用Broadcast类算子实现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操作

方案优点：对join操作导致的数据倾斜，效果非常好，因为根本就不会发生shuffle，也根本就不会发生数据倾斜

方案缺点：使用场景较少，因为这中方案只适用一个大表和一个小表的情况。毕竟我们要将一个小表进行广播，此时就会消耗内存资源Driver和每一个Executor内存中都会驻留一份小rdd的全量数据。如果我们广播出去的rdd数据比较大，比如10G以上，那么就可能发生oom了。因此，并不适用两个都是大表的情况

解决方案六：采样倾斜key并分拆join操作

方案适用场景：两个rdd/hive表进行join的时候，如果数据量都比较大，无法采用“方案五”，那么，此时可以看一下两个rdd/hive表中的key分布情况。如果出现数据倾斜，是因为其中某一个rdd/hive表中的少数几个key的数据量过大，而另一个rdd/hive表中的所有key都分布比较均匀，那么采用此解决方案

方案实现思路：对包含少数几个数据量过大的key的那个rdd，通过sample算子采样出一份样本来，然后统计一下每个key的数量，计算出数据量最大的是哪几个key。然后将这几个key对应的数据从原来的rdd中拆分出来，形成一个单独的edd，并给每一个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分拆成独立rdd，并附家随机前缀打散成n份去进行join，此时这几个key对应的数据就不会集中在少数几个task上，而是分散到多个task进行join了

方案优点：对于join导致的数据倾斜，如果只是某几个key导致了倾斜，采用该方式可以用最有效的方式打散key进行join。而且只需要针对少数倾斜key对应的数据进行扩容n被，不需要对全量数据进行扩容。避免占用了过多的内存

方案缺点：如果导致倾斜的key比较多的话，那么这种方式不适合

解决方案七：适用随机前缀和扩容rdd进行join

方案适用场景：如果在进行join操作时，rd中有大量的key导致数据侵倾斜，那么进行分拆key也没有什么意义，此时就只能使用最后一种方案来解决问题

方案实现思路：该方案的实行思路与“六”类似，首先查看rdd/hive表中的数据分布情况，找到那个造成数据倾斜的rdd/hive表，比如有多个key对应的数据都超过了万条。然后将该rdd的每条数据都打上一个n以内的随机前缀。同时对另一个正常的rdd进行扩容，将每条数据都扩容成n条数据，扩容出来的每条数据都依次打上一个0-n的前缀。最后将两个处理后的rdd进行join即可

方案实现原理：将原先一样的key通过附加随机前缀变成不一样的key，然后就可以将这些处理后的“不同key”分散到多个task中去处理，而不是让一个task处理大量的相同key。该方案与“六”不同之处就在于，“六”是尽量只对少数倾斜key对应的数据进行特殊处理，由于处理过程中需要扩容rdd，因此“六”扩容rdd后对内存的占用并不大：而这种是针对有大量的倾斜key进行数据扩容，对内存资源要求较高

方案优点：对jon类型的倾斜数据基本都可以处理，而且效果也相对比较显著，性能提升效果并不错

方案缺点：该方案更多的是环节数据倾斜，而不是彻底的避免数据倾斜。而且需要对整个rdd进行扩容，对内存资源要求比较高

方案实践经验：60分钟缩短到10分钟

解决方案八：多种方案组合使用

在实践中发现，很多情况下，如果只是处理较为简单的数据倾斜场景，那么使用上述方案中的一个就基本上能解决问题。但是如果要处理一个较为复杂的数据倾斜场景，那么可能需要将多种的方案组合起来使用，比如说，我们针对出现多个数据倾斜环节的spark作业。可以先运用方案一和二，预处理一部分数据，并过滤一部分数据来缓解；其次可以对某些shuffle操作提升并行度，优化其性能；最后还可以针对不同的聚合或join操作，选择一种方案来优化其性能。灵活运用，实践解决问题

Shuffle调优

大多数spark作业的性能主要就是消耗了shuffle环节，因为该环节包含了大量的磁盘io、序列化、网络数据传输等操作。因此，如果要让作业的性能更上一层楼，就必须要对shuffle过程进行调优。但是必须知道，影响一个spark作业性能的因素，主要还是代码开发、资源参数以及数据倾斜，shuffle调优只能在整个spark的性能调优占到一小部分而已。因此必须把握调优的基本原则

ShuffleManagter发展

在Spark的源码中，负责shuffle过程的执行、计算和处理的组件主要就是这里我们先明确一个假设前提：每个Executor只有1个CPU
core，也就是说，无论这个Executor上分配多少个task线程，同一时间都只能执行一个task线程。

我们先从shuffle
write开始说起。shuffle
write阶段，主要就是在一个stage结束计算之后，为了下一个stage可以执行shuffle类的算子（比如reduceByKey），而将每个 task处理的数据按key进行“分类”。所谓“分类”，就是对相同的key执行hash算法，从而将相同key都写入同一个磁盘文件中，而每一个磁盘文 件都只属于下游stage的一个task。在将数据写入磁盘之前，会先将数据写入内存缓冲中，当内存缓冲填满之后，才会溢写到磁盘文件中去。

那么每个执行shuffle
write的task，要为下一个stage创建多少个磁盘文件呢？很简单，下一个stage的task有多少个，当前stage的每个task就要创建 多少份磁盘文件。比如下一个stage总共有100个task，那么当前stage的每个task都要创建100份磁盘文件。如果当前stage有50个 task，总共有10个Executor，每个Executor执行5个Task，那么每个Executor上总共就要创建500个磁盘文件，所有 Executor上会创建5000个磁盘文件。由此可见，未经优化的shuffle write操作所产生的磁盘文件的数量是极其惊人的。

接着我们来说说shuffle
read。shuffle
read，通常就是一个stage刚开始时要做的事情。此时该stage的每一个task就需要将上一个stage的计算结果中的所有相同key，从各个 节点上通过网络都拉取到自己所在的节点上，然后进行key的聚合或连接等操作。由于shuffle write的过程中，task给下游stage的每个task都创建了一个磁盘文件，因此shuffle read的过程中，每个task只要从上游stage的所有task所在节点上，拉取属于自己的那一个磁盘文件即可。

shuffle read的拉取过程是一边拉取一边进行聚合的。每个shuffle read task都会有一个自己的buffer缓冲，每次都只能拉取与buffer缓冲相同大小的数据，然后通过内存中的一个Map进行聚合等操作。聚合完一批数 据后，再拉取下一批数据，并放到buffer缓冲中进行聚合操作。以此类推，直到最后将所有数据到拉取完，并得到最终的结果。

我们先从shuffle
write开始说起。shuffle
write阶段，主要就是在一个stage结束计算之后，为了下一个stage可以执行shuffle类的算子（比如reduceByKey），而将每个 task处理的数据按key进行“分类”。所谓“分类”，就是对相同的key执行hash算法，从而将相同key都写入同一个磁盘文件中，而每一个磁盘文 件都只属于下游stage的一个task。在将数据写入磁盘之前，会先将数据写入内存缓冲中，当内存缓冲填满之后，才会溢写到磁盘文件中去。

那么每个执行shuffle
write的task，要为下一个stage创建多少个磁盘文件呢？很简单，下一个stage的task有多少个，当前stage的每个task就要创建 多少份磁盘文件。比如下一个stage总共有100个task，那么当前stage的每个task都要创建100份磁盘文件。如果当前stage有50个 task，总共有10个Executor，每个Executor执行5个Task，那么每个Executor上总共就要创建500个磁盘文件，所有 Executor上会创建5000个磁盘文件。由此可见，未经优化的shuffle write操作所产生的磁盘文件的数量是极其惊人的。

接着我们来说说shuffle
read。shuffle
read，通常就是一个stage刚开始时要做的事情。此时该stage的每一个task就需要将上一个stage的计算结果中的所有相同key，从各个 节点上通过网络都拉取到自己所在的节点上，然后进行key的聚合或连接等操作。由于shuffle write的过程中，task给下游stage的每个task都创建了一个磁盘文件，因此shuffle read的过程中，每个task只要从上游stage的所有task所在节点上，拉取属于自己的那一个磁盘文件即可。

shuffle read的拉取过程是一边拉取一边进行聚合的。每个shuffle read task都会有一个自己的buffer缓冲，每次都只能拉取与buffer缓冲相同大小的数据，然后通过内存中的一个Map进行聚合等操作。聚合完一批数 据后，再拉取下一批数据，并放到buffer缓冲中进行聚合操作。以此类推，直到最后将所有数据到拉取完，并得到最终的结果。

优化后的HashShuffleManager

这里说的优化，是指我们可以设置一个参 数，spark.shuffle.consolidateFiles。该参数默认值为false，将其设置为true即可开启优化机制。通常来说，如果我 们使用HashShuffleManager，那么都建议开启这个选项。

开启consolidate机制之后，在shuffle write过程中，task就不是为下游stage的每个task创建一个磁盘文件了。此时会出现shuffleFileGroup的概念，每个 shuffleFileGroup会对应一批磁盘文件，磁盘文件的数量与下游stage的task数量是相同的。一个Executor上有多少个CPU core，就可以并行执行多少个task。而第一批并行执行的每个task都会创建一个shuffleFileGroup，并将数据写入对应的磁盘文件 内。

当Executor的CPU core执行完一批task，接着执行下一批task时，下一批task就会复用之前已有的shuffleFileGroup，包括其中的磁盘文件。也就 是说，此时task会将数据写入已有的磁盘文件中，而不会写入新的磁盘文件中。因此，consolidate机制允许不同的task复用同一批磁盘文件， 这样就可以有效将多个task的磁盘文件进行一定程度上的合并，从而大幅度减少磁盘文件的数量，进而提升shuffle
write的性能。

假设第二个stage有100个task，第一个stage有50个task，总共还是有10个Executor，每个Executor执行5个 task。那么原本使用未经优化的HashShuffleManager时，每个Executor会产生500个磁盘文件，所有Executor会产生 5000个磁盘文件的。但是此时经过优化之后，每个Executor创建的磁盘文件的数量的计算公式为：CPU core的数量 * 下一个stage的task数量。也就是说，每个Executor此时只会创建100个磁盘文件，所有Executor只会创建1000个磁盘文件。