《深入理解Spark-核心思想与源码分析》（三）第三章SparkContext的初始化
3.1 SparkContext概述
SparkConf负责配置参数，主要通过ConcurrentHaspMap来维护各种Spark的配置属性。
class SparkConf(loadDefaults: Boolean) extends Cloneable with Logging with Serializable {
import SparkConf._
/** Create a SparkConf that loads defaults from system properties and the classpath */
def this() = this(true)
private val settings = new ConcurrentHashMap[String, String]()
@transient private lazy val reader: ConfigReader = {
val _reader = new ConfigReader(new SparkConfigProvider(settings))
_reader.bindEnv(new ConfigProvider {
override def get(key: String): Option[String] = Option(getenv(key))
})
_reader
}
....
读取“spark.”开头的配置文件。
/**
* A config provider that only reads Spark config keys.
*/
private[spark] class SparkConfigProvider(conf: JMap[String, String]) extends ConfigProvider {
override def get(key: String): Option[String] = {
if (key.startsWith("spark.")) {
Option(conf.get(key)).orElse(SparkConf.getDeprecatedConfig(key, conf))
} else {
None
}
}
}
class SparkContext(config: SparkConf) extends Logging {
// The call site where this SparkContext was constructed.
private val creationSite: CallSite = Utils.getCallSite()
// In order to prevent multiple SparkContexts from being active at the same time, mark this
// context as having started construction.
// NOTE: this must be placed at the beginning of the SparkContext constructor.
SparkContext.markPartiallyConstructed(this)
val startTime = System.currentTimeMillis()
private[spark] val stopped: AtomicBoolean = new AtomicBoolean(false)
接下来对于Sparkconfi的赋值，各项配置信息的校验。
try {
_conf = config.clone()
_conf.validateSettings()
if (!_conf.contains("spark.master")) {
throw new SparkException("A master URL must be set in your configuration")
}
if (!_conf.contains("spark.app.name")) {
throw new SparkException("An application name must be set in your configuration")
}
_driverLogger = DriverLogger(_conf)
// log out spark.app.name in the Spark driver logs
logInfo(s"Submitted application: $appName")
3.2 创建执行环境SparkEnv
创建SparkEnv，主要适用createDriverEnv的方法，主要参数有三个sparkconf、isLocal、listenerBus的参数。
Sparkconf是对Spark的复制、isLocal标识是否为单机模式、listenerBus采用监听器模式维护各类事件的处理。
private[spark] def createDriverEnv(
conf: SparkConf,
isLocal: Boolean,
listenerBus: LiveListenerBus,
numCores: Int,
mockOutputCommitCoordinator: Option[OutputCommitCoordinator] = None): SparkEnv = {
assert(conf.contains(DRIVER_HOST_ADDRESS),
s"${DRIVER_HOST_ADDRESS.key} is not set on the driver!")
assert(conf.contains("spark.driver.port"), "spark.driver.port is not set on the driver!")
val bindAddress = conf.get(DRIVER_BIND_ADDRESS)
val advertiseAddress = conf.get(DRIVER_HOST_ADDRESS)
val port = conf.get("spark.driver.port").toInt
val ioEncryptionKey = if (conf.get(IO_ENCRYPTION_ENABLED)) {
Some(CryptoStreamUtils.createKey(conf))
} else {
None
}
create(
conf,
SparkContext.DRIVER_IDENTIFIER,
bindAddress,
advertiseAddress,
Option(port),
isLocal,
numCores,
ioEncryptionKey,
listenerBus = listenerBus,
mockOutputCommitCoordinator = mockOutputCommitCoordinator
)
}
最终调用create方法创建SparkEnv。
/**
* Helper method to create a SparkEnv for a driver or an executor.
*/
private def create(
conf: SparkConf,
executorId: String,
bindAddress: String,
advertiseAddress: String,
port: Option[Int],
isLocal: Boolean,
numUsableCores: Int,
ioEncryptionKey: Option[Array[Byte]],
listenerBus: LiveListenerBus = null,
mockOutputCommitCoordinator: Option[OutputCommitCoordinator] = None): SparkEnv = {
val isDriver = executorId == SparkContext.DRIVER_IDENTIFIER
// Listener bus is only used on the driver
if (isDriver) {
assert(listenerBus != null, "Attempted to create driver SparkEnv with null listener bus!")
}
val authSecretFileConf = if (isDriver) AUTH_SECRET_FILE_DRIVER else AUTH_SECRET_FILE_EXECUTOR
//第一步创建：安全管理器SecurityManager
val securityManager = new SecurityManager(conf, ioEncryptionKey, authSecretFileConf)
if (isDriver) {
securityManager.initializeAuth()
}
ioEncryptionKey.foreach { _ =>
if (!securityManager.isEncryptionEnabled()) {
logWarning("I/O encryption enabled without RPC encryption: keys will be visible on the " +
"wire.")
}
}
val systemName = if (isDriver) driverSystemName else executorSystemName
val rpcEnv = RpcEnv.create(systemName, bindAddress, advertiseAddress, port.getOrElse(-1), conf,
securityManager, numUsableCores, !isDriver)
// Figure out which port RpcEnv actually bound to in case the original port is 0 or occupied.
if (isDriver) {
conf.set("spark.driver.port", rpcEnv.address.port.toString)
}
// Create an instance of the class with the given name, possibly initializing it with our conf
def instantiateClass[T](className: String): T = {
val cls = Utils.classForName(className)
// Look for a constructor taking a SparkConf and a boolean isDriver, then one taking just
// SparkConf, then one taking no arguments
try {
cls.getConstructor(classOf[SparkConf], java.lang.Boolean.TYPE)
.newInstance(conf, java.lang.Boolean.valueOf(isDriver))
.asInstanceOf[T]
} catch {
case _: NoSuchMethodException =>
try {
cls.getConstructor(classOf[SparkConf]).newInstance(conf).asInstanceOf[T]
} catch {
case _: NoSuchMethodException =>
cls.getConstructor().newInstance().asInstanceOf[T]
}
}
}
第二步：创建基于Akka的分布式消息系统ActorSystem
第三步：创建Map任务输出跟踪器mapOutputTracker
第四步：实例化ShuffleManager
第五步：创建shuffleMemoryManager
第六步：创建块传输服务BlockTransferService
第七步：创建BlockManagerMaster
第八步：创建块管理器BlockManager
第九步：创建广播管理器Broadcastmanager
第十步：创建缓存管理器CacheManager
第十一步：创建HTTP文件服务器HttpFileServer
第十二步：创建测量系统MetricsSystem
第十三步：创建SparkEnv
3.2.1 安全管理器SecurityManager
主要对权限、账号进行设置。
def initializeAuth(): Unit = {
import SparkMasterRegex._
if (!sparkConf.get(NETWORK_AUTH_ENABLED)) {
return
}
// TODO: this really should be abstracted somewhere else.
val master = sparkConf.get(SparkLauncher.SPARK_MASTER, "")
val storeInUgi = master match {
case "yarn" | "local" | LOCAL_N_REGEX(_) | LOCAL_N_FAILURES_REGEX(_, _) =>
true
case k8sRegex() =>
// Don't propagate the secret through the user's credentials in kubernetes. That conflicts
// with the way k8s handles propagation of delegation tokens.
false
case _ =>
require(sparkConf.contains(SPARK_AUTH_SECRET_CONF),
s"A secret key must be specified via the $SPARK_AUTH_SECRET_CONF config.")
return
}
if (sparkConf.get(AUTH_SECRET_FILE_DRIVER).isDefined !=
sparkConf.get(AUTH_SECRET_FILE_EXECUTOR).isDefined) {
throw new IllegalArgumentException(
"Invalid secret configuration: Secret files must be specified for both the driver and the" +
" executors, not only one or the other.")
}
secretKey = secretKeyFromFile().getOrElse(Utils.createSecret(sparkConf))
if (storeInUgi) {
val creds = new Credentials()
creds.addSecretKey(SECRET_LOOKUP_KEY, secretKey.getBytes(UTF_8))
UserGroupInformation.getCurrentUser().addCredentials(creds)
}
}
3.2.2 基于Akka的分布式消息系统ActorSystem
Scala 认为Java线程通过共享数据以及通过锁来维护数据的一致性是糟糕的做法。
锁容易引起争用，降低并发程序的性能，甚至引入死锁的问题。
3.2.3 map任务输出跟踪器mapOutputTracker
用于跟踪map阶段任务的输出状态，此状态便于reduce阶段任务获取地址以及中间的输出中间结果。
3.2.4 实例化ShuffleManager
ShuffleManager负责管理本地以及远程的block数据的shuffle操作。
为什么需要Shuffle操作？
Spark作为并行计算框架， 同一个作业会被划分成多个任务在多个节点上执行。
reduce的输入可能存在于多个节点上，因此需要通过洗牌将所有的reduce的输入汇总起来。
这个过程就是shuffle。
3.2.5 shuffle线程内存管理器ShuffleMemoryManager
ShuffleMemoryManager负责管理Shuffle线程占有内存的分配和释放。
3.2.6 块传输服务BlockTransferService
BlockTransferService默认为NettyBlockTransferService（可以配置属性Spark.shuffle.blockTransferService使用NioBlockTransferService）
它使用Netty提供的异步事件驱动的网络应用架构，提供Web服务以及客户端，获取远程节点上的Block的集合。
3.2.7 BlockManagerMaster介绍
BlockManagerMaster负责对Block的管理和协调，具体操作依赖于BlockManagerMasterActor。
3.2.8 创建块管理器BlockManager
BlockManager负责对Block的管理。
3.2.9 创建广播管理器BroadcastManager
BroadcastManager用于配置信息和序列化后的RDD、JOB、以及ShuffleDependency等信息在本地存储。
为了容灾，也会复制到其他节点上。创建BroadcastManager的代码实现如下：
private[spark] class BroadcastManager(
val isDriver: Boolean,
conf: SparkConf,
securityManager: SecurityManager)
BroadcastManager必须在初始化方案被调用之后才能生效。
private def initialize() {
synchronized {
if (!initialized) {
broadcastFactory = new TorrentBroadcastFactory
broadcastFactory.initialize(isDriver, conf, securityManager)
initialized = true
}
}
}
3.2.10 创建缓存管理器CacheManager
CacheManager用于缓存RDD某个分区计算后的中间结果。
3.2.11 HTTP文件服务器HttpFileServer
HttpFIleServer主要提供对jar及其他文件的http访问，访问jar包包括用户上传的jar包。
3.2.12 创建测量系统MetricsSystem
MetricsSystem是Spark的测量系统
3.2.13 创建SparkEnv
当所有的基础组件准备好后，最终使用下边的代码创建执行环境SparkEnv。
3.3 创建metadataCleaner
SparkContext为了保持对所有的持久化的RDD的追踪，使用类型为TimeStampedWeakValueHashMap的persistentRdds缓存。
metadataCleaner的功能是清除过期的持久化RDD。
MetadataCleaner的实现可以看出其实质是一个用TimerTask实现的定时器，不断调用cleanupFunc这样的参数函数。构造metadataCleaner时的函数参数是cleanup，
用于清理persistentRdds中的过期内容。
3.4 SparkUI详解
异步事件监听。
DAGScheduler是主要的产生各类SparkListenerEvent的源头，它将各类中SparkListenerEvent发送到listenerBus的事件队列中，listenerBus通过
定时器将SparkListenerEvent事件匹配到具体的SparkListener，改变SparkListener中的传统监控数据，最终有SparkUI的界面展示。
各类监听器JobProgressListener、EnvironmentListener、StorageListener、ExecutorListener集成体系。
3.5 hadoop相关配置以及Executor环境变量
3.6 创建任务调度器TaskScheduler
3.7 创建和启动DAGScheduler
DAGScheduler主要在于任务正式交给TaskSchedulerImpl交给之前做一些准备工作，包括创建Job，将DAG中的RDD划分为不同的Stage，提交Stage，等等。
3.8 TaskScheduler启动
3.9 启动测量系统MetricsSystem
3.10 创建和启动ExecutorAllocationManager
ExecutorAllocationManager用于已经分配的Executor进行管理。
3.11 ContextCleaner的创建和启动
ContextCleaner用于那些清理超出应用范围的Rdd、shuffleDependency和Broadcast对象。
3.12 Spark环境更新
3.13 创建DAGSchedulerSource和BlockManagerSource
3.14 将SparkCOntext标记为激活
3.15小结
回顾本章，Scala与Akka的基于Actor的并发编程模型给人的印象深刻。
listenerBus对于监听器的模式的经典应用看起来并不复杂，希望读者朋友能都应用到自己的产品中去。
使用Netty所提供的异步网络架构构建的Block传输服务，基于Jetty构建的内嵌Web服务（HTTP文件服务器和SparkUI）。
基于codahale提供的第三方测量仓库创建的测量系统。
Executor中的心跳实现等内容。
