SparkContext 初始化过程源码说明

已于 2022-07-04 14:00:25 修改
阅读量465 收藏 3
点赞数 4
分类专栏： Spark 文章标签： spark 大数据 java 数据仓库 hadoop
于 2022-07-02 11:09:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ran_hao/article/details/125570533
版权

前言

本篇主要的目的是阐述 SparkContext 初始化过程中，重要环节源码的逻辑流程的梳理。SparkContext 实例化的过程是一个比较复杂的过程，主要包括SparkEnv、spark-history、心跳检测、状态追踪、广播、资源与任务调度、底层通信等等组件的初始化。本篇文章的主要目的在于：了解 Spark 提交任务底层是怎样将 Task 任务提交至 Executor 中；了解 SparkContext 初始化过程中几个重要的环节。

Spark 任务提交大致流程

流程说明

spark任务运行流程图解

  1. 经过 SparkSubmit 的提交之后就会准备运行环境（包括：资源、SparkContext初始化等等），然后开始提交 Spark Job 任务运行；
  2. 当遇到动作算子（如：reduce、collect等等）的时候就会开始提交 Job，这一类算的底层一定会执行runJob()方法并提交到 DAGschedule中；
  3. 而后通过 DAGSchedulerEventProcessLoop（循环事务处理器）处理提交 Job，然后开始递归分段提交任务至 TaskSchedule（实际为继承的子类 TaskSchedulerImpl）；
  4. 实际上到了这一步 Task 任务已经切分好了，并且准备提交给 Executor 执行；但是怎么直接将 Task 提交给Executor运行；，这里就需要 ScheduleBackend （后端调度器）将 Task 分发给各个 Executor；
  5. ScheduleBackend （实际为继承的子类 CoarseGrainedSchedulerBackend）开始通过 launchTasks 提交 Task任务至 Executor 中；
  6. ExecutorBackend （实际为继承的子类 CoarseGrainedExecutorBackend）接收到 Task 任务时，就会提交给 Executor 开始运行；
  7. Executor 接收到 Task任务时候就会开始执行；

涉及源码说明

执行Job
org.apache.spark.rdd.RDD

// 这里是以 reduce 算子为例进行说明
def reduce(f: (T, T) => T): T = withScope {
    val cleanF = sc.clean(f)
		................. 中间省略部分代码 ....................
      
//    通过SparkContext 开始提交Job
    sc.runJob(this, reducePartition, mergeResult)
    // Get the final result out of our Option, or throw an exception if the RDD was empty
    jobResult.getOrElse(throw new UnsupportedOperationException("empty collection"))
  }

org.apache.spark.SparkContext
  
def runJob[T, U: ClassTag](
      rdd: RDD[T],
      processPartition: Iterator[T] => U,
      resultHandler: (Int, U) => Unit)
  {
    val processFunc = (context: TaskContext, iter: Iterator[T]) => processPartition(iter)
      runJob[T, U](rdd, processFunc, 0 until rdd.partitions.length, resultHandler)
  }

org.apache.spark.SparkContext
  
def runJob[T, U: ClassTag](
      rdd: RDD[T],
      func: (TaskContext, Iterator[T]) => U,
      partitions: Seq[Int],
      resultHandler: (Int, U) => Unit): Unit = {
    ................. 中间省略部分代码 ....................
      
//    将任务提交至 DAGscheduler 进行Job 任务的划分
    dagScheduler.runJob(rdd, cleanedFunc, partitions, callSite, resultHandler, localProperties.get)
    progressBar.foreach(_.finishAll())
    rdd.doCheckpoint()
  }
提交 Stage
org.apache.spark.scheduler.DAGScheduler
  
def runJob[T, U](
      rdd: RDD[T],
      func: (TaskContext, Iterator[T]) => U,
      partitions: Seq[Int],
      callSite: CallSite,
      resultHandler: (Int, U) => Unit,
      properties: Properties): Unit = {
    val start = System.nanoTime
//    提交 Job
    val waiter = submitJob(rdd, func, partitions, callSite, resultHandler, properties)
		
    ................. 中间省略部分代码 ....................
    }
  }

org.apache.spark.scheduler.DAGScheduler
  
def submitJob[T, U](
      rdd: RDD[T],
      func: (TaskContext, Iterator[T]) => U,
      partitions: Seq[Int],
      callSite: CallSite,
      resultHandler: (Int, U) => Unit,
      properties: Properties): JobWaiter[U] = {
    ................. 中间省略部分代码 ....................
      
    assert(partitions.size > 0)
    val func2 = func.asInstanceOf[(TaskContext, Iterator[_]) => _]
    val waiter = new JobWaiter(this, jobId, partitions.size, resultHandler)
//    通过循环事务处理提交 Job
    eventProcessLoop.post(JobSubmitted(
      jobId, rdd, func2, partitions.toArray, callSite, waiter,
      SerializationUtils.clone(properties)))
    waiter
  }

org.apache.spark.scheduler.DAGSchedulerEventProcessLoop
/**
   * @Author: Small_Ran
   * @Date: 2022/6/1
   * @Description: 根据 driver 发送过来的 事件类型，来决定到底做什么
   */
private def doOnReceive(event: DAGSchedulerEvent): Unit = event match {
//      Job提交事务类型  
  case JobSubmitted(jobId, rdd, func, partitions, callSite, listener, properties) =>
      dagScheduler.handleJobSubmitted(jobId, rdd, func, partitions, callSite, listener, properties)
      
		................. 中间省略部分代码 ....................
  }

org.apache.spark.scheduler.DAGScheduler
  
private[scheduler] def handleJobSubmitted(jobId: Int,
      finalRDD: RDD[_],
      func: (TaskContext, Iterator[_]) => _,
      partitions: Array[Int],
      callSite: CallSite,
      listener: JobListener,
      properties: Properties) {
		................. 中间省略部分代码 ....................
      
    val jobSubmissionTime = clock.getTimeMillis()
    jobIdToActiveJob(jobId) = job
    activeJobs += job
    finalStage.setActiveJob(job)
    val stageIds = jobIdToStageIds(jobId).toArray
    val stageInfos = stageIds.flatMap(id => stageIdToStage.get(id).map(_.latestInfo))
    listenerBus.post(
      SparkListenerJobStart(job.jobId, jobSubmissionTime, stageInfos, properties))
//    提交 Stage
      submitStage(finalStage)
  }
分配 Task 至 ExecutorBackend
org.apache.spark.scheduler.DAGScheduler
  
private def submitStage(stage: Stage) {
    val jobId = activeJobForStage(stage)
    if (jobId.isDefined) {
      logDebug("submitStage(" + stage + ")")
      if (!waitingStages(stage) && !runningStages(stage) && !failedStages(stage)) {
        val missing = getMissingParentStages(stage).sortBy(_.id)
        logDebug("missing: " + missing)
        if (missing.isEmpty) {
          logInfo("Submitting " + stage + " (" + stage.rdd + "), which has no missing parents")
//          提交
          submitMissingTasks(stage, jobId.get)
        } else {
          for (parent <- missing) {
            submitStage(parent)
          }
          waitingStages += stage
        }
      }
    } else {
      abortStage(stage, "No active job for stage " + stage.id, None)
    }
  }

org.apache.spark.scheduler.DAGScheduler
  
private def submitMissingTasks(stage: Stage, jobId: Int) {
		................. 中间省略部分代码 ....................

    if (tasks.size > 0) {
      logInfo(s"Submitting ${tasks.size} missing tasks from $stage (${stage.rdd}) (first 15 " +
        s"tasks are for partitions ${tasks.take(15).map(_.partitionId)})")
//      提交任务至 TaskScheduler  
      taskScheduler.submitTasks(new TaskSet(
        tasks.toArray, stage.id, stage.latestInfo.attemptId, jobId, properties))
      stage.latestInfo.submissionTime = Some(clock.getTimeMillis())
    } else {
				................. 中间省略部分代码 ....................
      }
      logDebug(debugString)

      submitWaitingChildStages(stage)
    }
  }

org.apache.spark.scheduler.TaskSchedulerImpl
  
override def submitTasks(taskSet: TaskSet) {
    val tasks = taskSet.tasks
    logInfo("Adding task set " + taskSet.id + " with " + tasks.length + " tasks")
      
		................. 中间省略部分代码 ....................
//    准备通过 SchedulerBackend 分配任务至 Executor  
    backend.reviveOffers()
  }

org.apache.spark.scheduler.cluster.CoarseGrainedSchedulerBackend.DriverEndpoint
  
private def makeOffers() {
      // Make sure no executor is killed while some task is launching on it
      val taskDescs = CoarseGrainedSchedulerBackend.this.synchronized {
        // Filter out executors under killing
        val activeExecutors = executorDataMap.filterKeys(executorIsAlive)
        val workOffers = activeExecutors.map { case (id, executorData) =>
          new WorkerOffer(id, executorData.executorHost, executorData.freeCores)
        }.toIndexedSeq
        scheduler.resourceOffers(workOffers)
      }
      if (!taskDescs.isEmpty) {
//        启动任务
        launchTasks(taskDescs)
      }
    }

org.apache.spark.scheduler.cluster.CoarseGrainedSchedulerBackend.DriverEndpoint
  
private def launchTasks(tasks: Seq[Seq[TaskDescription]]) {
      for (task <- tasks.flatten) {
        val serializedTask = TaskDescription.encode(task)
        if (serializedTask.limit >= maxRpcMessageSize) {
          		................. 中间省略部分代码 ....................
        }
        else {
          val executorData = executorDataMap(task.executorId)
          executorData.freeCores -= scheduler.CPUS_PER_TASK

          logDebug(s"Launching task ${task.taskId} on executor id: ${task.executorId} hostname: " +
            s"${executorData.executorHost}.")
//          将任务提交至 ExecutorBackend 
          executorData.executorEndpoint.send(LaunchTask(new SerializableBuffer(serializedTask)))
        }
      }
    }
Executor 执行任务
org.apache.spark.executor.CoarseGrainedExecutorBackend
  
override def receive: PartialFunction[Any, Unit] = {
//    反向注册成功信息
    case RegisteredExecutor =>
					................. 中间省略部分代码 ....................

    //     Executor启动信息
    case LaunchTask(data) =>
      if (executor == null) {
        exitExecutor(1, "Received LaunchTask command but executor was null")
      } else {
        val taskDesc = TaskDescription.decode(data.value)
        logInfo("Got assigned task " + taskDesc.taskId)
//        开始Executor启动执行任务
        executor.launchTask(this, taskDesc)
      }
................. 中间省略部分代码 ....................
  }

SparkContext 初始化过程

流程源码说明

创建 Spark Job 任务环境 SparkEnv

创建SparkEnv 主要的作用是初始化各个 Manager 对象，包括：SortShuffleManager（）、useLegacyMemoryManager、broadcastManager等等。

org.apache.spark.SparkContext

_env = createSparkEnv(_conf, isLocal, listenerBus)
SparkEnv.set(_env)

org.apache.spark.SparkEnv

private def create(
      conf: SparkConf,
      executorId: String,
      bindAddress: String,
      advertiseAddress: String,
      port: Int,
      isLocal: Boolean,
      numUsableCores: Int,
      ioEncryptionKey: Option[Array[Byte]],
      listenerBus: LiveListenerBus = null,
      mockOutputCommitCoordinator: Option[OutputCommitCoordinator] = None): SparkEnv = {
		
    ................. 中间省略部分代码 ....................

//    初始化 NettyRpcEnv
    val systemName = if (isDriver) driverSystemName else executorSystemName
    val rpcEnv = RpcEnv.create(systemName, bindAddress, advertiseAddress, port, conf,
      securityManager, clientMode = !isDriver)

		................. 中间省略部分代码 ....................

//    初始化serializerManager（序列化、反序列化管理器）
    val serializerManager = new SerializerManager(serializer, conf, ioEncryptionKey)

		................. 中间省略部分代码 ....................

//    初始化广播管理器
    val broadcastManager = new BroadcastManager(isDriver, conf, securityManager)

		................. 中间省略部分代码 ....................

//    初始化 serializerManager
    // Let the user specify short names for shuffle managers
    val shortShuffleMgrNames = Map(
      "sort" -> classOf[org.apache.spark.shuffle.sort.serializerManager].getName,
      "tungsten-sort" -> classOf[org.apache.spark.shuffle.sort.SortShuffleManager].getName)
    val shuffleMgrName = conf.get("spark.shuffle.manager", "sort")
    val shuffleMgrClass =
      shortShuffleMgrNames.getOrElse(shuffleMgrName.toLowerCase(Locale.ROOT), shuffleMgrName)
    val shuffleManager = instantiateClass[ShuffleManager](shuffleMgrClass)

//    初始化 UnifiedMemoryManager（统一内存管理模型）、另一种内存管理模型 StaticMemoryManager（静态内存管理模型）
//    spark.memory.useLegacyMode 设置为 false（默认），则为UnifiedMemoryManager；否则为 StaticMemoryManager
    val useLegacyMemoryManager = conf.getBoolean("spark.memory.useLegacyMode", false)
    val memoryManager: MemoryManager =
      if (useLegacyMemoryManager) {
        new StaticMemoryManager(conf, numUsableCores)
      } else {
        UnifiedMemoryManager(conf, numUsableCores)
      }

		................. 中间省略部分代码 ....................
  }
创建并初始化 SparkUI

创建 SparkUI 主要作用在于后面运行 Job 时，可以通过 Web 界面实时的查看 Job 的运行情况。

org.apache.spark.SparkContext
  
_ui =
      if (conf.getBoolean("spark.ui.enabled", true)) {
        Some(SparkUI.createLiveUI(this, _conf, listenerBus, _jobProgressListener,
          _env.securityManager, appName, startTime = startTime))
      } else {
        // For tests, do not enable the UI
        None
      }
    // Bind the UI before starting the task scheduler to communicate
    // the bound port to the cluster manager properly
    _ui.foreach(_.bind())
创建心跳接收器

创建 HeartbeatReceiver 主要用于接收心跳，需要在 createTaskScheduler 之前注册 HeartbeatReceiver ，因为 Executor 将在构造函数中检索 HeartbeatReceiver；创建一个HeartbeatReceiver 的 RpcEndpoint 注册到 RpcEnv 中，每分钟给自己发送 ExpireDeadHosts 检测 Executor 是否存在心跳；如果当前时间减去最后一次心跳时间大于1分钟，就会用 CoarseGrainedSchedulerBackend 将 Executor 杀死；Driver端心跳接收器，用于接收各个 Executor 的心跳。

org.apache.spark.SparkContext

_heartbeatReceiver = env.rpcEnv.setupEndpoint(
      HeartbeatReceiver.ENDPOINT_NAME, new HeartbeatReceiver(this))
创建 SchedulerBackend 与 TaskScheduler

创建 SchedulerBackend 与 TaskScheduler 是 SparkContext 初始化中重要的部分。其中 SchedulerBackend（通讯后台） 主要是负责 Executor 之间的通信，而 TaskScheduler （任务调度器）主要负责 Job 任务的调度。不同的 Spark 任务提交模式就会创建不一样的 SchedulerBackend 与 TaskScheduler ，这里主要说明一下 Yarn-Cluster 模式；因此 SchedulerBackend 与 TaskScheduler分别是 YarnClusterSchedulerBackend 与 YarnClusterScheduler，下面会进行缘由说明。

org.apache.spark.SparkContext

// Create and start the scheduler
val (sched, ts) = SparkContext.createTaskScheduler(this, master, deployMode)
_schedulerBackend = sched
_taskScheduler = ts

org.apache.spark.SparkContext

private def createTaskScheduler(
      sc: SparkContext,
      master: String,
      deployMode: String): (SchedulerBackend, TaskScheduler) = {
    import SparkMasterRegex._

    // When running locally, don't try to re-execute tasks on failure.
    val MAX_LOCAL_TASK_FAILURES = 1

    master match {
      case "local" =>
				................. 中间省略部分代码 ....................

      case LOCAL_N_REGEX(threads) =>
				................. 中间省略部分代码 ....................

      case LOCAL_N_FAILURES_REGEX(threads, maxFailures) =>
				................. 中间省略部分代码 ....................

      case SPARK_REGEX(sparkUrl) =>
				................. 中间省略部分代码 ....................

      case LOCAL_CLUSTER_REGEX(numSlaves, coresPerSlave, memoryPerSlave) =>
        		................. 中间省略部分代码 ....................
//    Spark 外部资源管理器，目前支持三种（KubernetesClusterManager、YarnClusterManager、MesosClusterManager）
      case masterUrl =>
//        这里返回的是 YarnClusterManager
        val cm = getClusterManager(masterUrl) match {
          case Some(clusterMgr) => clusterMgr
          case None => throw new SparkException("Could not parse Master URL: '" + master + "'")
        }
        try {
//          调用的也是 YarnClusterManager 中 createTaskScheduler 与 createSchedulerBackend 方法
          val scheduler = cm.createTaskScheduler(sc, masterUrl)
          val backend = cm.createSchedulerBackend(sc, masterUrl, scheduler)
          cm.initialize(scheduler, backend)
          (backend, scheduler)
        } catch {
          case se: SparkException => throw se
          case NonFatal(e) =>
            throw new SparkException("External scheduler cannot be instantiated", e)
        }
    }
  }

org.apache.spark.scheduler.cluster.YarnClusterManager

override def createTaskScheduler(sc: SparkContext, masterURL: String): TaskScheduler = {
    sc.deployMode match {
      case "cluster" => new YarnClusterScheduler(sc)
      case "client" => new YarnScheduler(sc)
      case _ => throw new SparkException(s"Unknown deploy mode '${sc.deployMode}' for Yarn")
    }
  }

override def createSchedulerBackend(sc: SparkContext,
      masterURL: String,
      scheduler: TaskScheduler): SchedulerBackend = {
    sc.deployMode match {
      case "cluster" =>
        new YarnClusterSchedulerBackend(scheduler.asInstanceOf[TaskSchedulerImpl], sc)
      case "client" =>
        new YarnClientSchedulerBackend(scheduler.asInstanceOf[TaskSchedulerImpl], sc)
      case  _ =>
        throw new SparkException(s"Unknown deploy mode '${sc.deployMode}' for Yarn")
    }
  }
创建与启动 DAGScheduler

创建 DAGScheduler 同样也是初始化 SparkContext 中重要的部分，DAGScheduler 的主要作用是将 Job 划分成一个或者多个 Stage 。首先 DAGScheduler 在内部会先初始化一个 DAGSchedulerEventProcessLoop （主要作用是处理各种事件） ，对于后面 Job 的提交、取消等都是由它来完成。

== > Spark 划分 Stage 详细说明

org.apache.spark.SparkContext

_dagScheduler = new DAGScheduler(this)
_heartbeatReceiver.ask[Boolean](TaskSchedulerIsSet)

org.apache.spark.scheduler.DAGScheduler

/**
   * @Author: Small_Ran
   * @Date: 2022/6/1
   * @Description: 初始化事件处理器 DAGSchedulerEventProcessLoop
   *  主要事件包括：JobSubmitted JobCancelled
   */
  private[scheduler] val eventProcessLoop = new DAGSchedulerEventProcessLoop(this)
  taskScheduler.setDAGScheduler(this)
  ................. 中间省略部分代码 ....................
//  启动 事件处理循环处理器 
  eventProcessLoop.start()  

org.apache.spark.util.EventLoop

/**
   * @Author: Small_Ran
   * @Date: 2022/6/1
   * @Description:
   * 1、eventThread 专门用于处理 JobSubmitted
   * 2、eventThread.run 是在 eventProcessLoop.start() 开始启动
   */
  private val eventThread = new Thread(name) {
    setDaemon(true)

    override def run(): Unit = {
      try {
        while (!stopped.get) {
//          从队列中获取提交的事件，并循环开始执行
//          SparkContext 没有初始化完成之前，不会执行 sc.runJob 提交任务的
          val event = eventQueue.take()
          try {
//            直接就会调用 org.apache.spark.scheduler.DAGSchedulerEventProcessLoop 中的 onReceive 方法
            onReceive(event)
              
					................. 中间省略部分代码 ....................
    }
  }

def start(): Unit = {
    if (stopped.get) {
      throw new IllegalStateException(name + " has already been stopped")
    }
    // Call onStart before starting the event thread to make sure it happens before onReceive
    onStart()
//    这里就会调用上面的 run 方法
    eventThread.start()
  }

org.apache.spark.scheduler.DAGSchedulerEventProcessLoop
/**
   * @Author: Small_Ran
   * @Date: 2022/6/1
   * @Description: 根据 driver 发送过来的 事件类型，来决定到底做什么
   */
private def doOnReceive(event: DAGSchedulerEvent): Unit = event match {
//      Job提交事务类型  
  case JobSubmitted(jobId, rdd, func, partitions, callSite, listener, properties) =>
      dagScheduler.handleJobSubmitted(jobId, rdd, func, partitions, callSite, listener, properties)
      
		................. 中间省略部分代码 ....................
  }
启动 TaskScheduler

启动 TaskScheduler 中最重要的步骤是创建 driverEndpoint（主要作用是与 Executor 通讯）。如何创建 driverEndpoint ，则是通过执行 CoarseGrainedSchedulerBackend 中的 start() 方法；而且我们通过上的 Spark 任务提交大致流程可以知道 CoarseGrainedSchedulerBackend 主要用于与 Executor 建立连接，并将 Task 发送至 Executor 中执行，下面就会对大概流程进行源码说明。

org.apache.spark.SparkContext
// YarnClusterScheduler -> YarnScheduler -> TaskSchedulerImpl
// 所以这里实现的是 TaskSchedulerImpl 中的 start()
_taskScheduler.start()

org.apache.spark.scheduler.TaskSchedulerImpl

override def start() {
//    这里的 backend 封装指的是 YarnClusterSchedulerBackend
//    YarnClusterSchedulerBackend -> YarnSchedulerBackend -> CoarseGrainedSchedulerBackend
//    所以这里最后面也会实现 CoarseGrainedSchedulerBackend 中 start()
      backend.start()

    if (!isLocal && conf.getBoolean("spark.speculation", false)) {
      logInfo("Starting speculative execution thread")
      speculationScheduler.scheduleWithFixedDelay(new Runnable {
        override def run(): Unit = Utils.tryOrStopSparkContext(sc) {
          checkSpeculatableTasks()
        }
      }, SPECULATION_INTERVAL_MS, SPECULATION_INTERVAL_MS, TimeUnit.MILLISECONDS)
    }
  }

org.apache.spark.scheduler.cluster.CoarseGrainedSchedulerBackend

override def start() {
    val properties = new ArrayBuffer[(String, String)]
    for ((key, value) <- scheduler.sc.conf.getAll) {
      if (key.startsWith("spark.")) {
        properties += ((key, value))
      }
    }

    // TODO (prashant) send conf instead of properties
//    这里就会 new DriverEndpoint 对象
    driverEndpoint = createDriverEndpointRef(properties)
  }

org.apache.spark.scheduler.cluster.CoarseGrainedSchedulerBackend.DriverEndpoint

/**
     * @Author: Small_Ran
     * @Date: 2022/6/9
     * @Description:
     *   1、onStart() 对象实例初始化之后自动执行
     *   2、receive() 核心业务功能处理就在这里了
     *   3、onStop() 对象实例销毁之前自动调用执行
     */
    override def onStart() {
      // Periodically revive offers to allow delay scheduling to work
      val reviveIntervalMs = conf.getTimeAsMs("spark.scheduler.revive.interval", "1s")

      reviveThread.scheduleAtFixedRate(new Runnable {
        override def run(): Unit = Utils.tryLogNonFatalError {
          Option(self).foreach(_.send(ReviveOffers))
        }
      }, 0, reviveIntervalMs, TimeUnit.MILLISECONDS)
    }

怎么知道SparkContext初始化完成？

在 SparkContext 初始化完成的时候，会调用 YarnClusterScheduler 类中的 postStartHook 方法，而该方法会通知 ApplicationMaster 已经初始化好了 SparkContext 。

Small_Ran
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一文读懂类加载机制 --- ClassLoader
墨鱼菜鸡
07-11 1859
From：https://www.cnblogs.com/sunnick/p/9609326.html 【JVM笔记】classloader加载class文件的原理和机制：https://www.jianshu.com/p/52c38cf2e3d4 JVM 架构整体架构 在进入 classloader 分析之前，先了解一下 jvm 整体架构： ...
SparkContext初始化--Java篇 Educoder
weixin_46331685的博客
05-11 1804
import org.apache.spark.api.java.JavaSparkContext; import org.apache.spark.api.java.JavaRDD; import org.apache.spark.SparkConf; import java.util.Arrays; import java.util.List; public class Edu { public static void main(String[] args) { /********** Begin /
Thread.currentThread().getContextClassLoader().loadClass(className)和Class.forName(className)的区别...
weixin_34357962的博客
12-19 612
一、正文： 　　有去看开源框架的童鞋，应该会经常看到如下代码：Thread.currentThread().getContextClassLoader().loadClass(className)，那这个和Class.forName(className)有什么区别？ 　　带着这个问题，笔者查了一些资料，现整理分享如下，如果不当之处还望斧正： 　　通常情况下，一个JVM中的所有类加载器被组织成...
SparkContext初始化的流程(源码)
CyAurora的博客
08-15 1235
【代码】SparkContext初始化的流程(源码)
Spark源码-任务提交流程之-6-sparkContext初始化
m0_37817767的博客
07-18 903
spark源码阅读、算子
基本功：你忽略的ClassLoader
布道
02-20 4542
ClassLoader 是 Java 届最为神秘的技术之一，不是管是CS还是BS应用，都是由若干个.class文件组织而成的一个完整的Java应用程序。Class Loaders（类加载器）是JVM用于运行来动态加载类的，同时它们也是JRE的一部分，由于Class Loaders的存在，JVM运行Java程序的时候不需要知道底层文件或文件系统。 目录 1.基本概念 2. 双亲委派 2.1...
SparkContext scala初始化篇
m0_56494324的博客
05-04 2877
第一关:sparkcontext初始化 import org.apache.spark.{SparkConf, SparkContext} object Test { def main(args: Array[String]): Unit = { val conf = new SparkConf().setAppName("educoder").setMaster("local") val sc=new SparkContext(conf) ...
spark源码结构，源码说明
10-16
例如，`ExamplePlugin`实现了初始化、关闭、卸载等方法，而`ExamplePreference`定义了插件的属性。 5. **其他包**： - `org.jivesoftware`：这部分源码主要与Openfire项目相关，Openfire是一个基于Spark即时通讯...
spark初始化源码阅读sparkonyarn的client和cluster区别
10-20
Spark 初始化源码阅读 Spark on YARN 的 Client 和 Cluster 区别 Spark 是一个大数据处理的开源框架，它可以在多种集群管理器上运行，如 YARN、Mesos 和 Standalone。Spark on YARN 是 Spark 在 YARN 集群管理器上...
Spark读取HbaseRDD的过程及源码解析
04-07
Spark 读取 HbaseRDD 的过程涉及多个关键步骤和组件，这些步骤主要集中在构建 RDD、配置输入格式以及初始化扫描参数。下面将详细解释这些过程。 首先，创建 `hbaseRDD` 通过调用 `sc.newAPIHadoopRDD` 函数，其中 `...
深入理解Spark+核心思想与源码分析
01-29
在源码分析部分，读者会了解到Spark如何通过`SparkContext`初始化，如何调度任务，`Executor`如何执行任务，以及`RDD`的创建、转换和行动操作的实现细节。此外，还会深入到`Shuffle`过程、错误恢复机制、存储策略...
Spark的checkpoint源码讲解
04-09
Checkpoint 的初始化源码Checkpoint 的初始化源码主要包括两部分：设置 Checkpoint 目录和调用 Checkpoint 方法。设置 Checkpoint 目录可以使用 SparkContext 的 setCheckpointDir 方法，例如：sc.setCheckpointDir...
SparkContext的初始化
chbxw
03-27 889
SparkDriver 用于提交用户的应用程序， 一、SparkConf 负责SparkContext的配置参数加载， 主要通过ConcurrentHashMap来维护各种spark.*的配置属性 class SparkConf(loadDefaults: Boolean) extends Cloneable with Logging with Serializable { import ...
Thread.currentThread().getContextClassLoader().loadClass(className)
09-28 1911
<br />编译器加载类要依靠classloader， 而classloader有3个级别，从高到低分别是BootClassLoader(名字可能不准确) , ExtClassLoader, AppClassLoader. <br />这3个加载器分别对应着编译器去寻找类文件的优先级别和不同的路径：BootClassLoader对应jre/classes路径，是编译器最优先寻找class的地方 <br />ExtClassLoader对应jre/lib/ext路径，是编译器次优先寻找class的地方 <br
SparkContext初始化
qq_39425845的博客
07-19 979
一、SparkConf概述 1. SparkContext需要传入SparkConf来进行初始化，用于维护Spark的配置属性； 2. SparkConf内部使用ConcurrentHashMap来维护所有的配置； 3. SparkConf提供的setter方法返回的是this，所有它允许使用链式来设置属性。 二、SparkContext的初始化 1. 复制SparkConf配置
关于ClassLoader.getSystemClassLoader（）和Thread.currentThread().getContextClassLoader()
yangyangrenren的专栏
11-28 674
今天碰到一个问题，我做了一个动态编译的程序，但在javaSE环境直接运行（即javaApplication状态）可以运行，但在tomcat服务器上通过请求来处理就不行，提示找不到我动态生成的类：关键语句如下 (报错时我写的是：return ClassLoader.getSystemClassLoader（）) 最后我发现写成如图这样，调用Thread.currentThread().getContextClassLoader().loadClass(name);，就不会报错了。 查询资料后解释如下： Cl
Android ClassLoader详解
weixin_34185320的博客
10-21 318
我们知道不管是插件化还是组件化，都是基于系统的ClassLoader来设计的。只不过Android平台上虚拟机运行的是Dex字节码,一种对class文件优化的产物,传统Class文件是一个Java源码文件会生成一个.class文件，而Android是把所有Class文件进行合并，优化，然后生成一个最终的class.dex,目的是把不同class文件重复的...
反射学习笔记
AAA的博客
02-08 300
一.Class（类类型）的获取1.通过Object.getClass()方法2.通过.class标识3.通过Class.forName(String name)方法4.通过context.getClassLoader().loadClass(String name)（不建议使用）3和4中的name为类名Class.forName()和getClassLoader().loadClass()的区别f...
sparkcontext初始化--scala篇
最新发布
06-06
SparkContext是Spark的主要入口点，它是一个用于创建RDD、累加器和广播变量的对象。在Scala中，我们可以通过以下方式初始化SparkContext： 1. 创建一个SparkConf对象，设置一些Spark的配置参数，例如： ``` val conf = new SparkConf() .setAppName("MyApp") .setMaster("local") ``` 2. 创建一个SparkContext对象，将SparkConf对象作为参数传入，例如： ``` val sc = new SparkContext(conf) ``` 在这个例子中，我们创建了一个名为"MyApp"的应用程序，并将它运行在本地模式下。然后，我们将SparkConf对象传递给SparkContext对象，以便初始化SparkContext。 需要注意的是，一个应用程序只能有一个SparkContext对象。如果你尝试创建多个SparkContext对象，就会出现错误。因此，在创建SparkContext对象之前，你需要确保没有其他SparkContext对象在运行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值