1.分配更多的资源
它是性能优化调优的王道，就是增加和分配更多的资源，这对于性能和速度上的提升是显而易见的， 基本上，在一定范围之内，增加资源与性能的提升，是成正比的；写完了一个复杂的spark作业之后，进行性能调 优的时候，
首先第一步，就是要来调节优的资源配置；在这个基础之上，如果说你的spark作业，能够分配的资源达到 了你的能力范围的顶端之后，无法再分配更多的资源了，公司资源有限；那么才是考虑去做后面的这些性能调优的点。
2.参数调节到多大才算大
第一种情况：standalone模式 先计算出公司spark集群上的所有资源 每台节点的内存大小和cpu核数， 比如：一共有20台worker节点，每台节点8g内存，10个cpu。 实际任务在给定资源的时候，可以给20个executor、
每个executor的内存8g、每个executor的使用的cpu个数 10。 第二种情况：Yarn 先计算出yarn集群的所有大小，比如一共500g内存，100个cpu； 这个时候可以分配的大资源，比如给定50个executor、每个executor的内存
大小10g,每个executor使用的cpu 个数为2。 使用原则：你能使用的资源有多大，就尽量去调节到大的大小（executor的数量：几十个到上百个不等；executor的 内存；exector的cpu个数）
3.spark的并行度指的是什么
spark作业中，各个stage的task的数量，也就代表了spark作业在各个阶段stage的并行度！ 当分配完所能分配的大资源了，然后对应资源去调节程序的并行度，如果并行度没有与资源相匹配，那么导致你 分配下去的资源都浪
费掉了。同时并行运行，还可以让每个task要处理的数量变少（很简单的原理。合理设置并行度， 可以充分利用集群资源，减少每个task处理数据量，而增加性能加快运行速度。） 举例说明： 假如， 现在已经在spark‐submit 脚本
里面，给我们的spark作业分配了足够多的资源，比如50个executor ，每 个executor 有10G内存，每个executor有3个cpu core 。 基本已经达到了spark集群或者yarn集群上限。task没有 设置，或者设置的很少，比如就设置了100个task、
50个executor、每个executor有3个core ，也就是说 Application 任何一个stage运行的时候，都有总数150个cpu core ，可以并行运行。 但是你现在只有100个task，平均分配一下，每个executor 分配到2个task，那么同时在运行的task，
只有100个 task，每个executor 只会并行运行 2个task。 每个executor 剩下的一个cpu core 就浪费掉了！你的资源，虽然分 配充足了，但是问题是， 并行度没有与资源相匹配，导致你分配下去的资源都浪费掉了。合理的并行度的设置，
应该要 设置的足够大，大到可以完全合理的利用你的集群资源； 比如上面的例子，总共集群有150个cpu core ，可以并行运 行150个task。那么你就应该将你的Application 的并行度，至少设置成150个，才能完全有效的利用你的集群资源，
让150个task并行执行，而且task增加到150个以后，即可以同时并行运行，还可以让每个task要处理的数量变少； 比 如总共150G的数据要处理， 如果是100个task ，每个task 要计算1.5G的数据。 现在增加到150个task，每个task只 要处
理1G数据。
4.如何提高并行度
①.可以设置task的数量
至少设置成与spark Application 的总cpu core 数量相同（理想情况，150个core，分配150task，一起运 行，差不多同一时间运行完毕）官方推荐，task数量，设置成spark Application 总cpu core数量的
2~3倍 。 比如150个cpu core ，基本设置task数量为300~500. 与理想情况不同的，有些task会运行快一点，比如50s就完 了，有些task 可能会慢一点，要一分半才运行完，所以如果你的task数量，刚好设置的跟cpu core
数量相同，可能会 导致资源的浪费。 因为比如150个task中10个先运行完了，剩余140个还在运行，但是这个时候，就有10个cpu core空闲出来了，导 致浪费。如果设置2~3倍，那么一个task运行完以后，另外一个task
马上补上来，尽量让cpu core不要空闲。同时尽量 提升spark运行效率和速度。提升性能。
②.如何设置task数量来提高并行度
设置参数spark.defalut.parallelism 默认是没有值的，如果设置了值为10，它会在shuffle的过程才会起作用。 比如 val rdd2 = rdd1.reduceByKey(_+_) 此时rdd2的分区数就是10，rdd1的分区数不受这
个参数的影响。 可以通过在构建SparkConf对象的时候设置，例如： new SparkConf().set("spark.defalut.parallelism","500")
③.给RDD重新设置partition的数量
使用rdd.repartition 来重新分区，该方法会生成一个新的rdd，使其分区数变大。
此时由于一个partition对应一个task，那么对应的task个数越多，通过这种方式也可以提高并行度。
④.提高sparksql运行的task数量
通过设置参数 spark.sql.shuffle.partitions=500 默认为200；
可以适当增大，来提高并行度。 比如设置为 spark.sql.shuffle.partitions=500
5.如何对RDD进行持久化
可以调用rdd的cache或者persist方法。
（1）cache方法默认是把数据持久化到内存中 ，例如：rdd.cache ，其本质还是调用了persist方法
（2）persist方法中有丰富的缓存级别，这些缓存级别都定义在StorageLevel这个object中，可以结合实际的应用场 景合理的设置缓存级别。例如： rdd.persist(StorageLevel.MEMORY_ONLY),这是cache方法的实现。
6.RDD持久化时可采用序列化
（1）如果正常将数据持久化在内存中，那么可能会导致内存的占用过大，这样的话，也许会导致OOM内存溢出。
（2）当纯内存无法支撑公共RDD数据完全存放的时候，就优先考虑使用序列化的方式在纯内存中存储。将RDD的每个 partition的数据，序列化成一个字节数组；序列化后，大大减少内存的空间占用。
（3）序列化的方式，唯一的缺点就是，在获取数据的时候，需要反序列化。但是可以减少占用的空间和便于网络传输
（4）如果序列化纯内存方式，还是导致OOM，内存溢出；就只能考虑磁盘的方式，内存+磁盘的普通方式（无序列化）。
（5）为了数据的高可靠性，而且内存充足，可以使用双副本机制，进行持久化 持久化的双副本机制，持久化后的一个副本，因为机器宕机了，副本丢了，就还是得重新计算一次；
持久化的每个数据单元，存储一份副本，放在其他节点上面，从而进行容错； 一个副本丢了，不用重新计算，还可以使用另外一份副本。这种方式，仅仅针对你的内存资源极度充足。
比如: StorageLevel.MEMORY_ONLY_
7.广播变量的使用
①.场景描述
在实际工作中可能会遇到这样的情况，由于要处理的数据量非常大，这个时候可能会在一个stage中出现大量的 task，比如有1000个task，这些task都需要一份相同的数据来处理业务，这份数据的大小为100M，
该数据会拷贝 1000份副本，通过网络传输到各个task中去，给task使用。这里会涉及大量的网络传输开销，同时至少需要的内存 为1000*100M=100G，这个内存开销是非常大的。不必要的内存的消耗和占用，就导致了，
你在进行RDD持久化 到内存，也许就没法完全在内存中放下；就只能写入磁盘，后导致后续的操作在磁盘IO上消耗性能；这对于 spark任务处理来说就是一场灾难。
由于内存开销比较大，task在创建对象的时候，可能会出现堆内存放不下所有对象，就会导致频繁的垃圾回收器的 回收GC。GC的时候一定是会导致工作线程停止，也就是导致Spark暂停工作那么一点时间。频繁GC的话，
对 Spark作业的运行的速度会有相当可观的影响
②.广播变量的引入
Spark中分布式执行的代码需要传递到各个executor的task上运行。对于一些只读、固定的数据,每次都需要Driver 广播到各个Task上，这样效率低下。广播变量允许将变量只广播（提前广播）给各个executor。
该executor上的各 个task再从所在节点的BlockManager(负责管理某个executor对应的内存和磁盘上的数据)获取变量，而不是从 Driver获取变量，从而提升了效率。
广播变量，初始的时候，就在Drvier上有一份副本。通过在Driver把共享数据转换成广播变量。 task在运行的时候，想要使用广播变量中的数据，此时首先会在自己本地的Executor对应的BlockManager中，
尝 试获取变量副本；如果本地没有，那么就从Driver远程拉取广播变量副本，并保存在本地的BlockManager中； 此后这个executor上的task，都会直接使用本地的BlockManager中的副本。那么这个时候所有该executor的
task都会使用这个广播变量的副本。也就是说一个executor只需要在第一个task启动时，获得一份广播变量数据，之后 的task都从本节点的BlockManager中获取相关数据。 executor的BlockManager除了从driver上拉取，也可
能从其他节点的BlockManager上拉取变量副本，网络距离 越近越好。
③.使用广播变量后的性能分析
比如一个任务需要50个executor，1000个task，共享数据为100M。 (1)在不使用广播变量的情况下，1000个task，就需要该共享数据的1000个副本，也就是说有1000份数需要大量的网络 传输和内存开销存储。
耗费的内存大小1000*100=100G. (2)使用了广播变量后，50个executor就只需要50个副本数据，而且不一定都是从Driver传输到每个节点，还可能是就 近从近的节点的executor的blockmanager上拉取广播变量副本，网络传输
速度大大增加；内存开销 50*100M=5G 总结： 不使用广播变量的内存开销为100G，使用后的内存开销5G，这里就相差了20倍左右的网络传输性能损耗和内存开 销，使用广播变量后对于性能的提升和影响，还是很可观的。
广播变量的使用不一定会对性能产生决定性的作用。比如运行30分钟的spark作业，可能做了广播变量以后，速度 快了2分钟，或者5分钟。但是一点一滴的调优，积少成多。后还是会有效果的
④.如何使用广播变量
例如：
(1) 通过sparkContext的broadcast方法把数据转换成广播变量，类型为Broadcast， val broadcastArray: Broadcast[Array[Int]] = sc.broadcast(Array(1,2,3,4,5,6))
(2) 然后executor上的BlockManager就可以拉取该广播变量的副本获取具体的数据。 获取广播变量中的值可以通过调用其value方法 val array: Array[Int] = broadcastArray.valu
8.使用Kryo序列化
①.spark序列化介绍
Spark在进行任务计算的时候，会涉及到数据跨进程的网络传输、数据的持久化，这个时候就需要对数据进行序列 化。Spark默认采用Java的序列化器。默认java序列化的优缺点如下:
其好处： 处理起来方便，不需要我们手动做其他操作，只是在使用一个对象和变量的时候，需要实现Serializble接口。 其缺点： 默认的序列化机制的效率不高，序列化的速度比较慢；序列化以后的数据，占用的内存空间相对还
是比较大。
Spark支持使用Kryo序列化机制。Kryo序列化机制，比默认的Java序列化机制，速度要快，序列化后的数据要更小，大 概是Java序列化机制的1/10。所以Kryo序列化优化以后，可以让网络传输的数据变少；在集群中
耗费的内存资源大大减 少。
②.Kryo序列化启动后生效的地方
Kryo序列化机制，一旦启用以后，会生效的几个地方：
（1）算子函数中使用到的外部变量 算子中的外部变量可能来着与driver需要涉及到网络传输，就需要用到序列化。终可以优化网络传输的性能，优化集群中内存的占用和消耗
（2）持久化RDD时进行序列化，StorageLevel.MEMORY_ONLY_SER 将rdd持久化时，对应的存储级别里，需要用到序列化。 终可以优化内存的占用和消耗；持久化RDD占用的内存越少，task执行的时候，
创建的对象，就不至于频繁 的占满内存，频繁发生GC。
（3） 产生shuffle的地方，也就是宽依赖 下游的stage中的task，拉取上游stage中的task产生的结果数据，跨网络传输，需要用到序列化。 终可以优化网络传输的性
它是性能优化调优的王道，就是增加和分配更多的资源，这对于性能和速度上的提升是显而易见的， 基本上，在一定范围之内，增加资源与性能的提升，是成正比的；写完了一个复杂的spark作业之后，进行性能调 优的时候，
首先第一步，就是要来调节优的资源配置；在这个基础之上，如果说你的spark作业，能够分配的资源达到 了你的能力范围的顶端之后，无法再分配更多的资源了，公司资源有限；那么才是考虑去做后面的这些性能调优的点。
2.参数调节到多大才算大
第一种情况：standalone模式 先计算出公司spark集群上的所有资源 每台节点的内存大小和cpu核数， 比如：一共有20台worker节点，每台节点8g内存，10个cpu。 实际任务在给定资源的时候，可以给20个executor、
每个executor的内存8g、每个executor的使用的cpu个数 10。 第二种情况：Yarn 先计算出yarn集群的所有大小，比如一共500g内存，100个cpu； 这个时候可以分配的大资源，比如给定50个executor、每个executor的内存
大小10g,每个executor使用的cpu 个数为2。 使用原则：你能使用的资源有多大，就尽量去调节到大的大小（executor的数量：几十个到上百个不等；executor的 内存；exector的cpu个数）
3.spark的并行度指的是什么
spark作业中，各个stage的task的数量，也就代表了spark作业在各个阶段stage的并行度！ 当分配完所能分配的大资源了，然后对应资源去调节程序的并行度，如果并行度没有与资源相匹配，那么导致你 分配下去的资源都浪
费掉了。同时并行运行，还可以让每个task要处理的数量变少（很简单的原理。合理设置并行度， 可以充分利用集群资源，减少每个task处理数据量，而增加性能加快运行速度。） 举例说明： 假如， 现在已经在spark‐submit 脚本
里面，给我们的spark作业分配了足够多的资源，比如50个executor ，每 个executor 有10G内存，每个executor有3个cpu core 。 基本已经达到了spark集群或者yarn集群上限。task没有 设置，或者设置的很少，比如就设置了100个task、
50个executor、每个executor有3个core ，也就是说 Application 任何一个stage运行的时候，都有总数150个cpu core ，可以并行运行。 但是你现在只有100个task，平均分配一下，每个executor 分配到2个task，那么同时在运行的task，
只有100个 task，每个executor 只会并行运行 2个task。 每个executor 剩下的一个cpu core 就浪费掉了！你的资源，虽然分 配充足了，但是问题是， 并行度没有与资源相匹配，导致你分配下去的资源都浪费掉了。合理的并行度的设置，
应该要 设置的足够大，大到可以完全合理的利用你的集群资源； 比如上面的例子，总共集群有150个cpu core ，可以并行运 行150个task。那么你就应该将你的Application 的并行度，至少设置成150个，才能完全有效的利用你的集群资源，
让150个task并行执行，而且task增加到150个以后，即可以同时并行运行，还可以让每个task要处理的数量变少； 比 如总共150G的数据要处理， 如果是100个task ，每个task 要计算1.5G的数据。 现在增加到150个task，每个task只 要处
理1G数据。
4.如何提高并行度
①.可以设置task的数量
至少设置成与spark Application 的总cpu core 数量相同（理想情况，150个core，分配150task，一起运 行，差不多同一时间运行完毕）官方推荐，task数量，设置成spark Application 总cpu core数量的
2~3倍 。 比如150个cpu core ，基本设置task数量为300~500. 与理想情况不同的，有些task会运行快一点，比如50s就完 了，有些task 可能会慢一点，要一分半才运行完，所以如果你的task数量，刚好设置的跟cpu core
数量相同，可能会 导致资源的浪费。 因为比如150个task中10个先运行完了，剩余140个还在运行，但是这个时候，就有10个cpu core空闲出来了，导 致浪费。如果设置2~3倍，那么一个task运行完以后，另外一个task
马上补上来，尽量让cpu core不要空闲。同时尽量 提升spark运行效率和速度。提升性能。
②.如何设置task数量来提高并行度
设置参数spark.defalut.parallelism 默认是没有值的，如果设置了值为10，它会在shuffle的过程才会起作用。 比如 val rdd2 = rdd1.reduceByKey(_+_) 此时rdd2的分区数就是10，rdd1的分区数不受这
个参数的影响。 可以通过在构建SparkConf对象的时候设置，例如： new SparkConf().set("spark.defalut.parallelism","500")
③.给RDD重新设置partition的数量
使用rdd.repartition 来重新分区，该方法会生成一个新的rdd，使其分区数变大。
此时由于一个partition对应一个task，那么对应的task个数越多，通过这种方式也可以提高并行度。
④.提高sparksql运行的task数量
通过设置参数 spark.sql.shuffle.partitions=500 默认为200；
可以适当增大，来提高并行度。 比如设置为 spark.sql.shuffle.partitions=500
5.如何对RDD进行持久化
可以调用rdd的cache或者persist方法。
（1）cache方法默认是把数据持久化到内存中 ，例如：rdd.cache ，其本质还是调用了persist方法
（2）persist方法中有丰富的缓存级别，这些缓存级别都定义在StorageLevel这个object中，可以结合实际的应用场 景合理的设置缓存级别。例如： rdd.persist(StorageLevel.MEMORY_ONLY),这是cache方法的实现。
6.RDD持久化时可采用序列化
（1）如果正常将数据持久化在内存中，那么可能会导致内存的占用过大，这样的话，也许会导致OOM内存溢出。
（2）当纯内存无法支撑公共RDD数据完全存放的时候，就优先考虑使用序列化的方式在纯内存中存储。将RDD的每个 partition的数据，序列化成一个字节数组；序列化后，大大减少内存的空间占用。
（3）序列化的方式，唯一的缺点就是，在获取数据的时候，需要反序列化。但是可以减少占用的空间和便于网络传输
（4）如果序列化纯内存方式，还是导致OOM，内存溢出；就只能考虑磁盘的方式，内存+磁盘的普通方式（无序列化）。
（5）为了数据的高可靠性，而且内存充足，可以使用双副本机制，进行持久化 持久化的双副本机制，持久化后的一个副本，因为机器宕机了，副本丢了，就还是得重新计算一次；
持久化的每个数据单元，存储一份副本，放在其他节点上面，从而进行容错； 一个副本丢了，不用重新计算，还可以使用另外一份副本。这种方式，仅仅针对你的内存资源极度充足。
比如: StorageLevel.MEMORY_ONLY_
7.广播变量的使用
①.场景描述
在实际工作中可能会遇到这样的情况，由于要处理的数据量非常大，这个时候可能会在一个stage中出现大量的 task，比如有1000个task，这些task都需要一份相同的数据来处理业务，这份数据的大小为100M，
该数据会拷贝 1000份副本，通过网络传输到各个task中去，给task使用。这里会涉及大量的网络传输开销，同时至少需要的内存 为1000*100M=100G，这个内存开销是非常大的。不必要的内存的消耗和占用，就导致了，
你在进行RDD持久化 到内存，也许就没法完全在内存中放下；就只能写入磁盘，后导致后续的操作在磁盘IO上消耗性能；这对于 spark任务处理来说就是一场灾难。
由于内存开销比较大，task在创建对象的时候，可能会出现堆内存放不下所有对象，就会导致频繁的垃圾回收器的 回收GC。GC的时候一定是会导致工作线程停止，也就是导致Spark暂停工作那么一点时间。频繁GC的话，
对 Spark作业的运行的速度会有相当可观的影响
②.广播变量的引入
Spark中分布式执行的代码需要传递到各个executor的task上运行。对于一些只读、固定的数据,每次都需要Driver 广播到各个Task上，这样效率低下。广播变量允许将变量只广播（提前广播）给各个executor。
该executor上的各 个task再从所在节点的BlockManager(负责管理某个executor对应的内存和磁盘上的数据)获取变量，而不是从 Driver获取变量，从而提升了效率。
广播变量，初始的时候，就在Drvier上有一份副本。通过在Driver把共享数据转换成广播变量。 task在运行的时候，想要使用广播变量中的数据，此时首先会在自己本地的Executor对应的BlockManager中，
尝 试获取变量副本；如果本地没有，那么就从Driver远程拉取广播变量副本，并保存在本地的BlockManager中； 此后这个executor上的task，都会直接使用本地的BlockManager中的副本。那么这个时候所有该executor的
task都会使用这个广播变量的副本。也就是说一个executor只需要在第一个task启动时，获得一份广播变量数据，之后 的task都从本节点的BlockManager中获取相关数据。 executor的BlockManager除了从driver上拉取，也可
能从其他节点的BlockManager上拉取变量副本，网络距离 越近越好。
③.使用广播变量后的性能分析
比如一个任务需要50个executor，1000个task，共享数据为100M。 (1)在不使用广播变量的情况下，1000个task，就需要该共享数据的1000个副本，也就是说有1000份数需要大量的网络 传输和内存开销存储。
耗费的内存大小1000*100=100G. (2)使用了广播变量后，50个executor就只需要50个副本数据，而且不一定都是从Driver传输到每个节点，还可能是就 近从近的节点的executor的blockmanager上拉取广播变量副本，网络传输
速度大大增加；内存开销 50*100M=5G 总结： 不使用广播变量的内存开销为100G，使用后的内存开销5G，这里就相差了20倍左右的网络传输性能损耗和内存开 销，使用广播变量后对于性能的提升和影响，还是很可观的。
广播变量的使用不一定会对性能产生决定性的作用。比如运行30分钟的spark作业，可能做了广播变量以后，速度 快了2分钟，或者5分钟。但是一点一滴的调优，积少成多。后还是会有效果的
④.如何使用广播变量
例如：
(1) 通过sparkContext的broadcast方法把数据转换成广播变量，类型为Broadcast， val broadcastArray: Broadcast[Array[Int]] = sc.broadcast(Array(1,2,3,4,5,6))
(2) 然后executor上的BlockManager就可以拉取该广播变量的副本获取具体的数据。 获取广播变量中的值可以通过调用其value方法 val array: Array[Int] = broadcastArray.valu
8.使用Kryo序列化
①.spark序列化介绍
Spark在进行任务计算的时候，会涉及到数据跨进程的网络传输、数据的持久化，这个时候就需要对数据进行序列 化。Spark默认采用Java的序列化器。默认java序列化的优缺点如下:
其好处： 处理起来方便，不需要我们手动做其他操作，只是在使用一个对象和变量的时候，需要实现Serializble接口。 其缺点： 默认的序列化机制的效率不高，序列化的速度比较慢；序列化以后的数据，占用的内存空间相对还
是比较大。
Spark支持使用Kryo序列化机制。Kryo序列化机制，比默认的Java序列化机制，速度要快，序列化后的数据要更小，大 概是Java序列化机制的1/10。所以Kryo序列化优化以后，可以让网络传输的数据变少；在集群中
耗费的内存资源大大减 少。
②.Kryo序列化启动后生效的地方
Kryo序列化机制，一旦启用以后，会生效的几个地方：
（1）算子函数中使用到的外部变量 算子中的外部变量可能来着与driver需要涉及到网络传输，就需要用到序列化。终可以优化网络传输的性能，优化集群中内存的占用和消耗
（2）持久化RDD时进行序列化，StorageLevel.MEMORY_ONLY_SER 将rdd持久化时，对应的存储级别里，需要用到序列化。 终可以优化内存的占用和消耗；持久化RDD占用的内存越少，task执行的时候，
创建的对象，就不至于频繁 的占满内存，频繁发生GC。
（3） 产生shuffle的地方，也就是宽依赖 下游的stage中的task，拉取上游stage中的task产生的结果数据，跨网络传输，需要用到序列化。 终可以优化网络传输的性
来源：https://www.cnblogs.com/lvhongwi/p/12436058.html