Spark性能调优系列：Spark参数配置大全（官网资料）

Spark参数配置大全

 

Spark提供了三个位置来配置系统

Spark属性控制大多数应用程序参数，可以使用SparkConf对象或Java系统属性来设置。
通过conf/spark-env.sh每个节点上的脚本，环境变量可用于设置每台计算机的设置，例如IP地址。
可以通过配置日志log4j.properties。

Spark属性

Spark属性控制大多数应用程序设置，并分别为每个应用程序配置。这些属性可以在传递给 的SparkConf上直接设置 SparkContext。SparkConf允许您配置一些常用属性（例如主URL和应用程序名称），以及通过该set()方法配置任意键/值对 。
例如，我们可以使用两个线程来初始化应用程序，如下所示：
请注意，我们使用local [2]运行，这意味着两个线程-表示“最小”并行度，这可以帮助检测仅当我们在分布式上下文中运行时才存在的错误。

val conf = new SparkConf()
             .setMaster("local[2]")
             .setAppName("CountingSheep")
val sc = new SparkContext(conf)

动态加载Spark属性

在某些情况下，您可能希望避免对中的某些配置进行硬编码SparkConf。例如，如果您想使用不同的主机或不同的内存量运行同一应用程序。Spark允许您简单地创建一个空的conf

val sc = new SparkContext(new SparkConf())

运行时配置值

./bin/spark-submit --name "My app" --master local[4] --conf spark.eventLog.enabled=false
  --conf "spark.executor.extraJavaOptions=-XX:+PrintGCDetails -XX:+PrintGCTimeStamps" myApp.jar

Spark Shell和spark-submit 工具支持两种动态加载配置的方式。第一个是命令行选项，例如--master，如上所示。
spark-submit可以使用该--conf 标志接受任何Spark属性，但对在启动Spark应用程序中起作用的属性使用特殊标志。运行./bin/spark-submit --help将显示这些选项的完整列表。

读取配置

bin/spark-submit还将从中读取配置选项conf/spark-defaults.conf，其中每行包含一个键和一个由空格分隔的值。例如：

spark.master            spark://5.6.7.8:7077
spark.executor.memory   4g
spark.eventLog.enabled  true
spark.serializer        org.apache.spark.serializer.KryoSerializer

分别有三个地方可以设置Spark属性值
1.在spark应用代码SparkConf中设置的值。
2.在spark-submit或spark-shell时设置的值。
3.在spark-defaults.conf文件里面设置的值。

优先级

SparkConf > spark-submit或spark-shell > spark-defaults.conf。同时存在时，优先级高的覆盖优先级低的。

Spark属性主要可以分为两种

一种与部署相关，例如“ spark.driver.memory”，“ spark.executor.instances”，SparkConf在运行时通过编程设置时，此类属性可能不会受到影响，或者行为取决于您选择的集群管理器和部署模式，因此建议您通过配置文件或spark-submit命令行选项进行设置；
另一个主要与Spark运行时控件有关，例如“ spark.task.maxFailures”，可以用任何一种方式设置这种属性。

自定义Hadoop/hive配置

如果您的Spark应用程序正在与Hadoop和/或Hive交互，则Spark的类路径中可能存在Hadoop / Hive配置文件。

多个正在运行的应用程序可能需要不同的Hadoop / Hive客户端配置。您可以复制和修改hdfs-site.xml，core-site.xml，yarn-site.xml，hive-site.xmlSpark中的类路径中为每个应用程序。在YARN上运行的Spark群集中，这些配置文件是在群集范围内设置的，因此应用程序无法安全地对其进行更改。

更好的选择是使用形式的spark hadoop属性spark.hadoop.*。它们可以被视为与可以在$SPARK_HOME/conf/spark-defaults.conf

在某些情况下，您可能希望避免对中的某些配置进行硬编码SparkConf。例如，Spark允许您简单地创建一个空的conf并设置spark / spark hadoop属性。

val conf = new SparkConf().set("spark.hadoop.abc.def","xyz")
val sc = new SparkContext(conf)

运行时修改或添加配置

./bin/spark-submit \ 
  --name "My app" \ 
  --master local[4] \  
  --conf spark.eventLog.enabled=false \ 
  --conf "spark.executor.extraJavaOptions=-XX:+PrintGCDetails -XX:+PrintGCTimeStamps" \ 
  --conf spark.hadoop.abc.def=xyz \ 
  myApp.jar

配置日志

Spark使用log4j来进行日志记录。您可以通过log4j.properties在conf目录中添加文件来配置它 。一种开始的方法是复制log4j.properties.template那里的现有文件 。

覆盖配置目录

要指定默认的“ SPARK_HOME / conf”以外的其他配置目录，可以设置SPARK_CONF_DIR。Spark将使用此目录中的配置文件（spark-defaults.conf，spark-env.sh，log4j.properties等）。

继承Hadoop集群配置

如果计划使用Spark从HDFS读取和写入，则Spark的类路径中应包含两个Hadoop配置文件：

• hdfs-site.xml，它为HDFS客户端提供默认行为。
• core-site.xml，它设置默认文件系统名称。

环境变量

可以通过环境变量配置某些Spark设置，这些环境变量是从conf/spark-env.sh安装Spark的目录（或conf/spark-env.cmdWindows）中的脚本读取的 。在独立模式和Mesos模式下，此文件可以提供计算机的特定信息，例如主机名。运行本地Spark应用程序或提交脚本时也会提供该资源。

请注意，conf/spark-env.sh默认情况下在安装Spark时不存在。但是，您可以复制conf/spark-env.sh.template以创建它。确保使副本可执行。

可以在设置以下变量spark-env.sh：

环境变量	含义
JAVA_HOME	安装Java的位置（如果不是默认设置PATH）。
PYSPARK_PYTHON	在驱动程序和工作程序中都可用于PySpark的Python二进制可执行文件（python2.7如果可用，则为默认值，否则为python）。spark.pyspark.python如果设置了属性，则优先
PYSPARK_DRIVER_PYTHON	仅在驱动程序中用于PySpark的Python二进制可执行文件（默认为PYSPARK_PYTHON）。spark.pyspark.driver.python如果设置了属性，则优先
SPARKR_DRIVER_R	用于SparkR shell的R二进制可执行文件（默认为R）。spark.r.shell.command如果设置了属性，则优先
SPARK_LOCAL_IP	绑定机器的IP地址。
SPARK_PUBLIC_DNS	您的Spark程序的主机名将播发到其他计算机。

除上述内容外，还有用于设置Spark 独立群集脚本的选项，例如，每台计算机上使用的内核数量和最大内存。

由于spark-env.sh是Shell脚本，因此其中一些可以通过编程设置-例如，您可以SPARK_LOCAL_IP通过查找特定网络接口的IP进行计算。

注意：在YARN cluster模式下运行Spark时，需要使用文件中的spark.yarn.appMasterEnv.[EnvironmentVariableName]属性设置环境变量conf/spark-defaults.conf。设置的环境变量spark-env.sh将不会以模式显示在YARN Application Master进程中cluster。有关更多信息，请参见YARN相关的Spark属性。

可用属性

属性名称	默认	含义
spark.app.name	(none)	您的应用程序的名称。这将出现在UI和日志数据中。
spark.driver.cores	1	仅在群集模式下，用于驱动程序进程的核心数。
spark.driver.maxResultSize	1g	每个Spark操作（例如收集）的所有分区的序列化结果的总大小的限制（以字节为单位）。至少应为1M，否则应为0（无限制）。如果总大小超过此限制，作业将中止。具有较高的限制可能会导致驱动程序发生内存不足错误（取决于spark.driver.memory和JVM中对象的内存开销）。设置适当的限制可以保护驱动程序免受内存不足错误的影响。
spark.driver.memory	1g	的存储器的量以用于驱动器的过程，即其中SparkContext被初始化时，在相同的格式作为具有大小单位后缀（“K”，“M”，“G”或“T”）JVM存储器串（例如512m，2g） 。 注意：在客户端模式下，不得通过SparkConf 直接在应用程序中设置此配置，因为此时驱动程序JVM已经启动。相反，请通过--driver-memory命令行选项或在默认属性文件中进行设置。
spark.driver.memoryOverhead	driverMemory * 0.10，最小为384	除非另有说明，否则在群集模式下（MiB）以群集模式为每个驱动程序分配的堆外内存量。这是内存，用于解决VM开销，内部字符串，其他本机开销等问题。随着容器大小的增加（通常为6％至10％），该内存通常会增加。YARN和Kubernetes当前支持此选项。
spark.executor.memory	1g	的存储器的量每执行过程中使用，在相同的格式作为具有大小单位后缀（“K”，“M”，“G”或“t”）（例如JVM存储器串512m，2g）。
spark.executor.pyspark.memory	Not set	除非另有说明，否则在MiB中要分配给每个执行程序中PySpark的内存量。如果设置，执行者的PySpark内存将被限制为该数量。如果未设置，Spark将不会限制Python的内存使用，并且取决于应用程序来避免超出与其他非JVM进程共享的开销内存空间。当PySpark在YARN或Kubernetes中运行时，此内存将添加到执行程序资源请求中。注意：在不支持资源限制的平台（例如Windows）上，可能不会限制Python内存的使用。
spark.executor.memoryOverhead	executorMemory * 0.10，最小为384	除非另有说明，否则每个执行器要分配的堆外内存量（以MiB为单位）。这是一种内存，用于解决VM开销，内部字符串，其他本机开销等问题。随着执行程序大小的增加（通常为6％至10％），内存通常会增加。YARN和Kubernetes当前支持此选项。
spark.extraListeners	(none)	用逗号分隔的实现的类列表SparkListener；初始化SparkContext时，将创建这些类的实例并在Spark的侦听器总线中注册。如果类具有接受SparkConf的单参数构造函数，则该构造函数将被调用；否则，将调用零参数构造函数。如果找不到有效的构造函数，则SparkContext创建将失败，并出现异常。
spark.local.dir	/ tmp	用于Spark中“临时”空间的目录，包括映射输出文件和存储在磁盘上的RDD。它应该在系统中的快速本地磁盘上。它也可以是不同磁盘上多个目录的逗号分隔列表。注意：在Spark 1.0及更高版本中，它将由集群管理器设置的SPARK_LOCAL_DIRS（独立），MESOS_SANDBOX（Mesos）或LOCAL_DIRS（YARN）环境变量覆盖。
spark.logConf	false	启动SparkContext时，将有效的SparkConf记录为INFO。
spark.master	(none)	要连接的集群管理器。请参阅允许的主URL的列表 。
spark.submit.deployMode	(none)	Spark驱动程序的部署模式，可以是“客户端”或“集群”，这意味着可以在群集中的一个节点上本地（“客户端”）或远程（“集群”）启动驱动程序。
spark.log.callerContext	(none)	在Yarn / HDFS上运行时将写入Yarn RM日志/ HDFS审核日志中的应用程序信息。它的长度取决于Hadoop配置hadoop.caller.context.max.size。它应该简洁明了，通常最多可以包含50个字符。
spark.driver.supervise	false	如果为true，则如果驱动程序以非零退出状态失败，则会自动重新启动驱动程序。仅在Spark独立模式或Mesos集群部署模式下有效。

运行环境

属性名称	默认	含义
spark.driver.extraClassPath	(none)	额外的类路径条目，以前置于驱动程序的类路径。 注意：在客户端模式下，不得通过SparkConf 直接在应用程序中设置此配置，因为此时驱动程序JVM已经启动。相反，请通过--driver-class-path命令行选项或在默认属性文件中进行设置。
spark.driver.extraJavaOptions	(none)	传递给驱动程序的一串额外的JVM选项。例如，GC设置或其他日志记录。请注意，使用此选项设置最大堆大小（-Xmx）设置是非法的。可以spark.driver.memory在群集模式下通过--driver-memory客户端模式下的命令行选项来设置最大堆大小设置。 注意：在客户端模式下，不得通过SparkConf 直接在应用程序中设置此配置，因为此时驱动程序JVM已经启动。相反，请通过--driver-java-options命令行选项或在默认属性文件中进行设置。
spark.driver.extraLibraryPath	(none)	设置启动驱动程序JVM时要使用的特殊库路径。 注意：在客户端模式下，不得通过SparkConf 直接在应用程序中设置此配置，因为此时驱动程序JVM已经启动。相反，请通过--driver-library-path命令行选项或在默认属性文件中进行设置。
spark.driver.userClassPathFirst	false	（实验性的）在驱动程序中加载类时，是否使用户添加的jar优先于Spark自己的jar。此功能可用于缓解Spark依赖项和用户依赖项之间的冲突。目前，这是一项实验功能。仅在群集模式下使用。
spark.executor.extraClassPath	(none)	额外的类路径条目，以附加到执行者的类路径。主要是为了与旧版本的Spark向后兼容。用户通常不需要设置此选项。
spark.executor.extraJavaOptions	(none)	一串额外的JVM选项传递给执行者。例如，GC设置或其他日志记录。请注意，使用此选项设置Spark属性或最大堆大小（-Xmx）设置是非法的。应该使用SparkConf对象或与spark-submit脚本一起使用的spark-defaults.conf文件设置Spark属性。可以通过spark.executor.memory设置最大堆大小设置。下列符号（如果存在）将被内插：将被应用程序ID替换，并将被执行者ID替换。例如，要在/ tmp中启用详细gc日志记录到以应用程序的执行者ID命名的文件，请传递以下值： -verbose:gc -Xloggc:/tmp/-.gc
spark.executor.extraLibraryPath	(none)	设置启动执行程序JVM时要使用的特殊库路径。
spark.executor.logs.rolling.maxRetainedFiles	(none)	设置系统将保留的最新滚动日志文件的数量。较旧的日志文件将被删除。默认禁用。
spark.executor.logs.rolling.enableCompression	fasle	启用执行程序日志压缩。如果启用，则滚动的执行程序日志将被压缩。默认禁用。
spark.executor.logs.rolling.maxSize	(none)	设置文件的最大大小（以字节为单位），执行程序日志将通过该大小翻转。默认情况下禁用滚动。请参阅spark.executor.logs.rolling.maxRetainedFiles 以自动清除旧日志。
spark.executor.logs.rolling.strategy	(none)	设置滚动执行程序日志的策略。默认情况下，它是禁用的。可以将其设置为“时间”（基于时间的滚动）或“尺寸”（基于尺寸的滚动）。对于“时间”，用于spark.executor.logs.rolling.time.interval设置滚动间隔。对于“大小”，用于spark.executor.logs.rolling.maxSize设置滚动的最大文件大小。
spark.executor.logs.rolling.time.interval	daily	设置执行程序日志将被翻转的时间间隔。默认情况下禁用滚动。有效值是daily，hourly，minutely或在几秒钟内的任何时间间隔。请参阅spark.executor.logs.rolling.maxRetainedFiles 以自动清除旧日志。
spark.executor.userClassPathFirst	false	（实验性）与的功能相同spark.driver.userClassPathFirst，但适用于执行程序实例。
spark.executorEnv.[EnvironmentVariableName]	(none)	将指定的环境变量添加EnvironmentVariableName到执行程序进程。用户可以指定多个以设置多个环境变量。
spark.redaction.regex	(?i)secret|password	正则表达式决定驱动程序和执行程序环境中的哪些Spark配置属性和环境变量包含敏感信息。当此正则表达式与属性键或值匹配时，将从环境UI和各种日志（如YARN和事件日志）中删除该值。
spark.python.profile	false	在Python worker中启用分析，配置文件结果将显示为sc.show_profiles()，或者将在驱动程序退出之前显示。也可以通过将它转储到磁盘中 sc.dump_profiles(path)。如果某些配置文件结果是手动显示的，则在退出驱动程序之前不会自动显示。默认情况下pyspark.profiler.BasicProfiler将使用，但是可以通过将探查器类作为参数传递给SparkContext构造函数来覆盖它。
spark.python.profile.dump	(none)	在驱动程序退出之前，用于转储概要文件结果的目录。结果将作为每个RDD的单独文件转储。可以通过加载它们pstats.Stats()。如果指定此选项，则配置文件结果将不会自动显示。
spark.python.worker.memory	512m	的存储器的量，以聚合期间每蟒工作进程使用，以相同的格式作为具有大小单位后缀（“K”，“M”，“G”或“t”）（例如JVM存储器串512m，2g）。如果聚合过程中使用的内存超过该数量，则会将数据溢出到磁盘中。
spark.python.worker.reuse	true	是否重复使用Python worker。如果是，它将使用固定数量的Python工作者，不需要为每个任务fork（）一个Python进程。如果存在大型广播，这将非常有用，那么对于每个任务，都不需要将广播从JVM传输到Python worker。
spark.files		以逗号分隔的文件列表，将其放置在每个执行程序的工作目录中。允许使用小球。
spark.submit.pyFiles		以逗号分隔的.zip，.egg或.py文件列表，用于Python应用程序的PYTHONPATH上。允许使用小球。
spark.jars		以逗号分隔的jar列表，​​包括在驱动程序和执行程序的类路径中。允许使用小球。
spark.jars.packages		以逗号分隔的jar的Maven坐标列表，包括在驱动程序和执行程序的类路径中。坐标应为groupId：artifactId：version。如果spark.jars.ivySettings 给出了构件，则将根据文件中的配置来解析构件，否则将在本地maven存储库中搜索构件，然后在maven Central中搜索，最后在命令行选项中给出的任何其他远程存储库中进行搜索--repositories。有关更多详细信息，请参见 高级依赖关系管理。
spark.jars.excludes		用逗号分隔的groupId：artifactId列表，在解析提供的依赖项时要排除，spark.jars.packages以避免依赖项冲突。
spark.jars.ivy		指定Ivy用户目录的路径，用于从中进行本地Ivy缓存和包文件 spark.jars.packages。这将覆盖ivy.default.ivy.user.dir 默认为〜/ .ivy2 的Ivy属性。
spark.jars.ivySettings		常春藤设置文件的路径，用于自定义使用spark.jars.packages 而不是内置默认值（例如maven central）指定的jar的分辨率。附加仓库由命令行选项指定--repositories或spark.jars.repositories也将被包括在内。对于允许Spark从防火墙后面解析伪像很有用，例如，通过内部伪像服务器（如Artifactory）。有关设置文件格式的详细信息，请参见设置文件。
spark.jars.repositories		以逗号分隔的其他远程存储库列表，以搜索用--packages或给出的Maven坐标spark.jars.packages。
spark.pyspark.driver.python		在驱动程序中用于PySpark的Python二进制可执行文件。（默认为spark.pyspark.python）
spark.pyspark.python		在驱动程序和执行程序中都可用于PySpark的Python二进制可执行文件。

内存管理

属性名称	默认	含义
spark.memory.fraction	0.6	用于执行和存储的部分（堆空间-300MB）。数值越低，溢出和缓存数据逐出的频率就越高。此配置的目的是为稀疏的，异常大的记录留出用于内部元数据，用户数据结构以及大小估计不精确的内存。建议将其保留为默认值。有关更多详细信息，包括有关增加此值时正确调整JVM垃圾回收的重要信息，请参阅 此描述。
spark.memory.storageFraction	0.5	可以逐出的存储内存量，表示为预留的区域大小的一部分spark.memory.fraction。数值越高，则可用于执行的工作内存就越少，任务可能会更频繁地溢出到磁盘上。建议将其保留为默认值。有关更多详细信息，请参见此 描述。
spark.memory.offHeap.enabled	flase	如果为true，Spark将尝试将堆外内存用于某些操作。如果启用了堆外内存使用，则spark.memory.offHeap.size必须为正。
spark.memory.offHeap.size	0	可用于堆外分配的绝对内存量（以字节为单位）。此设置对堆内存使用没有影响，因此，如果执行者的总内存消耗必须在某个硬限制内，那么请确保相应地缩小JVM堆大小。时必须将其设置为正值spark.memory.offHeap.enabled=true。
spark.memory.useLegacyMode	false	是否启用Spark 1.5及之前版本的旧版内存管理模式。传统模式将堆空间严格划分为固定大小的区域，如果未调整应用程序，则可能导致过多的溢出。除非已启用，否则不会读取以下不推荐使用的内存分数配置： spark.shuffle.memoryFraction spark.storage.memoryFraction spark.storage.unrollFraction
spark.shuffle.memoryFraction	0.2	（不建议使用）仅在spark.memory.useLegacyMode启用时才是只读的。在洗牌期间用于聚合和共组的Java堆的分数。在任何给定时间，用于随机播放的所有内存映射的总体大小都受到此限制的限制，超出此限制，内容将开始溢出到磁盘。如果经常发生泄漏，请考虑以来增加此值 spark.storage.memoryFraction。
spark.storage.memoryFraction	0.6	（不建议使用）仅在spark.memory.useLegacyMode启用时才是只读的。用于Spark的内存缓存的Java堆的分数。它不应大于JVM中对象的“旧”代，默认情况下，该对象的堆大小为0.6，但是如果您配置自己的旧代大小，则可以增加它。
spark.storage.unrollFraction	0.2	（不建议使用）仅在spark.memory.useLegacyMode启用时才是只读的。spark.storage.memoryFraction用于展开内存中的块的分数。当没有足够的可用存储空间来完全展开新块时，通过删除现有块来动态分配该块。
spark.storage.replication.proactive	false	为RDD块启用主动块复制。如果存在任何现有可用副本，则会补充由于执行程序故障而丢失的缓存RDD块副本。这将尝试使块的复制级别达到初始编号。
spark.cleaner.periodicGC.interval	30min	控制触发垃圾回收的频率。 仅当弱引用被垃圾回收时，此上下文清除器才触发清除。在具有大型驱动程序JVM的长时间运行的应用程序中，驱动程序上的内存压力很小，这可能很少发生或根本没有发生。根本不清理可能会导致执行程序过一会儿耗尽磁盘空间。
spark.cleaner.referenceTracking	true	启用或禁用上下文清理。
spark.cleaner.referenceTracking.blocking	true	控制清理线程是否应阻止清理任务（除了shuffle以外，后者由spark.cleaner.referenceTracking.blocking.shuffleSpark属性控制 ）。
spark.cleaner.referenceTracking.blocking.shuffle	false	控制清洗线程是否应在随机清洗任务上阻塞。
spark.cleaner.referenceTracking.cleanCheckpoints	false	控制如果引用超出范围，是否清理检查点文件。

动态分配

属性名称	默认	含义
spark.dynamicAllocation.enabled	false	是否使用动态资源分配，该资源分配将根据工作负载上下扩展在此应用程序中注册的执行程序的数量。有关更多详细信息，请参见此处的描述 。 这需要spark.shuffle.service.enabled设置。下面的配置也与此有关： spark.dynamicAllocation.minExecutors， spark.dynamicAllocation.maxExecutors，和 spark.dynamicAllocation.initialExecutors spark.dynamicAllocation.executorAllocationRatio
spark.dynamicAllocation.executorIdleTimeout	60s	如果启用了动态分配，并且执行器闲置了超过此持续时间，则该执行器将被删除。有关更多详细信息，请参见此 描述。
spark.dynamicAllocation.cachedExecutorIdleTimeout	infinity	如果启用了动态分配，并且已缓存数据块的执行器闲置了超过此持续时间，则该执行器将被删除。有关更多详细信息，请参见此 描述。
spark.dynamicAllocation.initialExecutors	spark.dynamicAllocation.minExecutors	如果启用了动态分配，则要运行的执行程序的初始数量。 如果`--num-executors`（或`spark.executor.instances`）被设置并且大于该值，它将被用作执行者的初始数量。
spark.dynamicAllocation.maxExecutors	infinity	如果启用了动态分配，则执行者数量的上限。
spark.dynamicAllocation.minExecutors	0	如果启用了动态分配，则执行者数量的下限。
spark.dynamicAllocation.executorAllocationRatio	1	默认情况下，动态分配将要求足够的执行者根据要处理的任务数量最大化并行性。虽然这可以最大程度地减少作业的等待时间，但是对于小型任务，此设置可能会由于执行程序分配开销而浪费大量资源，因为某些执行程序甚至可能无法执行任何工作。此设置允许设置一个比率，该比率将用于减少具有完全并行性的执行程序的数量。默认为1.0以提供最大的并行度。0.5将执行程序的目标执行程序数除以2。dynamicAllocation计算的执行程序的目标执行程序数仍可以通过spark.dynamicAllocation.minExecutors和 spark.dynamicAllocation.maxExecutors设置 覆盖。
spark.dynamicAllocation.schedulerBacklogTimeout	1s	如果启用了动态分配，并且有待解决的任务积压的时间超过了此期限，则将请求新的执行者。有关更多详细信息，请参见此 描述。
spark.dynamicAllocation.sustainedSchedulerBacklogTimeout	schedulerBacklogTimeout	与相同spark.dynamicAllocation.schedulerBacklogTimeout，但仅用于后续执行程序请求。有关更多详细信息，请参见此 描述。

执行行为

属性名称	默认	含义
spark.broadcast.blockSize	4m	TorrentBroadcastFactory除非另有说明，否则 每块的大小，以KiB 为单位。太大的值会降低广播过程中的并行度（使其变慢）；但是，如果它太小，BlockManager可能会降低性能。
spark.broadcast.checksum	true	是否启用广播校验和。如果启用，广播将包含校验和，以计算和发送更多数据为代价，可以帮助检测损坏的块。如果网络具有其他机制来保证广播期间数据不会被破坏，则可以禁用它。
spark.executor.cores	在YARN模式下为1，在独立模式和Mesos粗粒度模式下工作器上的所有可用内核。	每个执行程序上要使用的内核数。在独立模式和Mesos粗粒度模式下，有关更多详细信息，请参阅 此描述。
spark.default.parallelism	对于像reduceByKey和的分布式随机播放操作join，父RDD中的分区数量最多。对于parallelize 没有父RDD的操作，它取决于集群管理器： 本地模式：本地计算机上的内核数。 Mesos细颗粒模式：8 其他：所有执行程序节点上的内核总数或2个，以较大者为准	通过变换返回RDDS分区的默认数量一样join， reduceByKey和parallelize在不被用户设置。
spark.executor.heartbeatInterval	10s	每个执行者对驾驶员的心跳之间的间隔。心跳使驾驶员知道执行器仍在运行，并使用正在进行的任务的度量标准对其进行更新。spark.executor.heartbeatInterval应该大大小于spark.network.timeout
spark.files.fetchTimeout	60s	从驱动程序获取通过SparkContext.addFile（）添加的文件时使用的通信超时。
spark.files.useFetchCache	true	如果设置为true（默认值），则文件提取将使用由属于同一应用程序的执行程序共享的本地缓存，当在同一主机上运行许多执行程序时，这可以提高任务启动性能。如果设置为false，则将禁用这些缓存优化，并且所有执行程序都将获取其自己的文件副本。为了使用驻留在NFS文件系统上的Spark本地目录，可以禁用此优化（有关更多详细信息，请参阅 SPARK-6313）。
spark.files.overwrite	false	当目标文件存在且其内容与源文件不匹配时，是否覆盖通过SparkContext.addFile（）添加的文件。
spark.files.maxPartitionBytes	134217728（128 MB）	读取文件时打包到单个分区中的最大字节数。
spark.files.openCostInBytes	4194304（4 MB）	可以同时扫描以字节数衡量的打开文件的估计成本。将多个文件放入分区时使用。最好高估一下，然后文件较小的分区将比文件较大的分区更快。
spark.hadoop.cloneConf	false	如果设置为true，Configuration则为每个任务克隆一个新的Hadoop 对象。应该启用此选项以解决Configuration线程安全问题（有关更多详细信息，请参阅 SPARK-2546）。默认情况下禁用此功能，以避免不受这些问题影响的作业出现意外的性能下降。
spark.hadoop.validateOutputSpecs	true	如果设置为true，则验证saveAsHadoopFile和其他变体中使用的输出规范（例如，检查输出目录是否已存在）。可以禁用此选项以使由于预先存在的输出目录而导致的异常静音。我们建议用户不要禁用此功能，除非试图与以前版本的Spark兼容。只需使用Hadoop的FileSystem API即可手动删除输出目录。对于通过Spark Streaming的StreamingContext生成的作业，此设置将被忽略，因为在检查点恢复期间可能需要将数据重写到预先存在的输出目录中。
spark.storage.memoryMapThreshold	2m	从磁盘读取块时，Spark内存在其上映射的块大小（以字节为单位）。这可以防止Spark从内存映射很小的块。通常，对于接近或小于操作系统页面大小的块，内存映射具有高开销。
spark.hadoop.mapreduce.fileoutputcommitter.algorithm.version	1	文件输出提交者算法版本，有效算法版本号：1或2。根据MAPREDUCE-4815，版本2可能具有更好的性能，但是版本1在某些情况下可以更好地处理故障。

随机行为

属性名称	默认	含义
spark.reducer.maxSizeInFlight	48m	除非另外指定，否则从MiB中同时从每个reduce任务获取的映射输出的最大大小。由于每个输出都需要我们创建一个缓冲区来接收它，因此这代表每个reduce任务固定的内存开销，因此，请使其保持较小，除非您有大量的内存。
spark.reducer.maxReqsInFlight	整数最大值	此配置限制了在任意给定点获取块的远程请求的数量。当群集中的主机数量增加时，它可能导致到一个或多个节点的大量入站连接，从而导致工作负载在负载下失败。通过允许它限制获取请求的数量，可以缓解这种情况。
spark.reducer.maxBlocksInFlightPerAddress	整数最大值	此配置限制了每个缩减任务从给定主机端口获取的远程块的数量。当在单个提取中或同时从给定地址请求大量块时，这可能会使服务执行程序或节点管理器崩溃。启用外部随机播放时，这对于减少节点管理器上的负载特别有用。您可以通过将其设置为较低的值来缓解此问题。
spark.maxRemoteBlockSizeFetchToMem	最大最大值-512	当块的大小超过此阈值（以字节为单位）时，远程块将被提取到磁盘。这是为了避免占用太多内存的巨大请求。默认情况下，仅对大于2GB的块启用此功能，因为无论可用的资源如何，都无法将其直接提取到内存中。但是可以将其调低到更低的值（例如200m），以避免在较小的块上也使用过多的内存。请注意，此配置将影响混洗获取和块管理器远程块获取。对于启用了外部随机播放服务的用户，仅当外部随机播放服务比Spark 2.2更高时才能使用此功能。
spark.shuffle.compress	true	是否压缩地图输出文件。通常是个好主意。压缩将使用 spark.io.compression.codec。
spark.shuffle.file.buffer	32k	除非另有说明，否则每个随机播放文件输出流的内存缓冲区大小（以KiB为单位）。这些缓冲区减少了在创建中间混排文件时进行的磁盘查找和系统调用的数量。
spark.shuffle.io.maxRetries	3	（仅限Netty）如果将其设置为非零值，则会自动重试由于与IO相关的异常而失败的访存。这种重试逻辑有助于在长时间的GC暂停或瞬态网络连接问题时稳定大型混洗。
spark.shuffle.io.numConnectionsPerPeer	1个	（仅限Netty）主机之间的连接被重用，以减少大型群集的连接建立。对于具有许多硬盘和少量主机的群集，这可能导致并发不足以使所有磁盘饱和，因此用户可以考虑增加此值。
spark.shuffle.io.preferDirectBufs	true	（仅限Netty）堆外缓冲区用于减少随机播放和高速缓存块传输期间的垃圾收集。对于堆外内存受到严格限制的环境，用户可能希望将其关闭以强制从Netty分配所有内存。
spark.shuffle.io.retryWait	5s	（仅适用于Netty）两次重试之间等待的时间。默认情况下，重试导致的最大延迟为15秒，计算方式为maxRetries * retryWait。
spark.shuffle.io.backLog	64	随机播放服务的接受队列的长度。对于大型应用程序，可能需要增加该值，以便在服务无法在短时间内到达大量连接的情况下，不会断开传入连接。无论洗牌服务本身在哪里运行，都需要对其进行配置（可能在应用程序外部spark.shuffle.service.enabled）（请参阅下面的选项）。
spark.shuffle.service.enabled	false	启用外部随机播放服务。此服务保留执行者编写的随机播放文件，以便可以安全地删除执行者。如果spark.dynamicAllocation.enabled为“ true”，则必须启用 它。必须设置外部随机播放服务才能启用它。有关更多信息，请参阅 动态分配配置和设置文档。
spark.shuffle.service.port	7337	外部随机播放服务将在其上运行的端口。
spark.shuffle.service.index.cache.size	100m	高速缓存条目限制为指定的内存占用空间（以字节为单位）。
spark.shuffle.maxChunksBeingTransferred	Long.MAX_VALUE	随机播放服务上允许同时传输的最大块数。请注意，当达到最大数量时，新的传入连接将关闭。客户端将根据随机重试配置（请参见spark.shuffle.io.maxRetries和 spark.shuffle.io.retryWait）重试，如果达到了这些限制，则任务将失败，并导致获取失败。
spark.shuffle.sort.bypassMergeThreshold	200	（高级）在基于排序的混洗管理器中，如果没有地图端聚合并且最多有很多缩减分区，请避免合并排序数据。
spark.shuffle.spill.compress	true	是否压缩随机播放中溢出的数据。压缩将使用 spark.io.compression.codec。
spark.shuffle.accurateBlockThreshold	100 * 1024 * 1024	阈值，以字节为单位，高于该阈值时，HighlyCompressedMapStatus中的混洗块的大小将被准确记录。通过避免在提取混洗块时低估混洗块的大小，有助于防止OOM。
spark.shuffle.registration.timeout	5000	注册到外部随机播放服务的超时时间（以毫秒为单位）。
spark.shuffle.registration.maxAttempts	3	当我们无法注册到外部随机播放服务时，我们将重试maxAttempts次。

Spark用户界面

属性名称	默认	含义
spark.eventLog.logBlockUpdates.enabled	false	如果spark.eventLog.enabled为true ，是否为每个块更新记录事件。*警告*：这将大大增加事件日志的大小。
spark.eventLog.longForm.enabled	false	如果为true，请在事件日志中使用长格式的呼叫站点。否则，请使用简写形式。
spark.eventLog.compress	false	是否spark.eventLog.enabled为true ，是否压缩记录的事件。压缩将使用spark.io.compression.codec。
spark.eventLog.dir	file:///tmp/spark-events	记录Spark事件的基本目录（如果spark.eventLog.enabled为true）。在此基本目录中，Spark为每个应用程序创建一个子目录，并将特定于该应用程序的事件记录在此目录中。用户可能希望将其设置为统一位置，例如HDFS目录，以便历史记录服务器可以读取历史记录文件。
spark.eventLog.enabled	false	是否记录Spark事件，这对于在应用程序完成后重建Web UI很有用。
spark.eventLog.overwrite	false	是否覆盖任何现有文件。
spark.eventLog.buffer.kb	100k	除非另有说明，否则在写入输出流时要使用的缓冲区大小，以KiB为单位。
spark.ui.dagGraph.retainedRootRDDs	整数最大值	垃圾回收之前，Spark UI和状态API记住多少个DAG图形节点。
spark.ui.enabled	true	是否为Spark应用程序运行Web UI。
spark.ui.killEnabled	true	允许从Web UI中取消作业和阶段。
spark.ui.liveUpdate.period	100ms	多久更新一次活动实体。-1表示重播应用程序时“从不更新”，这意味着只会发生最后一次写入。对于实时应用程序，这避免了我们在快速处理传入任务事件时无需进行的一些操作。
spark.ui.liveUpdate.minFlushPeriod	1s	刷新过时的UI数据之前经过的最短时间。当传入的任务事件不经常触发时，这可以避免UI失效。
spark.ui.port	4040	应用程序仪表板的端口，其中显示内存和工作负载数据。
spark.ui.retainedJobs	1000	垃圾收集之前，Spark UI和状态API会记住多少个作业。这是目标最大值，在某些情况下可以保留较少的元素。
spark.ui.retainedStages	1000	垃圾收集之前，Spark UI和状态API会记住多少阶段。这是目标最大值，在某些情况下可以保留较少的元素。
spark.ui.retainedTasks	100000	垃圾回收之前，Spark UI和状态API会记住多少个任务。这是目标最大值，在某些情况下可以保留较少的元素。
spark.ui.reverseProxy	fasle	启用运行Spark Master作为工作人员和应用程序UI的反向代理。在此模式下，Spark主站将反向代理工作人员和应用程序用户界面以启用访问权限，而无需直接访问其主机。请谨慎使用它，因为将无法直接访问工作人员和应用程序用户界面，因此您只能通过spark master / proxy公共URL访问它们。此设置影响集群中运行的所有工作程序和应用程序UI，并且必须在所有工作程序，驱动程序和主服务器上进行设置。
spark.ui.reverseProxyUrl		这是代理运行所在的URL。该URL用于运行在Spark Master前面的代理。当运行身份验证代理（例如OAuth代理）时，这很有用。确保这是一个完整的URL，包括方案（http / https）和访问您的代理的端口。
spark.ui.showConsoleProgress	fasle	在控制台中显示进度栏。进度条显示了运行时间超过500毫秒的阶段的进度。如果多个阶段同时运行，则多个进度条将显示在同一行上。 注意：在Shell环境中，spark.ui.showConsoleProgress的默认值为true。
spark.worker.ui.retainedExecutors	1000	垃圾回收之前，Spark UI和状态API会记住多少完成的执行程序。
spark.worker.ui.retainedDrivers	1000	垃圾回收之前，Spark UI和状态API会记住多少完成的驱动程序。
spark.sql.ui.retainedExecutions	1000	垃圾回收之前，Spark UI和状态API会记住多少完成的执行。
spark.streaming.ui.retainedBatches	1000	垃圾收集之前，Spark UI和状态API会记住多少批成品。
spark.ui.retainedDeadExecutors	100	垃圾回收之前，Spark UI和状态API会记住多少个死执行器。
spark.ui.filters	(none)	以逗号分隔的过滤器类名称列表，以应用于Spark Web UI。该过滤器应该是标准的 javax servlet Filter。 过滤器参数也可以在配置中通过设置以下格式的配置条目来指定spark.<class name of filter>.param.<param name>=<value> ： spark.ui.filters=com.test.filter1 spark.com.test.filter1.param.name1=foo spark.com.test.filter1.param.name2=bar
spark.ui.requestHeaderSize	8k	除非另外指定，否则HTTP请求标头的最大允许大小（以字节为单位）。此设置也适用于Spark History Server。

压缩和序列化

属性名称	默认	含义
spark.broadcast.compress	true	发送前是否压缩广播变量。通常是个好主意。压缩将使用spark.io.compression.codec。
spark.checkpoint.compress	fasle	是否压缩RDD检查点。通常是个好主意。压缩将使用spark.io.compression.codec。
spark.io.compression.codec	lz4	用于压缩内部数据的编解码器，例如RDD分区，事件日志，广播变量和随机播放输出。默认情况下，星火提供了四个编解码器：lz4，lzf， snappy，和zstd。您还可以使用完全限定类名来指定的编解码器，例如 org.apache.spark.io.LZ4CompressionCodec， org.apache.spark.io.LZFCompressionCodec， org.apache.spark.io.SnappyCompressionCodec，和org.apache.spark.io.ZStdCompressionCodec。
spark.io.compression.lz4.blockSize	32k	在使用LZ4压缩编解码器的情况下，LZ4压缩中使用的块大小（以字节为单位）。当使用LZ4时，减小此块的大小也会降低随机播放存储器的使用率。
spark.io.compression.snappy.blockSize	32k	在使用Snappy压缩编解码器的情况下，在Snappy压缩中使用的块大小（以字节为单位）。使用Snappy时，减小此块的大小也会降低随机播放存储器的使用率。
spark.io.compression.zstd.level	1个	Zstd压缩编解码器的压缩级别。增加压缩级别将导致更好的压缩，但会占用更多的CPU和内存。
spark.io.compression.zstd.bufferSize	32k	在使用Zstd压缩编解码器的情况下，Zstd压缩中使用的缓冲区大小（以字节为单位）。减小此大小将降低使用Zstd时的混洗内存使用量，但由于过多的JNI调用开销，可能会增加压缩成本。
spark.kryo.classesToRegister	(none)	如果您使用Kryo序列化，请提供用逗号分隔的自定义类名称列表，以向Kryo注册。有关更多详细信息，请参见调整指南。
spark.kryo.referenceTracking	true	使用Kryo序列化数据时是否跟踪对同一对象的引用，如果对象图具有循环，则这是必要的；如果它们包含相同对象的多个副本，则对于提高效率很有用。如果您不是这种情况，可以禁用它以提高性能。
spark.kryo.registrationRequired	false	是否要求向Kryo注册。如果设置为“ true”，则如果未注册的类被序列化，Kryo将引发异常。如果设置为false（默认值），Kryo将与每个对象一起写入未注册的类名称。编写类名称可能会导致大量的性能开销，因此启用此选项可以严格执行以下操作：用户没有从注册中省略类。
spark.kryo.registrator	(none)	如果您使用Kryo序列化，请提供一个用逗号分隔的类列表，这些类将向Kryo注册您的自定义类。如果您需要以自定义方式注册类（例如，指定自定义字段序列化程序），则此属性很有用。否则spark.kryo.classesToRegister比较简单。应该将其设置为extends类 。有关更多详细信息，请参见调整指南。 KryoRegistrator
spark.kryo.unsafe	false	是否使用不安全的Kryo串行器。使用基于不安全的IO可以大大提高速度。
spark.kryoserializer.buffer.max	64m	除非另有说明，否则Kryo序列化缓冲区的最大允许大小（以MiB为单位）。它必须大于您尝试序列化的任何对象，并且必须小于2048m。如果在Kryo中收到“超出缓冲区限制”异常，请增加此值。
spark.kryoserializer.buffer	64k	除非另有说明，否则Kryo序列化缓冲区的初始大小（以KiB为单位）。请注意，每个工作线程上每个内核将有一个缓冲区。spark.kryoserializer.buffer.max如果需要，此缓冲区将增长 。
spark.rdd.compress	false	是否压缩序列化的RDD分区（例如， StorageLevel.MEMORY_ONLY_SER在Java和Scala中或StorageLevel.MEMORY_ONLY在Python中）。可以节省大量空间，但要花一些额外的CPU时间。压缩将使用spark.io.compression.codec。
spark.serializer	org.apache.spark.serializer。 JavaSerializer	用于序列化将通过网络发送或需要以序列化形式缓存的对象的类。Java序列化的默认设置可与任何Serializable Java对象一起使用，但速度很慢，因此我们建议 在需要速度时使用 org.apache.spark.serializer.KryoSerializer和配置Kryo序列化。可以是的任何子类 。 org.apache.spark.Serializer
spark.serializer.objectStreamReset	100	使用org.apache.spark.serializer.JavaSerializer进行序列化时，序列化程序将缓存对象以防止写入冗余数据，但是这会停止垃圾回收这些对象。通过调用“重置”，您可以从序列化程序中清除该信息，并允许收集旧对象。要关闭此定期重置，请将其设置为-1。默认情况下，它将每100个对象重置序列化程序。

联网

属性名称	默认	含义
spark.rpc.message.maxSize	128	“控制平面”通信中允许的最大消息大小（以MB为单位）；通常仅适用于在执行程序和驱动程序之间发送的地图输出大小信息。如果您正在运行具有数千个map的作业，请增加此数量，并减少任务并查看有关RPC消息大小的消息。
spark.blockManager.port	（随机）	所有块管理器都可以监听的端口。这些在驱动程序和执行程序上都存在。
spark.driver.blockManager.port	(value of spark.blockManager.port)	特定于驱动程序的端口，块管理器可以侦听，以防其无法使用与执行程序相同的配置。
spark.driver.bindAddress	(value of spark.driver.host)	绑定侦听套接字的主机名或IP地址。此配置将覆盖SPARK_LOCAL_IP环境变量（请参见下文）。 它还允许将与本地地址不同的地址发布给执行者或外部系统。例如，在通过桥接网络运行容器时，这很有用。为了使其正常工作，需要从容器的主机转发驱动程序使用的不同端口（RPC，块管理器和UI）。
spark.driver.host	（本地主机名）	驱动程序的主机名或IP地址。这用于与执行者和独立的Master通信。
spark.driver.port	（随机）	供驾驶员监听的端口。这用于与执行者和独立的Master通信。
spark.rpc.io.backLog	64	RPC服务器的接受队列的长度。对于大型应用程序，可能需要增加此值，以便在短时间内到达大量连接时不会丢失传入连接。
spark.network.timeout	120s	所有网络交互的默认超时。该配置将替代使用 spark.core.connection.ack.wait.timeout， spark.storage.blockManagerSlaveTimeoutMs， spark.shuffle.io.connectionTimeout，spark.rpc.askTimeout或者 spark.rpc.lookupTimeout如果没有配置它们。
spark.port.maxRetries	16	绑定到端口之前放弃的最大重试次数。如果为端口指定了特定值（非0），则每次后续重试都会在重试之前将上一次尝试中使用的端口加1。从本质上讲，这使它可以尝试从指定的起始端口到port + maxRetries的一系列端口。
spark.rpc.numRetries	3	放弃RPC任务之前要重试的次数。RPC任务将在此次数的大多数时间运行。
spark.rpc.retry.wait	3s	重试之前RPC询问操作等待的持续时间。
spark.rpc.askTimeout	spark.network.timeout	RPC询问操作等待超时之前的持续时间。
spark.rpc.lookupTimeout	120s	RPC远程端点查找操作在超时之前要等待的持续时间。
spark.core.connection.ack.wait.timeout	spark.network.timeout	在超时并放弃之前，连接等待确认发生多长时间。为避免长时间停顿（如GC）引起的不希望的超时，可以设置较大的值。

排程

属性名称	默认	含义
spark.cores.max	(none)	当以“粗粒度”共享模式在独立部署群集或 Mesos群集上运行时，跨群集（而不是从每台计算机）请求应用程序的最大CPU内核数量。如果未设置，则默认值将 spark.deploy.defaultCores在Spark的独立群集管理器上，或者在Mesos上是无限（所有可用的内核）上。
spark.locality.wait	3s	在放弃并在不太本地的节点上启动它之前，要等待多长时间才能启动本地数据任务。相同的等待将用于逐步遍历多个位置级别（过程本地，节点本地，机架本地，然后任意）。也可以通过设置spark.locality.wait.node等自定义每个级别的等待时间。如果您的任务很长且位置不佳，则应增加此设置，但是默认设置通常效果很好。
spark.locality.wait.node	spark.locality.wait	定制位置等待节点位置。例如，您可以将其设置为0以跳过节点的位置并立即搜索机架的位置（如果您的集群具有机架信息）。
spark.locality.wait.process	spark.locality.wait	自定义位置，等待过程位置。这会影响尝试访问特定执行程序进程中的缓存数据的任务。
spark.locality.wait.rack	spark.locality.wait	定制位置，等待机架位置。
spark.scheduler.maxRegisteredResourcesWaitingTime	30s	在调度开始之前等待资源注册的最长时间。
spark.scheduler.minRegisteredResourcesRatio	KUBERNETES模式为0.8; YARN模式为0.8; 0.0（对于独立模式和Mesos粗粒度模式）	注册资源的最小比例（注册资源/总预期资源）（资源是yarn模式和Kubernetes模式的执行者，独立模式和Mesos粗粒度模式的CPU内核['spark.cores.max'值是计划开始之前要等待的Mesos粗粒度模式]）。指定为0.0到1.0之间的两倍。不管是否达到最小资源比例，在开始调度之前等待的最大时间由config控制 spark.scheduler.maxRegisteredResourcesWaitingTime。
spark.scheduler.mode	FIFO	提交到相同SparkContext的作业之间 的调度模式。可以设置为FAIR 使用公平共享，而不是一个接一个地排队。对于多用户服务很有用。
spark.scheduler.revive.interval	1s	调度程序恢复工作资源所提供的间隔长度以运行任务。
spark.scheduler.listenerbus.eventqueue.capacity	10000	Spark侦听器总线中事件队列的容量必须大于0。如果删除了侦听器事件，则考虑增加值（例如20000）。增加该值可能会导致驱动程序使用更多的内存。
spark.scheduler.blacklist.unschedulableTaskSetTimeout	120s	等待中止新任务的执行者等待超时的时间（以秒为单位），该任务是中止由于完全列入黑名单而无法计划的TaskSet的。
spark.blacklist.enabled	false	如果设置为“ true”，则阻止Spark在由于任务失败过多而被列入黑名单的执行器上调度任务。可以通过其他“ spark.blacklist”配置选项进一步控制黑名单算法。
spark.blacklist.timeout	1h	（实验性的）节点或执行程序在整个应用程序中被列入黑名单的时间，然后无条件地将其从黑名单中删除以尝试运行新任务。
spark.blacklist.task.maxTaskAttemptsPerExecutor	1	（实验性的）对于给定的任务，在将一个执行者列入该任务的黑名单之前，可以对该执行者重试多少次。
spark.blacklist.task.maxTaskAttemptsPerNode	2	（实验性的）对于给定的任务，在将整个节点列入该任务的黑名单之前，可以在一个节点上重试该节点多少次。
spark.blacklist.stage.maxFailedTasksPerExecutor	2	（实验性的）在一个执行者将某个执行者列入该阶段的黑名单之前的一个阶段中，有多少个不同的任务必须失败。
spark.blacklist.stage.maxFailedExecutorsPerNode	2	（实验）在给定阶段将整个节点标记为失败之前，给定阶段有多少个不同的执行程序被标记为黑名单。
spark.blacklist.application.maxFailedTasksPerExecutor	2	（实验）在成功的任务集中，一个执行器必须失败多少个不同的任务，然后该执行器才被列入整个应用程序的黑名单。指定为的超时后，列入黑名单的执行者将自动添加回可用资源池中 spark.blacklist.timeout。但是请注意，使用动态分配时，执行程序可能会被标记为空闲，并被集群管理器收回。
spark.blacklist.application.maxFailedExecutorsPerNode	2	（实验性的）在将节点列入整个应用程序的黑名单之前，必须为整个应用程序将几个不同的执行者列入黑名单。指定为的超时后，列入黑名单的节点将自动添加回可用资源池中 spark.blacklist.timeout。但是请注意，使用动态分配时，节点上的执行程序可能会被标记为空闲，并被集群管理器收回。
spark.blacklist.killBlacklistedExecutors	false	（实验性的）如果设置为“ true”，则当spark.blacklist.application。*控制时，在执行失败时将执行者列入黑名单或将整个应用程序列入黑名单的情况下，允许Spark自动杀死执行者。请注意，将整个节点添加到黑名单后，该节点上的所有执行程序将被杀死。
spark.blacklist.application.fetchFailure.enabled	fasle	（实验性的）如果设置为“ true”，则在发生获取失败时，Spark将立即将执行程序列入黑名单。如果启用了外部随机播放服务，则整个节点将被列入黑名单。
spark.speculation	fasle	如果设置为“ true”，则执行任务的推测执行。这意味着如果一个或多个任务在一个阶段中运行缓慢，它们将被重新启动。
spark.speculation.interval	100ms	Spark多久检查一次要推测的任务。
spark.speculation.multiplier	1.5	任务要比要考虑的中位数慢多少倍。
spark.speculation.quantile	0.75	在特定阶段启用推测之前必须完成的部分任务。
spark.task.cpus	1	为每个任务分配的核心数。
spark.task.maxFailures	4	在放弃工作之前，任何特定任务的失败次数。分布在不同任务上的故障总数不会导致作业失败。特定任务必须使此尝试次数失败。应该大于或等于1。允许的重试次数=此值-1。
spark.task.reaper.enabled	false	启用监视已终止/中断的任务。当设置为true时，执行器将监视所有被杀死的任务，直到该任务实际完成执行。有关spark.task.reaper.*如何控制此监视的确切行为的详细信息，请参见其他 配置。当设置为false（默认值）时，任务杀死将使用缺少此类监视的较旧代码路径。
spark.task.reaper.pollingInterval	10s	当为时spark.task.reaper.enabled = true，此设置控制执行者轮询被终止任务的状态的频率。如果被轮询时被杀死的任务仍在运行，则将记录警告，并且默认情况下将记录该任务的线程转储（可以通过以下spark.task.reaper.threadDump设置禁用此线程转储）。
spark.task.reaper.threadDump	true	如果为spark.task.reaper.enabled = true，则此设置控制在定期轮询被终止的任务期间是否记录任务线程转储。将此设置为false可禁用线程转储的收集。
spark.task.reaper.killTimeout	-1	当spark.task.reaper.enabled = true设置为时，此设置指定一个超时时间，如果被终止的任务没有停止运行，执行器JVM将在该超时后终止自身。缺省值-1禁用此机制并阻止执行程序自毁。此设置的目的是充当安全网，以防止失控的不可取消任务使执行程序无法使用。
spark.stage.maxConsecutiveAttempts	4	中止阶段之前允许的连续阶段尝试次数。

Spark Streaming的参数配置

属性名称	默认	含义
spark.streaming.backpressure.enabled	false	启用或禁用Spark Streaming的内部背压机制（自1.5开始）。这使Spark Streaming能够基于当前的批处理调度延迟和处理时间来控制接收速率，以便系统仅接收与系统可处理的速度一样的速度。在内部，这可以动态设置接收器的最大接收速率。此速率由值spark.streaming.receiver.maxRate及其spark.streaming.kafka.maxRatePerPartition 设置的上限限制 （请参见下文）。
spark.streaming.backpressure.initialRate	(none)	这是启用背压机制时每个接收器将接收第一批数据的初始最大接收速率。
spark.streaming.blockInterval	200ms	Spark Streaming接收器接收到的数据在存储到Spark中之前的时间间隔被分成数据块。最低建议-50毫秒。有关更多详细信息，请参见Spark Streaming编程指南中的 性能调整部分。
spark.streaming.receiver.maxRate	(none)	每个接收器接收数据的最大速率（每秒的记录数）。实际上，每个流每秒最多消耗此数量的记录。将此配置设置为0或负数将不限制速率。有关 模式的详细信息，请参见Spark Streaming编程指南中的部署指南。
spark.streaming.receiver.writeAheadLog.enable	false	为接收器启用预写日志。通过接收器接收的所有输入数据将保存到预写日志中，以便在驱动程序发生故障后将其恢复。有关 更多详细信息，请参见Spark Streaming编程指南中的部署指南。
spark.streaming.unpersist	true	强制由Spark Streaming生成并保留的RDD自动从Spark的内存中消失。Spark Streaming接收到的原始输入数据也将自动清除。将其设置为false将允许原始数据和持久的RDD在流应用程序外部访问，因为它们不会自动清除。但这是以Spark中更高的内存使用为代价的。
spark.streaming.stopGracefullyOnShutdown	false	如果为true，Spark会StreamingContext在JVM关闭时正常关闭，而不是立即关闭。
spark.streaming.kafka.maxRatePerPartition	(none)	使用新的Kafka直接流API时，将从每个Kafka分区读取数据的最大速率（每秒的记录数）。有关 更多详细信息，请参见《 Kafka集成指南》。
spark.streaming.kafka.minRatePerPartition	1	使用新的Kafka直接流API时，将从每个Kafka分区读取数据的最小速率（每秒的记录数）。
spark.streaming.kafka.maxRetries	1	驱动程序将执行的最大连续重试次数，以便在每个分区的引导线上找到最新的偏移量（默认值1表示驱动程序将最多进行2次尝试）。仅适用于新的Kafka直接流API。
spark.streaming.ui.retainedBatches	1000	垃圾收集之前，Spark Streaming UI和状态API会记住多少批次。
spark.streaming.driver.writeAheadLog.closeFileAfterWrite	false	在驱动程序上写入预写日志记录后是否关闭文件。当您要对驱动程序上的元数据W​​AL使用S3（或任何不支持刷新的文件系统）时，请将其设置为“ true”。
spark.streaming.receiver.writeAheadLog.closeFileAfterWrite	false	在接收方上写一个预写日志记录后是否关闭文件。当您要对接收器上的数据WAL使用S3（或任何不支持刷新的文件系统）时，请将其设置为“ true”。