<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>大数据 on 飞乐</title><link>https://www.feilewu.cn/tags/%E5%A4%A7%E6%95%B0%E6%8D%AE/</link><description>Recent content in 大数据 on 飞乐</description><generator>Hugo</generator><language>zh-cn</language><lastBuildDate>Fri, 27 Sep 2024 19:10:53 +0800</lastBuildDate><atom:link href="https://www.feilewu.cn/tags/%E5%A4%A7%E6%95%B0%E6%8D%AE/index.xml" rel="self" type="application/rss+xml"/><item><title>Spark在Standalone运行架构中的运行流程</title><link>https://www.feilewu.cn/posts/halo-posts/spark%E5%9C%A8standalone%E8%BF%90%E8%A1%8C%E6%9E%B6%E6%9E%84%E4%B8%AD%E7%9A%84%E8%BF%90%E8%A1%8C%E6%B5%81%E7%A8%8B/</link><pubDate>Fri, 27 Sep 2024 19:10:53 +0800</pubDate><guid>https://www.feilewu.cn/posts/halo-posts/spark%E5%9C%A8standalone%E8%BF%90%E8%A1%8C%E6%9E%B6%E6%9E%84%E4%B8%AD%E7%9A%84%E8%BF%90%E8%A1%8C%E6%B5%81%E7%A8%8B/</guid><description>&lt;h2 id="standalone"&gt;Standalone&lt;/h2&gt;
&lt;p&gt;Standalone模式是Spark实现的资源调度框架，其主要的节点有Client节点、Master节点和Worker节点。其中Driver既可以运行在Master节点上中， 也可以运行在本地Client端。当用spark-shell交互式工具提交Spark的Job时，Driver在Master节点上运行； 当使用spark-submit工具提交Job或者在Eclips、IDEA等开发平台上使用”new SparkConf().setMaster(“spark://master:7077”)”方式运行Spark任务时， Driver是运行在本地Client端上的。&lt;/p&gt;
&lt;h3 id="具体流程"&gt;具体流程&lt;/h3&gt;
&lt;p&gt;&lt;img loading="lazy" src="https://pic.feilewu.cn/uploads/2024/09/30/13c6323e-901a-456e-9c45-f1b29f30ac6e.png"&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;我们提交一个任务，任务就叫Application&lt;/li&gt;
&lt;li&gt;初始化程序的入口SparkContext&lt;/li&gt;
&lt;li&gt;初始化DAG Scheduler&lt;/li&gt;
&lt;li&gt;初始化Task Scheduler&lt;/li&gt;
&lt;li&gt;Task Scheduler向master去进行注册并申请资源（CPU Core和Memory）&lt;/li&gt;
&lt;li&gt;Master根据SparkContext的资源申请要求和Worker心跳周期内报告的信息决定在哪个Worker上分配资源，然后在该Worker上获取资源，然后启动StandaloneExecutorBackend；顺便初始化好了一个线程池&lt;/li&gt;
&lt;li&gt;StandaloneExecutorBackend向Driver(SparkContext)注册,这样Driver就知道哪些Executor为他进行服务了。 到这个时候其实我们的初始化过程基本完成了，我们开始执行transform、ation的代码，但是代码并不会真正的运行，直到我们遇到一个action操作。先生产一个job任务，进行stage的划分。&lt;/li&gt;
&lt;li&gt;SparkContext将Applicaiton代码发送给StandaloneExecutorBackend；并且SparkContext解析Applicaiton代码，构建DAG图，并提交给DAG Scheduler分解成Stage（当碰到Action操作时，就会催生Job；每个Job中含有1个或多个Stage，Stage一般在获取外部数据和shuffle之前产生）。&lt;/li&gt;
&lt;li&gt;将Stage（或者称为TaskSet）提交给Task Scheduler。Task Scheduler负责将Task分配到相应的Worker，最后提交给StandaloneExecutorBackend执行；&lt;/li&gt;
&lt;li&gt;对task进行序列化，并根据task的分配算法，分配task&lt;/li&gt;
&lt;li&gt;对接收过来的task进行反序列化，把task封装成一个线程&lt;/li&gt;
&lt;li&gt;开始执行Task，并向SparkContext报告，直至Task完成。&lt;/li&gt;
&lt;li&gt;资源注销&lt;/li&gt;
&lt;/ul&gt;</description></item><item><title>Spark学习之Spark简述</title><link>https://www.feilewu.cn/posts/halo-posts/spark%E5%AD%A6%E4%B9%A0%E4%B9%8Bspark%E7%AE%80%E8%BF%B0/</link><pubDate>Fri, 27 Sep 2024 19:10:53 +0800</pubDate><guid>https://www.feilewu.cn/posts/halo-posts/spark%E5%AD%A6%E4%B9%A0%E4%B9%8Bspark%E7%AE%80%E8%BF%B0/</guid><description>&lt;h2 id="spark生态"&gt;Spark生态&lt;/h2&gt;
&lt;p&gt;&lt;img loading="lazy" src="https://pic.feilewu.cn/uploads/2026/10/09/fcb444ea-c498-4e99-b20b-7d5b64c6a90e.png"&gt;
Spark Core：包含Spark的基本功能；尤其是定义RDD的API、操作以及这两者上的动作。其他Spark的库都是构建在RDD和Spark Core之上的&lt;/p&gt;
&lt;p&gt;Spark SQL：提供通过Apache Hive的SQL变体Hive查询语言（HiveQL）与Spark进行交互的API。每个数据库表被当做一个RDD，Spark SQL查询被转换为Spark操作。&lt;/p&gt;
&lt;p&gt;Spark Streaming：对实时数据流进行处理和控制。Spark Streaming允许程序能够像普通RDD一样处理实时数据&lt;/p&gt;
&lt;p&gt;MLlib：一个常用机器学习算法库，算法被实现为对RDD的Spark操作。这个库包含可扩展的学习算法，比如分类、回归等需要对大量数据集进行迭代的操作。&lt;/p&gt;
&lt;p&gt;GraphX：控制图、并行图操作和计算的一组算法和工具的集合。GraphX扩展了RDD API，包含控制图、创建子图、访问路径上所有顶点的操作。&lt;/p&gt;
&lt;h2 id="spark的运行流程"&gt;Spark的运行流程&lt;/h2&gt;
&lt;p&gt;&lt;img loading="lazy" src="https://pic.feilewu.cn/uploads/2026/10/09/8b096236-1128-4ab3-a187-a3d5007b1322.png"&gt;
构建Spark Application的运行环境，启动SparkContext&lt;/p&gt;
&lt;p&gt;SparkContext向资源管理器（可以是Standalone，Mesos，Yarn）申请运行Executor资源，并启动StandaloneExecutorbackend，&lt;/p&gt;
&lt;p&gt;Executor向SparkContext申请Task&lt;/p&gt;
&lt;p&gt;SparkContext将应用程序分发给Executor&lt;/p&gt;
&lt;p&gt;SparkContext构建成DAG图，将DAG图分解成Stage、将Taskset发送给Task Scheduler，最后由Task Scheduler将Task发送给Executor运行&lt;/p&gt;
&lt;p&gt;Task在Executor上运行，运行完释放所有资源&lt;/p&gt;
&lt;h2 id="spark与hadoop"&gt;Spark与Hadoop&lt;/h2&gt;
&lt;p&gt;MapReduce采用硬盘保存临时数据，而Spark采用内存保存临时数据&lt;/p&gt;
&lt;p&gt;&lt;img loading="lazy" src="https://pic.feilewu.cn/uploads/2026/10/09/1a902c9f-e51b-4b9f-86f1-8613188fc1f6.png"&gt;&lt;/p&gt;</description></item><item><title>Spark的运行原理</title><link>https://www.feilewu.cn/posts/halo-posts/spark%E7%9A%84%E8%BF%90%E8%A1%8C%E5%8E%9F%E7%90%86/</link><pubDate>Fri, 27 Sep 2024 19:10:53 +0800</pubDate><guid>https://www.feilewu.cn/posts/halo-posts/spark%E7%9A%84%E8%BF%90%E8%A1%8C%E5%8E%9F%E7%90%86/</guid><description>&lt;h2 id="spark基本概念"&gt;Spark基本概念&lt;/h2&gt;
&lt;p&gt;RDD：是弹性分布式数据集（Resilient Distributed Dataset）的简称，是分布式内存的一个抽象概念，提供了一种高度受限的共享内存模型。
&lt;img alt="2022-03-29-20-49-45" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2022-03-29-20-49-45.png"&gt;&lt;/p&gt;
&lt;p&gt;DAGScheduler：有向无环图调度器基于DAG划分Stage并以TaskSet的形式提交Stage给TaskScheduler；负责将作业拆分成不同阶段的具有宽窄依赖关系的多批任务；最重要的任务之一就是：计算作业和任务的依赖关系，指定调度逻辑。在SparkContext初始化的过程中被实例化，一个SparkContext对应一个DAGScheduler。
&lt;img alt="2022-03-29-20-50-13" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2022-03-29-20-50-13.png"&gt;&lt;/p&gt;
&lt;p&gt;DAG：是Directed Acyclic Graph（有向无环图）的简称，反映RDD之间的依赖关系。
&lt;img alt="2022-03-29-20-48-38" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2022-03-29-20-48-38.png"&gt;
窄依赖：父RDD每一个分区最多被一个子RDD的分区所用；表现为一个父RDD的分区对应于一个子RDD的分区，或两个父RDD的分区对应于一个子RDD的分区。
&lt;img alt="2021-09-21-19-40-39" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2021-09-21-19-40-39.png"&gt;&lt;/p&gt;
&lt;p&gt;宽依赖：父RDD的每个分区都可能被多个子RDD分区所使用，子RDD分区通常对应所有的父RDD分区
&lt;img alt="2021-09-21-19-41-36" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2021-09-21-19-41-36.png"&gt;&lt;/p&gt;
&lt;p&gt;常见的宽窄依赖有：map、filter、union、mapPartitions、mapValues、join（父RDD是hash-partitioned：如果joinAPI之前被调用的RDD API是宽依赖【存在shuffle】，而且两个join的RDD的分区数量一致，join结果的RDD分区数量也一样，这个时候join API是窄依赖）。&lt;/p&gt;
&lt;p&gt;常见的宽依赖有：groupByKey、partitionBy、reduceByKey、join（父RDD不是hash-partitioned：除此之外的，RDD的join API都是宽依赖）。&lt;/p&gt;
&lt;p&gt;Driver Program：控制程序，负责为Application构建DAG图。
&lt;img alt="2022-03-29-20-50-31" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2022-03-29-20-50-31.png"&gt;&lt;/p&gt;
&lt;p&gt;Cluster Manager：集群资源管理中心，负责分配计算资源。&lt;/p&gt;
&lt;p&gt;Worker Node：工作节点，负责完成具体计算。
&lt;img alt="2022-03-29-20-50-45" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2022-03-29-20-50-45.png"&gt;&lt;/p&gt;
&lt;p&gt;Executor：是运行在工作节点（Worker Node）上的一个进程，负责运行Task，并为应用程序存储数据。
&lt;img alt="2022-03-29-20-51-01" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2022-03-29-20-51-01.png"&gt;&lt;/p&gt;
&lt;p&gt;Application：用户编写的Spark应用程序，一个Application包含多个Job。
&lt;img alt="2022-03-29-20-51-13" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2022-03-29-20-51-13.png"&gt;&lt;/p&gt;
&lt;p&gt;Job：作业，一个Job包含多个RDD及作用于相应RDD上的各种操作。
&lt;img alt="2022-03-29-20-51-26" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2022-03-29-20-51-26.png"&gt;&lt;/p&gt;
&lt;p&gt;Stage：阶段，是作业的基本调度单位，一个作业会分为多组任务，每组任务被称为“阶段”。&lt;/p&gt;
&lt;p&gt;TaskScheduler：任务调度器 将TaskSet提交给Worker（集群）运行并汇报结果；负责每个具体任务的实际物理调度。
&lt;img alt="2022-03-29-20-51-45" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2022-03-29-20-51-45.png"&gt;&lt;/p&gt;
&lt;p&gt;Task：任务，运行在Executor上的工作单元，是Executor中的一个线程。&lt;/p&gt;
&lt;p&gt;TaskSet：任务集 由一组关联的，但相互之间没有Shuffle依赖关系的任务所组成的任务集。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;1） 一个Stage创建一个TaskSet；&lt;/li&gt;
&lt;li&gt;2） 为Stage的每个RDD分区创建一个Task，多个Task分装成TaskSet。
&lt;img alt="2021-09-21-19-34-22" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2021-09-21-19-34-22.png"&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;总结：Application由多个Job组成，Job由多个Stage组成，Stage由多个Task组成。Stage是作业调度的基本单位。&lt;/p&gt;
&lt;p&gt;整体结构
&lt;img alt="2021-09-21-19-39-09" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2021-09-21-19-39-09.png"&gt;&lt;/p&gt;
&lt;h2 id="spark作业执行过程"&gt;Spark作业执行过程&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;我们使用spark-submit提交一个Spark作业之后，这个作业就会启动一个对应的Driver进程。根据你使用的部署模式（deploy-mode）不同，Driver进程可能在本地启动，也可能在集群中某个工作节点上启动。而Driver进程要做的第一件事情，就是向集群管理器（可以是Spark Standalone集群，也可以是其他的资源管理集群，美团•大众点评使用的是YARN作为资源管理集群）申请运行Spark作业需要使用的资源，这里的资源指的就是Executor进程。YARN集群管理器会根据我们为Spark作业设置的资源参数，在各个工作节点上，启动一定数量的Executor进程，每个Executor进程都占有一定数量的内存和CPU core。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;在申请到了作业执行所需的资源之后，Driver进程就会开始调度和执行我们编写的作业代码了。Driver进程会将我们编写的Spark作业代码分拆为多个stage，每个stage执行一部分代码片段，并为每个stage创建一批Task，然后将这些Task分配到各个Executor进程中执行。Task是最小的计算单元，负责执行一模一样的计算逻辑（也就是我们自己编写的某个代码片段），只是每个Task处理的数据不同而已。一个stage的所有Task都执行完毕之后，会在各个节点本地的磁盘文件中写入计算中间结果，然后Driver就会调度运行下一个stage。下一个stage的Task的输入数据就是上一个stage输出的中间结果。如此循环往复，直到将我们自己编写的代码逻辑全部执行完，并且计算完所有的数据，得到我们想要的结果为止。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Spark是根据shuffle类算子来进行stage的划分。如果我们的代码中执行了某个shuffle类算子（比如reduceByKey、join等），那么就会在该算子处，划分出一个stage界限来。可以大致理解为，shuffle算子执行之前的代码会被划分为一个stage，shuffle算子执行以及之后的代码会被划分为下一个stage。因此一个stage刚开始执行的时候，它的每个Task可能都会从上一个stage的Task所在的节点，去通过网络传输拉取需要自己处理的所有key，然后对拉取到的所有相同的key使用我们自己编写的算子函数执行聚合操作（比如reduceByKey()算子接收的函数）。这个过程就是shuffle。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;当我们在代码中执行了cache/persist等持久化操作时，根据我们选择的持久化级别的不同，每个Task计算出来的数据也会保存到Executor进程的内存或者所在节点的磁盘文件中。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;因此Executor的内存主要分为三块：第一块是让Task执行我们自己编写的代码时使用，默认是占Executor总内存的20%；第二块是让Task通过shuffle过程拉取了上一个stage的Task的输出后，进行聚合等操作时使用，默认也是占Executor总内存的20%；第三块是让RDD持久化时使用，默认占Executor总内存的60%。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Task的执行速度是跟每个Executor进程的CPU core数量有直接关系的。一个CPU core同一时间只能执行一个线程。而每个Executor进程上分配到的多个Task，都是以每个Task一条线程的方式，多线程并发运行的。如果CPU core数量比较充足，而且分配到的Task数量比较合理，那么通常来说，可以比较快速和高效地执行完这些Task线程。&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</description></item><item><title>Spark的运行模式</title><link>https://www.feilewu.cn/posts/halo-posts/spark%E7%9A%84%E8%BF%90%E8%A1%8C%E6%A8%A1%E5%BC%8F/</link><pubDate>Fri, 27 Sep 2024 19:10:53 +0800</pubDate><guid>https://www.feilewu.cn/posts/halo-posts/spark%E7%9A%84%E8%BF%90%E8%A1%8C%E6%A8%A1%E5%BC%8F/</guid><description>&lt;h2 id="standalone模式"&gt;Standalone模式&lt;/h2&gt;
&lt;h3 id="架构"&gt;架构&lt;/h3&gt;
&lt;p&gt;&lt;img alt="2021-09-21-19-47-21" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2021-09-21-19-47-21.png"&gt;&lt;/p&gt;
&lt;h3 id="standalone运行过程"&gt;Standalone运行过程&lt;/h3&gt;
&lt;p&gt;&lt;img alt="2021-09-21-19-52-16" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2021-09-21-19-52-16.png"&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;SparkContext连接到Master，向Master注册并申请资源（CPU Core and Memory）。&lt;/li&gt;
&lt;li&gt;Master根据SparkContext的资源申请要求和Worker心跳周期内报告的信息决定哪个Worker上分配资源，然后在该Worker上获取资源，然后启动Executor，Executor向SparkContext注册。&lt;/li&gt;
&lt;li&gt;SparkContext将Application代码发送到Executor。同时，SparkContext解析Application代码，构建DAG图，并提交给DAGScheduler分解成Stage，然后以Stage（或者称为TaskSet）提交给TaskScheduler，TaskScheduler负责将Task分配到相应的Worker，最后提交给Executor执行。&lt;/li&gt;
&lt;li&gt;Executor会建立Executor线程池，开始执行Task，并向SparkContext报告，直至Task完成。&lt;/li&gt;
&lt;li&gt;所有Task完成后，SparkContext向Master注销，释放资源。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id="spark-on-yarn模式"&gt;Spark on Yarn模式&lt;/h2&gt;
&lt;h3 id="yarn-cluster模式"&gt;Yarn-Cluster模式&lt;/h3&gt;
&lt;p&gt;&lt;img alt="2021-09-21-19-53-14" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2021-09-21-19-53-14.png"&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Client向Yarn中提交应用程序，包括ApplicationMaster程序、启动ApplicationMaster的命令、需要在Executor中运行的程序等。&lt;/li&gt;
&lt;li&gt;ResourceManager收到请求后，在集群中选择一个NodeManager，为该应用程序分配第一个Container，要求它在这个Container中启动应用程序的ApplicationMaster，其中ApplicationMaster进行SparkContext等的初始化。&lt;/li&gt;
&lt;li&gt;ApplicationMaster向ResourceManager注册，这样用户可以直接通过ResourceManage查看应用程序的运行状态，然后它将采用轮询的方式通过RPC协议为各个任务申请资源，并监控它们的运行状态直到运行结束。&lt;/li&gt;
&lt;li&gt;一旦ApplicationMaster申请到资源后，便与对应的NodeManager通信，要求它在获得的Container中启动Executor，启动后会向ApplicationMaster中的SparkContext注册并申请Task。&lt;/li&gt;
&lt;li&gt;ApplicationMaster中的SparkContext分配Task给Executor执行，Executor运行Task并向ApplicationMaster汇报运行的状态和进度，以让ApplicationMaster随时掌握各个任务的运行状态，从而可以在任务失败时重新启动任务。&lt;/li&gt;
&lt;li&gt;应用程序运行完成后，ApplicationMaster向ResourceManager申请注销并关闭自己。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id="spark-on-yarn-client-模式"&gt;Spark on Yarn-Client 模式&lt;/h3&gt;
&lt;p&gt;&lt;img alt="2021-09-21-19-58-37" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2021-09-21-19-58-37.png"&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Client向Yarn的ResourceManager申请启动ApplicationMaster。同时，在SparkContext初始化中将创建DAGScheduler和TaskScheduler。&lt;/li&gt;
&lt;li&gt;ResourceManager收到请求后，在集群中选择一个NodeManager，为该能够用程序分配第一个Container，要求它在这个Container中启动应用程序的ApplicationMaster。&lt;/li&gt;
&lt;li&gt;Client中的SparkContext初始化完毕后，与ApplicationMaster建立通讯，向ResourceManager注册，根据任务信息向ResourceManager申请资源。&lt;/li&gt;
&lt;li&gt;一旦ApplicationMaster申请到资源后，便与对应的NodeManager通信，要求它在获得的Container中启动Executor，启动后会向Client中的SparkContext注册并申请Task。&lt;/li&gt;
&lt;li&gt;Client中的SparkContext分配Task给Executor执行，Executor运行Task并向Driver汇报运行的状态和进度，以让Client随时掌握各个任务的运行状态，从而可以在任务失败时重新启动任务。&lt;/li&gt;
&lt;li&gt;应用程序运行完成后，Client的SparkContext向ResourceManager申请注销并关闭自己。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id="yarn-cluster与yarn-client的区别"&gt;Yarn-Cluster与Yarn-Client的区别&lt;/h3&gt;
&lt;p&gt;它们的区别就是ApplicationMaster的区别：Yarn-Cluster中ApplicationMaster不仅负责申请资源，并负责监控Task的运行状况，因此可以关掉Client；而Yarn-Client中ApplicationMaster仅负责申请资源，由Client中的Driver来监控调度Task的运行，因此不能关掉Client。&lt;/p&gt;
&lt;h3 id="spark-on-yarn与mapreduce-on-yarn的区别"&gt;Spark on Yarn与MapReduce on Yarn的区别&lt;/h3&gt;
&lt;p&gt;Spark的高性能一定程度上取决于它采用的异步并发模型（这里指server/driver端采用 的模型），这与Hadoop 2.0（包括Yarn和MapReduce）是一致的。Hadoop 2.0自己实现了类似Actor的异步并发模型，实现方式是epoll+状态机，而Spark则直接采用了开源软件Akka，该软件实现了Actor模型，性能非常高。尽管二者在server端采用了一致的并发模型，但在任务级别（特指Spark任务和MapReduce任务）上却采用了不同的并发机制：Hadoop MapReduce采用了多进程模型，而Spark采用了多线程模型。&lt;/p&gt;
&lt;p&gt;注意，这里的多进程和多线程，指的是同一个节点上多个任务的运行模式。无论是MapReduce和Spark，整体上看，都是多进程：MapReduce应用程序是由多个独立的Task进程组成的；Spark应用成的运行环境是由多个独立的Executor进程构建的临时资源池构成的。&lt;/p&gt;
&lt;p&gt;多进程模型便于细粒度控制每个任务占用的资源，但会消耗较多的启动时间，不适合运行低延迟类型的作业，这是MapReduce广为诟病的原因之一。而多线程模型则相反，该模型使得Spark很适合运行低延迟类型的作业。总之，Spark同节点上的任务以多线程的方式运行在一个JVM进程中，可带来以下好处：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;任务启动速度快，与之相反的是MapReduce Task进程的慢启动速度，通常需要1s左右；&lt;/li&gt;
&lt;li&gt;同节点上所有任务运行在一个进程中，有利于共享内存。这非常适合内存密集型任务，尤其对于那些需要加载大量词典的应用程序，可大大节省内存；&lt;/li&gt;
&lt;li&gt;同节点上所有任务可运行在一个JVM进程（Executor）中，且Executor所占资源可连续被多批任务使用，不会在运行部分任务后释放掉，这避免了每个任务重复申请资源带来的时间开销，对于任务数目非常多的应用，可大大降低运行时间。与之对比的是MapReduce中的Task：每个Task单独申请资源，用完后马上释放，不能被其他任务重用，尽管1.0支持JVM重用在一定程度上弥补了该问题，但2.0尚未支持该功能。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;尽管Spark的多线程模型带来了很多好处，但同样存在不足，主要有：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;由于节点上所有任务运行在一个进程中，因此，会出现严重的资源争用，难以细粒度控制每个任务占用资源。与之相反的是MapReduce，它允许用户单独为Map Task和Reduce Task设置不同的资源，进而细粒度控制任务占用资源量，有利于大作业的正常平稳运行。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id="mapreduce和spark运行模型"&gt;MapReduce和Spark运行模型&lt;/h2&gt;
&lt;h3 id="mapreduce多进程模型"&gt;MapReduce多进程模型&lt;/h3&gt;
&lt;p&gt;&lt;img alt="2021-09-21-20-03-00" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2021-09-21-20-03-00.png"&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;每个Task运行在一个独立的JVM进程中；&lt;/li&gt;
&lt;li&gt;可单独为不同类型的Task设置不同的资源量，目前支持内存和CPU两种资源；&lt;/li&gt;
&lt;li&gt;每个Task运行完后，释放所占用的资源，这些资源不能被其他Task复用，即使是同一个作业相同类型的Task。也就是说，每个Task都要经历“申请资源-&amp;gt;运行Task-&amp;gt;释放资源”的过程。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id="spark多线程模型"&gt;Spark多线程模型&lt;/h3&gt;
&lt;p&gt;&lt;img alt="2021-09-21-20-03-43" loading="lazy" src="https://pic.feilewu.cn/uploads/vscode-images/2021-09-21-20-03-43.png"&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;每个节点上可以运行一个或多个Executor服务（一个节点上可以有多个Container）；&lt;/li&gt;
&lt;li&gt;每个Executor配有一定数量的slot，表示该Executor中可以同时运行多少个ShuffleMap Task或者Reduce Task；&lt;/li&gt;
&lt;li&gt;每个Executor单独运行在一个JVM进程中，每个Task则是运行在Executor中的一个线程（每个线程可以通过轮询的方式运行每个Task）；&lt;/li&gt;
&lt;li&gt;同一个Executor内部的Task可共享内存，比如通过函数SparkContext.broadcast广播的文件或者数据结构只会在每个Executor中加载一次，而不会像MapReduce那样，每个Task加载一次；&lt;/li&gt;
&lt;li&gt;Executor一旦启动后，将一直运行，且它的资源可以一直被Task复用，直到Spark程序运行完成后才释放退出。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id="总结"&gt;总结&lt;/h3&gt;
&lt;p&gt;总体上看，Spark采用的是经典的scheduler/workers模式，每个Spark应用程序运行的第一步是构建一个可重用的资源池，然后在这个资源池里运行所有的ShuffleMap Task和Reduce Task（注意，尽管Spark引擎内部只用两类Task便可表示出一个复杂的应用程序，即ShuffleMap Task和Reduce Task），而MapReduce应用程序则不同，它不会构建一个可重用的资源池，而是让每个Task动态申请资源，且运行完后马上释放资源。&lt;/p&gt;</description></item></channel></rss>