spark提交命令spark-submit的参数executor-memory、
execu。。。
add是什么意思
nohup spark-submit
--master yarn
--deploy-mode cluster
--jars /xx/xx/xx/xx.jar
--class com.spark_kudu_parquet.spark_kudu
--name spark_kudu
--driver-memory 2g
--driver-cores 2
frank lucas
-
-executor-memory 2g
--executor-cores 2
ladyantebellum
--num-executors 24
--conf spark.default.parallelism=300receive是什么意思
spark_kudu_parquet-1.0-SNAPSHOT.jar > out.log &
带有 CDH6.1.1 版本的jar包（每个jar包之间不能有空格，并且使⽤逗号分隔）
（yarn集群模式）nohup spark-submit --master yarn --deploy-mode cluster --jars /home/gzp/spark_kudu/jars/accessors-smart-1.2.jar,/home/gzp/spark_kudu/jars/（local本地单机模式）nohup spark-submit --master local --deploy-mode client --jars /home/gzp/spark_kudu/jars/accessors-smart-1.2.jar,/home/gzp/spark_kudu/ja
参数解析：
1.3台主机，每台主机有2个cpu和62G内存，每个cpu有8个核，那么每台机器⼀共有16核，3台机器⼀共有48个核
2.num-executors 24 和 executor-cores 2：每个executors⽤2个核，那么24个executors⼀共⽤48个核
3.num-executors 24 和 executor-memory 2g：每个executors⽤2g，那么24个executors⼀共⽤48g
权限翻译4.每个主机的executors数量 = 30 / 8 约等于 3.75
5.spark.default.parallelism：指定并⾏的task数量为300
参数说明：该参数⽤于设置每个stage的默认task数量。这个参数极为重要，如果不设置可能会直接影响你的Spark作业性能。
参数调优建议：Spark作业的默认task数量为500~1000个较为合适。很多同学常犯的⼀个错误就是不去设置这个参数，
那么此时就会导致Spark⾃⼰根据底层HDFS的block数量来设置task的数量，默认是⼀个HDFS block对应⼀个task。
通常来说，Spark默认设置的数量是偏少的（⽐如就⼏⼗个task），如果task数量偏少的话，就会导致你前⾯设置好的Executor的参数都前功尽弃。
试想⼀下，⽆论你的Executor进程有多少个，内存和CPU有多⼤，但是task只有1个或者10个，那么90%的Executor进程可能根本就没有task执⾏，
也就是⽩⽩浪费了资源！因此Spark官⽹建议的设置原则是，设置该参数为num-executors * executor-cores的2~3倍较为合适，
⽐如Executor的总CPU core数量为300个，那么设置1000个task是可以的，此时可以充分地利⽤Spark集群的资源。
ps aux|grep spark_kudu_parquet-1.0-SNAPSHOT.jar
查看yarn当前运⾏任务列表，可使⽤如下命令查看：yarn application -list
如需杀死当前某个作业，使⽤kill application-id的命令如下：yarn application -kill spark程序id
nohup spark-submit --master yarn --deploy-mode cluster
--jars /home/xx/lib/mysql-connector-java-5.1.32-bin.jar --
--name XX
-
-driver-memory 2g
--driver-cores 2
--executor-memory 2g
--executor-cores 2
--num-executors 30
--conf spark.default.parallelism=300
xx-0.0.1-SNAPSHOT.jar > xx.log &
参数解析：
1.8台主机，每台主机有2个cpu和62G内存，每个cpu有8个核，那么每台机器⼀共有16核，8台机器⼀共有128核
2.num-executors 30 和 executor-cores 2：每个executors⽤2个核，那么30个executors⼀共⽤60个核
3.num-executors 30 和 executor-memory 2g：每个executors⽤2g，那么30个executors⼀共⽤60g
4.每个主机的executors数量 = 30 / 8 约等于 3.75
5.spark.default.parallelism：指定并⾏的task数量为300
参数说明：该参数⽤于设置每个stage的默认task数量。这个参数极为重要，如果不设置可能会直接影响你的Spark作业性能。
参数调优建议：Spark作业的默认task数量为500~1000个较为合适。很多同学常犯的⼀个错误就是不去设置这个参数，
那么此时就会导致Spark⾃⼰根据底层HDFS的block数量来设置task的数量，默认是⼀个HDFS block对应⼀个task。
通常来说，Spark默认设置的数量是偏少的（⽐如就⼏⼗个task），如果task数量偏少的话，就会导致你前⾯设置好的Executor的参数都前功尽弃。
试想⼀下，⽆论你的Executor进程有多少个，内存和CPU有多⼤，但是task只有1个或者10个，那么90%的Executor进程可能根本就没有task执⾏，
也就是⽩⽩浪费了资源！因此Spark官⽹建议的设置原则是，设置该参数为num-executors * executor-cores的2~3倍较为合适，
⽐如Executor的总CPU core数量为300个，那么设置1000个task是可以的，此时可以充分地利⽤Spark集群的资源。
num-executors
参数说明：该参数⽤于设置Spark作业总共要⽤多少个Executor进程来执⾏。
Driver在向YARN集群管理器申请资源时，YARN集群管理器会尽可能按照你的设置来在集群的各个⼯作节点上，启动相应数量的Executor进程。
这个参数⾮常之重要，如果不设置的话，默认只会给你启动少量的Executor进程，此时你的Spark作业的运⾏速度是⾮常慢的。
参数调优建议：每个Spark作业的运⾏⼀般设置50~100个左右的Executor进程⽐较合适，设置太少或太多的Executor进程都不好。
设置的太少，⽆法充分利⽤集群资源；设置的太多的话，⼤部分队列可能⽆法给予充分的资源。
executor-cores
参数说明：该参数⽤于设置每个Executor进程的CPU core数量。这个参数决定了每个Executor进程并⾏执⾏task线程的能⼒。
因为每个CPU core同⼀时间只能执⾏⼀个task线程，因此每个Executor进程的CPU core数量越多，越能够快速地执⾏完分配给⾃⼰的所有task线程。
参数调优建议：Executor的CPU core数量设置为2~4个较为合适。
同样得根据不同部门的资源队列来定，可以看看⾃⼰的资源队列的最⼤CPU core限制是多少，再依据设置的Executor数量，来决定每个Executor进程可以分配到⼏同样建议，如果是跟他⼈共享这个队列，那么num-executors * executor-cores不要超过队列总CPU core的1/3~1/2左右⽐较合适，也是避免影响其他同学的作业运
executor-memory
参数说明：该参数⽤于设置每个Executor进程的内存。Executor内存的⼤⼩，很多时候直接决定了Spark作业的性能，⽽且跟常见的JVM OOM异常，也有直接的关联参数调优建议：每个Executor进程的内存设置4G~8G较为合适。但是这只是⼀个参考值，具体的设置还是得根据不同部门的资源队列来定。
可以看看⾃⼰团队的资源队列的最⼤内存限制是多少，num-executors乘以executor-memory，就代表了你的Spark作业申请到的总内存量（也就是所有Executor进这个量是不能超过队列的最⼤内存量的。此外，如果你是跟团队⾥其他⼈共享这个资源队列，那么申请的总内存量最好不要超过资源队列最⼤总内存的1/3~1/2，避免你⾃⼰的Spark作业占⽤了队列所有的资源，导致别的同学的作业⽆法运⾏。
--driver-memory
Driver内存，默认1G
--driver-cores
Driver的核数，默认是1。在yarn集群模式下使⽤
====================================================================================================
在我们提交spark程序时，应该如何为Spark集群配置 num-executors、executor-memory、execuor-cores 呢？
Hadoop / Yarn / OS Deamons
当我们使⽤像Yarn这样的集群管理器运⾏spark应⽤程序时，会有⼏个守护进程在后台运⾏，如NameNode，Secondary NameNode，DataNode，JobTracker和Tas 因此，在指定num-executors时，我们需要确保为这些守护进程留下⾜够的核⼼（⾄少每个节点约1 CPU核）以便顺利运⾏。
Yarn ApplicationMaster（AM）
ApplicationMaster负责协调来⾃ResourceManager的资源，并与NodeManagers⼀起执⾏container并监控其资源消耗。
如果我们在YARN上运⾏Spark，那么我们需要预估运⾏AM所需要的资源（⾄少1024MB和1 CPU核）。
HDFS吞吐量
HDFS客户端遇到⼤量并发线程会出现⼀些bug。⼀般来说，每个executors最多可以实现5个任务的完全写⼊吞吐量，因此最好将每个executors的核⼼数保持在该数量 MemoryOverhead
JVM还需要⼀些off heap的内存，请参考下图中描绘的Spark和YARN中内存属性的层次结构，
简单来说，有以下两个公式：
每个executor从YARN请求的内存 = utor-memory + Overhead
Overhead = Max(384MB, 7% utor-memory)
例如当我设置 --executor-memory=20 时，我们实际请求了 20GB + memoryOverhead = 20 + 7% of 20GB = ~23GB。
运⾏具有executors较⼤内存的通常会导致过多的GC延迟。
运⾏具有executors较⼩内存的（例如，1G & 1 CPU core）则会浪费单个JVM中运⾏多个任务所带来的优点。
不同配置的优劣分析
1.现在，让我们考虑⼀个具有以下配置的10节点集群，并分析执⾏程序的不同可能性，核⼼内存分布：
10 Nodes
每个Node：16 cores、64GB RAM
2.第⼀种⽅法：使⽤较⼩的executors，每个核⼼⼀个executors
`--num-executors` = `在这种⽅法中，我们将为每个核⼼分配⼀个executor`
= `集群的总核⼼数`
= `每个节点的核⼼数 * 集群的总节点数`
= 16 x 10 = 160
`--executor-cores` = 1 (`每个executor分配的核⼼数⽬`)
`--executor-memory` = `每个executor分配的内存数`
= `每个节点内存总数 / 每个节点上分配的executor数`
= 64GB/16 = 4GB
分析：
由于每个executor只分配了⼀个核，我们将⽆法利⽤在同⼀个JVM中运⾏多个任务的优点。
此外，共享/缓存变量（如⼴播变量和累加器）将在节点的每个核⼼中复制16次。
最严重的就是，我们没有为Hadoop / Yarn守护程序进程留下⾜够的内存开销，我们还忘记了将ApplicationManagers运⾏所需要的开销加⼊计算。
3.第⼆种⽅法：使⽤较⼤的executors，每个节点⼀个executors
`--num-executors` = `在这种⽅法中，我们将为每个节点分配⼀个executor`
= `集群的总节点数`
= 10
`--executor-cores` = `每个节点⼀个executor意味着该节点的所有核⼼都分配给⼀个执executor`
= `每个节点的总核⼼数`
= 16
`--executor-memory` = `每个executor分配的内存数`
= `每个节点内存总数数/每个节点上分配的executor数`
byz
= 64GB/1 = 64GB
分析：
每个executor都有16个核⼼，由于HDFS客户端遇到⼤量并发线程会出现⼀些bug，即HDFS吞吐量会受到影响。
同时过⼤的内存分配也会导致过多的GC延迟。ApplicationManager和守护进程没有计算在内，HDFS的吞吐量会受到影响，并且会导致垃圾结果过多，不好！
4.第三种⽅法：使⽤优化的executors
1.基于上⾯提到的建议，让我们为每个执⾏器分配5个核⼼, 即 --executor-cores = 5（⽤于良好的HDFS吞吐量）
2.为每个节点留出1个核⼼⽤于Hadoop / Yarn守护进程, 即每个节点可⽤的核⼼数为 16 -1 = 15。因此，群集中核⼼的可⽤总数剩余 15 x 10 = 150
3.可⽤executors的数量 =（群集中核⼼的可⽤总数/每个executors分配的核⼼数）= 150/5 = 30
gorgeous是什么意思然后为ApplicationManager预留1个executors的资源，所以即 --num-executors = 29
每个节点的executors数⽬ 30/10 = 3
4.群集中每个节点的可使⽤的总内存数 64GB - 1GB = 63GB
每个executor的内存= 64GB / 3 = 21GB
预留的 off heap overhead = 21GB * 7％约等于 1.47G
所以，实际的--executor-memory = 21 - 1.47G 约等于 19GB
5.所以，推荐的配置是：29个executors，每个executors 18GB内存，每个executors 5个核⼼！
--num-executors = 29
--executor-cores = 5
--executor-memory = 18
====================================================================================================
属性名称默认值含义
出丑放乖
executor 数量 = s.max / s
executor 进程的数量等于 spark程序设置的最⼤核⼼数除以每个 executor进程分配的核⼼数
⽐如机器有12cpu和36g内存，那么将会启动12/4=3个executor，每个executor使⽤4cpu和12g内存，总共占⽤worker资源12cpu和36g内存
默认情况下，Spark集群下的worker，只会启动⼀个Executor。
1、设置每个executor使⽤的cpu数为4
2、设置cpu的最⼤使⽤数量
3、设置每个executor的内存⼤⼩为12gg
< 12g
Spark1.6的源码部分为：
protected final String EXECUTOR_MEMORY = "--executor-memory";
protected final String TOTAL_EXECUTOR_CORES = "--total-executor-cores";
protected final String EXECUTOR_CORES = "--executor-cores";
也可以在提交任务的时候添加：
SparkSubmit
--class com.dyq.spark.MyClass
--master:spark://master:7077
--total-executor-cores 12
-
-executor-cores 24
--executor-memory 12g
Executor是spark任务(task)的执⾏单元，Executor运⾏在worker上，但是不等同于worker，实际上Executor是⼀组计算资源(cpu核⼼、memory)的集合。
⼀个worker上的memory、cpu由多个executor共同使⽤。
< 配置executor内存⼤⼩
executor个数 = s / s
集群的executor个数由s、s共同决定，注意在standalone、mesos coar-grained模式下cores不要⼤于对应节点的内核数
要保证每个worker上启动的executor均衡。如果不均衡的话会造成数据倾斜，拉慢任务的整体速度。
在运⾏过程中⼀个task对应⼀个partition，配置不均衡，会导致每个节点处理的任务量不⼀样，因此会产⽣短板效应。
如果运⾏过程中发现GC时间变红（管理界⾯可以看到），应该适当调⼤
====================================================================================================
1.RDD在计算的时候，RDD中的每个分区都会起⼀个task，所以rdd中的分区数⽬决定了总的的task数⽬。
2.申请的计算节点Executor数⽬和每个计算节点核数，决定了你同⼀时刻可以并⾏执⾏的task数⽬。
3.⽐如的RDD中有100个分区，那么计算的时候就会⽣成100个task，你的资源配置为10个计算节点Executor数⽬，每个计算节点Executor有两2个核，
同⼀时刻可以并⾏的task数⽬为20，计算这个RDD就需要5轮。
4.如果计算资源不变，你有101个task的话，就需要6个轮次，在最后⼀轮中，只有⼀个task在执⾏，其余核都在空转。
5.如果资源不变，你的RDD只有2个分区，那么同⼀时刻只有2个task运⾏，其余18个核空转，造成资源浪费。这就是在spark调优中，增⼤RDD分区数⽬，增⼤任务并
指定spark executor 数量的公式
executor数量 = s.s
指定并⾏的task数量
spark.default.parallelism
参数说明：该参数⽤于设置每个stage的默认task数量。这个参数极为重要，如果不设置可能会直接影响你的Spark作业性能。
参数调优建议：Spark作业的默认task数量为500~1000个较为合适。很多同学常犯的⼀个错误就是不去设置这个参数，
那么此时就会导致Spark⾃⼰根据底层HDFS的block数量来设置task的数量，默认是⼀个HDFS block对应⼀个task。
通常来说，Spark默认设置的数量是偏少的（⽐如就⼏⼗个task），如果task数量偏少的话，就会导致你前⾯设置好的Executor的参数都前功尽弃。
试想⼀下，⽆论你的Executor进程有多少个，内存和CPU有多⼤，但是task只有1个或者10个，那么90%的Executor进程可能根本就没有task执⾏，
也就是⽩⽩浪费了资源！因此Spark官⽹建议的设置原则是，设置该参数为num-executors * executor-cores的2~3倍较为合适，
⽐如Executor的总CPU core数量为300个，那么设置1000个task是可以的，此时可以充分地利⽤Spark集群的资源。
在关于spark任务并⾏度的设置中，有两个参数我们会经常遇到，spark.sql.shuffle.partitions 和 spark.default.parallelism, 那么这两个参数到底有什么区别的？
⾸先，让我们来看下它们的定义
spark.sql.shuffle.partitions（对sparks SQL专⽤的设置）
默认值：200
remain是什么意思含义：当shuffle数据时，配置joins联接或aggregations聚合时要使⽤的分区数
spark.default.parallelism（只有在处理RDD时才会起作⽤，对Spark SQL的⽆效）
默认值：
1.对于分布式⽆序移动操作（如reducebykey和join），⽗RDD中的最⼤分区数。
2.对于没有⽗RDD的并⾏化操作，它取决于集群管理器：
1.本地模式：本地计算机上的核⼼数
平均相对误差2.细粒模式：8
3.其他：所有执⾏器节点上的核⼼总数或2个，以较⼤者为准。
含义：在RDD中，由join、reducebykey、parallelize等转换（如果不是由⽤户设置）返回的默认分区数
