精华内容
下载资源
问答
  • 1RDD的依赖关系及容错1.1RDD的依赖关系RDD的依赖关系分为两种:窄依赖(Narrow Dependencies)与宽依赖(Wide Dependencies,源码中称为ShuffleDependencies)依赖有2个作用,其一用来解决数据容错的高效性;其二用来...

    1RDD的依赖关系及容错

    1.1RDD的依赖关系

    RDD的依赖关系分为两种:窄依赖(Narrow Dependencies)与宽依赖(Wide Dependencies,源码中称为ShuffleDependencies)

    依赖有2个作用,其一用来解决数据容错的高效性;其二用来划分stage。

    窄依赖:每个父RDD的一个Partition最多被子RDD的一个Partition所使用(1:1 或n:1)。例如map、filter、union等操作都会产生窄依赖;

    子RDD分区通常对应常数个父RDD分区(O(1),与数据规模无关。

    宽依赖:一个父RDD的Partition会被多个子RDD的Partition所使用,例如groupByKey、reduceByKey、sortByKey等操作都会产生宽依赖;(1:m 或n:m)

    (子RDD分区通常对应所有的父RDD分区(O(n),与数据规模有关)

    相比于宽依赖,窄依赖对优化很有利,主要基于以下两点:

    1、宽依赖往往对应着shuffle操作,需要在运行过程中将同一个父RDD的分区传入到不同的子RDD分区中,中间可能涉及多个节点之间的数据传输;而窄依赖的每个父RDD的分区只会传入到一个子RDD分区中,通常可以在一个节点内完成转换。

    2、当RDD分区丢失时(某个节点故障),spark会对数据进行重算。

    Ø对于窄依赖,由于父RDD的一个分区只对应一个子RDD分区,这样只需要重算和子RDD分区对应的父RDD分区即可,所以这个重算对数据的利用率是100%的;

    Ø对于宽依赖,重算的父RDD分区对应多个子RDD分区,这样实际上父RDD中只有一部分的数据是被用于恢复这个丢失的子RDD分区的,另一部分对应子RDD的其它未丢失分区,这就造成了多余的计算;更一般的,宽依赖中子RDD分区通常来自多个父RDD分区,极端情况下,所有的父RDD分区都要进行重新计算。

    Ø如下图所示,b1分区丢失,则需要重新计算a1,a2和a3,这就产生了冗余计算(a1,a2,a3中对应b2的数据)。

    区分这两种依赖很有用。首先,窄依赖允许在一个集群节点上以流水线的方式(pipeline)计算所有父分区。例如,逐个元素地执行map、然后filter操作;而宽依赖则需要首先计算好所有父分区数据,然后在节点之间进行Shuffle,这与MapReduce类似。第二,窄依赖能够更有效地进行失效节点的恢复,即只需重新计算丢失RDD分区的父分区,而且不同节点之间可以并行计算;而对于一个宽依赖关系的Lineage图,单个节点失效可能导致这个RDD的所有祖先丢失部分分区,因而需要整体重新计算。

    【误解】之前一直理解错了,以为窄依赖中每个子RDD可能对应多个父RDD,当子RDD丢失时会导致多个父RDD进行重新计算,所以窄依赖不如宽依赖有优势。而实际上应该深入到分区级别去看待这个问题,而且重算的效用也不在于算的多少,而在于有多少是冗余的计算。窄依赖中需要重算的都是必须的,所以重算不冗余。

    窄依赖的函数有:map、filter、union、join(父RDD是hash-partitioned )、mapPartitions、mapValues

    宽依赖的函数有:groupByKey、join(父RDD不是hash-partitioned )、partitionBy

    1.2依赖样例

    依赖的继承关系:

    val rdd1 = sc.parallelize(1 to 10, 1)

    val rdd2 = sc.parallelize(11 to 20, 1)

    val rdd3 = rdd1.union(rdd2)

    rdd3.dependencies.size

    // 长度为2,值为rdd1、rdd2,意为rdd3依赖rdd1、rdd2

    rdd3.dependencies

    // 结果:

    rdd3.dependencies(0).rdd.collect

    // 打印rdd1的数据

    rdd3.dependencies(1).rdd.collect

    // 打印rdd2的数据

    rdd3.dependencies(3).rdd.collect

    // 数组越界,报错

    哪些RDD Actions对应shuffleDependency?下面的join(r5)好像就没有shuffleDependency

    val r1 = sc.parallelize(List("dog", "salmon", "salmon", "rat", "elephant"))

    val r2 = r1.keyBy(_.length)

    val r3 = sc.parallelize(List("dog","cat","gnu","salmon","rabbit","turkey","wolf","bear","bee"))

    val r4 = r3.keyBy(_.length)

    val r5 = r2.join(r4)

    回答:join不一定会有shuffleDependency,上面的操作中就没有。

    redueceByKey会产生shuffleDependency。

    注意上面操作中的keyBy,和我的想象不太一样。要注意一下。

    keyBy:与map操作较为类似,给每个元素增加了一个key

    以下这个例子有点意思:

    val r1 = sc.textFile("hdfs:///user/hadoop/data/block_test1.csv")

    r1

    val r2 = r1.dependencies(0).rdd

    r2.partitions.size

    r2.preferredLocations(r2.partitions(0))

    r2.preferredLocations(r2.partitions(3))

    有意思的地方在于(查找依赖、优先位置):

    1、r1的类型为MapPartitionsRDD

    2、r1依赖于r2,如果没有这个赋值语句是看不出来的。r2的类型为:HadoopRDD

    3、可以检索r2各个分区的位置,该hdfs文件系统的副本数设置为2

    1.3RDD的容错(lineage、checkpoint)

    一般来说,分布式数据集的容错性有两种方式:数据检查点和记录数据的更新(CheckPoint Data,和Logging The Updates)。

    面向大规模数据分析,数据检查点操作成本很高,需要通过数据中心的网络连接在机器之间复制庞大的数据集,而网络带宽往往比内存带宽低得多,同时还需要消耗更多的存储资源。

    因此,Spark选择记录更新的方式。但是,如果更新粒度太细太多,那么记录更新成本也不低。因此,RDD只支持粗粒度转换,即只记录单个块上执行的单个操作(记录如何从其他RDD转换而来,即lineage),然后将创建RDD的一系列变换序列(每个RDD都包含了他是如何由其他RDD变换过来的以及如何重建某一块数据的信息。因此RDD的容错机制又称“血统(Lineage)”容错)记录下来,以便恢复丢失的分区。

    Lineage本质上很类似于数据库中的重做日志(Redo Log),只不过这个重做日志粒度很大,是对全局数据做同样的重做进而恢复数据。

    Lineage容错原理:在容错机制中,如果一个节点死机了,而且运算窄依赖,则只要把丢失的父RDD分区重算即可,不依赖于其他节点。而宽依赖需要父RDD的所有分区都存在,重算就很昂贵了。可以这样理解开销的经济与否:在窄依赖中,在子RDD的分区丢失、重算父RDD分区时,父RDD相应分区的所有数据都是子RDD分区的数据,并不存在冗余计算。在宽依赖情况下,丢失一个子RDD分区重算的每个父RDD的每个分区的所有数据并不是都给丢失的子RDD分区用的,会有一部分数据相当于对应的是未丢失的子RDD分区中需要的数据,这样就会产生冗余计算开销,这也是宽依赖开销更大的原因。因此如果使用Checkpoint算子来做检查点,不仅要考虑Lineage是否足够长,也要考虑是否有宽依赖,对宽依赖加Checkpoint是最物有所值的。

    Checkpoint机制。在以下2种情况下,RDD需要加检查点:

    ØDAG中的Lineage过长,如果重算,则开销太大(如在多次迭代中)

    Ø在宽依赖上做Checkpoint获得的收益更大

    由于RDD是只读的,所以Spark的RDD计算中一致性不是主要关心的内容,内存相对容易管理,这也是设计者很有远见的地方,这样减少了框架的复杂性,提升了性能和可扩展性,为以后上层框架的丰富奠定了强有力的基础。

    在RDD计算中,通过检查点机制进行容错,传统做检查点有两种方式:通过冗余数据和日志记录更新操作。在RDD中的doCheckPoint方法相当于通过冗余数据来缓存数据,而之前介绍的血统就是通过相当粗粒度的记录更新操作来实现容错的。

    检查点(本质是通过将RDD写入Disk做检查点)是为了通过lineage做容错的辅助,Lineage过长会造成容错成本过高,这样就不如在中间阶段做检查点容错,如果之后有节点出现问题而丢失分区,从做检查点的RDD开始重做Lineage,就会减少开销。

    1.4checkpoint与cache的关系

    1、从本质上说:checkpoint是容错机制;cache是优化机制

    2、checkpoint将数据写到共享存储中(hdfs);cache通常是内存中

    3、运算时间很长或运算量太大才能得到的RDD,computing chain过长或依赖其他RDD很多的RDD,需要做checkpoint。会被重复使用的(但不能太大)RDD,做cache。

    实际上,将ShuffleMapTask 的输出结果存放到本地磁盘也算是checkpoint,只不过这个checkpoint的主要目的是去partition输出数据。

    4、RDD的checkpoint操作完成后会斩断lineage,cache操作对lineage没有影响。

    checkpoint 在Spark Streaming中特别重要,spark streaming 中对于一些有状态的操作,这在某些stateful转换中是需要的,在这种转换中,生成RDD需要依赖前面的batches,会导致依赖链随着时间而变长。为了避免这种没有尽头的变长,要定期将中间生成的RDDs保存到可靠存储来切断依赖链,必须隔一段时间进行一次checkpoint。

    cache 和checkpoint是有显著区别的,缓存把 RDD 计算出来然后放在内存中, 但是RDD的依赖链(相当于数据库中的redo日志),也不能丢掉,当某个点某个executor宕了,上面cache的RDD就会丢掉,需要通过依赖链重放计算出来,不同的是,checkpoint是把RDD保存在HDFS中,是多副本可靠存储,所以依赖链就可以丢掉了,即斩断了依赖链,是通过复制实现的高容错。

    注意:checkpoint需要把job重新从头算一遍,最好先cache一下,checkpoint就可以直接保存缓存中的RDD了,就不需要重头计算一遍了,对性能有极大的提升。

    1.5checkpoint的使用与流程

    checkpoint 的正确使用姿势

    val data = sc.textFile("/tmp/spark/1.data").cache()// 注意要cache

    sc.setCheckpointDir("/tmp/spark/checkpoint")

    data.checkpoint

    data.count

    //问题:cache和checkpoint有没有先后的问题;有了cache可以避免第二次计算,我在代码中可以看见相关的说明!!!

    使用很简单,就是设置一下 checkpoint 目录,然后再rdd上调用checkpoint方法,action的时候就对数据进行了checkpoint

    checkpoint 写流程

    RDD checkpoint 过程中会经过以下几个状态,

    [ Initialized –> marked for checkpointing –> checkpointing in progress –> checkpointed ]

    展开全文
  • Spark RDD宽依赖 窄依赖

    2019-08-15 20:48:02
    宽依赖宽依赖往往对应着shuffle操作,需要在运行过程中将同一个父RDD的分区传入到不同的子RDD分区中,中间可能涉及多个节点之间的数据传输。 窄依赖: 而窄依赖的每个父RDD的分区只会传入到一个子RDD分区中...

    宽依赖:

           宽依赖往往对应着shuffle操作,需要在运行过程中将同一个父RDD的分区传入到不同的子RDD分区中,中间可能涉及多个节点之间的数据传输。

    窄依赖:

         而窄依赖的每个父RDD的分区只会传入到一个子RDD分区中,通常可以在一个节点内完成转换,不会产生shuffle操作。

    依赖的好处:

         当RDD分区丢失时(某个节点故障),spark会对数据进行重算,不会导致数据分片丢失,也不需要整体全部计算。

    展开全文
  • 宽依赖窄依赖+stage划分

    千次阅读 2018-03-06 22:22:55
    1.RDD的依赖关系1.1 WordCount中的RDDRDD和它...1.2 窄依赖窄依赖指的是每一个父RDD的Partition最多被子RDD的一个Partition使用总结:窄依赖我们形象的比喻为独生子女1.3 宽依赖宽依赖指的是多个子RDD的Partitio...

    1.RDD的依赖关系

    1.1  WordCount中的RDD


    RDD和它依赖的父RDD(s)的关系有两种不同的类型,即窄依赖(narrow dependency)和宽依赖(wide dependency)。

    1.2  窄依赖

    窄依赖指的是每一个父RDD的Partition最多被子RDD的一个Partition使用

    总结:窄依赖我们形象的比喻为独生子女

    1.3  宽依赖

    宽依赖指的是多个子RDD的Partition会依赖同一个父RDD的Partition

    总结:窄依赖我们形象的比喻为超生


    窄依赖:可以理解为独生子女

    宽依赖:可以理解为超生

    如上图所示,一个文件被textFile后经过两次转换,每次转换后生成的新的RDD都和原分区一一对应,为窄依赖关系。

    当map算子计算失败时,可以直接去上一步的RDD中重新计算,而不需要其他的分区参与。但是如果最后的action算子在计算某个RDD时,计算失败,将会到上一层的多个分区中寻找依赖关系,比较麻烦。

    stage解决了这个问题,它根据宽依赖和窄依赖的关系进行换分,如上图将存在窄依赖关系的RDD换分成为一个stage。


    2.  DAG的生成

    2.1  什么是DAG

    DAG(Directed Acyclic Graph)叫做有向无环图,原始的RDD通过一系列的转换就就形成了DAG,根据RDD之间的依赖关系的不同将DAG划分成不同的Stage,对于窄依赖,partition的转换处理在Stage中完成计算。对于宽依赖,由于有Shuffle的存在,只能在parent RDD处理完成后,才能开始接下来的计算,因此宽依赖是划分Stage的依据

    2.2  DAG在spark中的应用

    • 在Spark应用中,整个执行流程在逻辑上会形成有向无环图(DAG)。
    • Action算子触发之后,将所有累积的算子形成一个有向无环图,然后由调度器调度该图上的任务进行运算。
    • Spark的调度方式与MapReduce有所不同。Spark根据RDD之间不同的依赖关系切分形成不同的阶段(Stage),一个阶段包含一系列函数执行流水线。
    • 图中的A、B、C、D、E、F分别代表不同的RDD,RDD内的方框代表分区。
    • 数据从HDFS输入Spark,形成RDD A和RDD C,RDD C上执行map操作,转换为RDD D,RDD B和RDD E执行join操作,转换为F,而在B和E连接转化为F的过程中又会执行Shuffle,最后RDD F通过函数saveAsSequenceFile输出并保存到HDFS中。

    2.3.  Spark的任务提交机制

     

    作业执行流程描述:

    1、客户端启动后直接运行用户程序,启动Driver相关的工作:DAGSchedulerBlockManagerMaster等。

    2、客户端的DriverMaster注册。

    3Master还会让Worker启动ExeuctorWorker创建一个ExecutorRunner线程,ExecutorRunner会启动ExecutorBackend进程。

    4ExecutorBackend启动后会向DriverSchedulerBackend注册。DriverDAGScheduler解析作业并生成相应的Stage,每个Stage包含的Task通过TaskScheduler分配给Executor执行。

    5、所有stage都完成后作业结束。


    简单理解:

    首先Driver和master通信(提交任务,申请资源,传送driverUrl地址)如 spark-submit xxx.jar --total-executor-cores 2 --executor-memory 512,该命令执行后master会根据提交的信息申请资源;

    master主要做几件事情:1拿出所有workers上的资源;2按照资源的大小进行排序;3按照排序顺序取资源;4让worker启动executor。

    最后把任务换分为stage,将stage添加到taskSet中。循环taskset,将task下发。


    展开全文
  • 宽依赖窄依赖 窄依赖(narrow dependency)和宽依赖(wide dependency, 也称 shuffle dependency). 窄依赖是指父RDD的每个分区只被子RDD的一个分区所使用,子RDD分区通常对应常数个父RDD分区(O(1),与数据...

    文章授权自: http://www.6aiq.com/article/1547041236424
    79284fc78ea1414bbcaa1bc5422a1700.png

    宽依赖与窄依赖

    窄依赖(narrow dependency)和宽依赖(wide dependency, 也称 shuffle dependency).

    1. 窄依赖是指父RDD的每个分区只被子RDD的一个分区所使用,子RDD分区通常对应常数个父RDD分区(O(1),与数据规模无关), map/filter和union

    2. 相应的,宽依赖是指父RDD的每个分区都可能被多个子RDD分区所使用,子RDD分区通常对应所有的父RDD分区(O(n),与数据规模有关), join

    宽依赖和窄依赖如下图所示:

    476685204a7644a2b6d60d2ed8e5604a.png

    相比于宽依赖,窄依赖对优化很有利 ,主要基于以下两点:

    1. 宽依赖往往对应着shuffle操作,需要在运行过程中将同一个父RDD的分区传入到不同的子RDD分区中,中间可能涉及多个节点之间的数据传输;而窄依赖的每个父RDD的分区只会传入到一个子RDD分区中,通常可以在一个节点内完成转换。

    2. 当RDD分区丢失时(某个节点故障),spark会对数据进行重算。

      1. 对于窄依赖,由于父RDD的一个分区只对应一个子RDD分区,这样只需要重算和子RDD分区对应的父RDD分区即可,所以这个重算对数据的利用率是100%的;

      2. 对于宽依赖,重算的父RDD分区对应多个子RDD分区,这样实际上父RDD 中只有一部分的数据是被用于恢复这个丢失的子RDD分区的,另一部分对应子RDD的其它未丢失分区,这就造成了多余的计算;更一般的,宽依赖中子RDD分区通常来自多个父RDD分区,极端情况下,所有的父RDD分区都要进行重新计算。

      3. 如下图所示,b1分区丢失,则需要重新计算a1,a2和a3,这就产生了冗余计算(a1,a2,a3中对应b2的数据)。

    b8b193420285452fb728b73e1da7e2db.png

    Job & Stage & Executor & Task

    • Job: A job is triggered by an action, like count() or saveAsTextFile(). 由action 触发

    • stage: 一个job会被拆分为多组Task,每组任务被称为一个Stage, Stage包含两类:

      • ShuffleMapStage in Spark

        ShuffleMapStage 是在DAG中 属于中间层的stage, 会产生map output file的write disk操作,提供给下一个stage的task使用,并且增加了网络IO,跨stage会是一种高昂的开销,很多情况下应尽量避免, 另外ShuffleMapStage可以被多个job共享!

      • ResultStage in Spark

      action操作会包含在ResultStage里,是DAG中最终的stage, 里面的task会计算最终的action结果
      53025fc4db434c39af057427657417d7.png

    d67fc206b2d64619bfb180e2cfbfbc1a.png

    bbefc3c9b64448a69ff70e00b924e927.png

    stage内只会存在窄依赖, stage间存在宽依赖,一定存在shuffle过程!

    • 在Spark中有两类task:

      • 一类是shuffleMapTask
      • 一类是resultTask
        第一类task的输出是shuffle所需数据,第二类task的输出是result,stage的划分也以此为依据,shuffle之前的所有变换是一个stage,shuffle之后的操作是另一个stage。比如
    rdd.parallize(1 to 10).foreach(println)
    

    这个操作没有shuffle,直接就输出了,那么只有它的task是resultTask,stage也只有一个;如果是

    rdd.map(x => (x, 1)).reduceByKey(_ + _).foreach(println)
    

    这个job因为有reduce,所以有一个shuffle过程,那么reduceByKey之前的是一个stage,执行shuffleMapTask,输出shuffle所需的数据,reduceByKey到最后是一个stage,直接就输出结果了。如果job中有多次shuffle,那么每个shuffle之前都是一个stage. 会根据RDD之间的依赖关系将DAG图划分为不同的阶段,对于窄依赖,由于partition依赖关系的确定性,partition的转换处理就可以在同一个线程里完成,窄依赖就被spark划分到同一个stage中,而对于宽依赖,只能等父RDD shuffle处理完成后,下一个stage才能开始接下来的计算。之所以称之为ShuffleMapTask是因为它需要将自己的计算结果通过shuffle到下一个stage中
    5e15d1f9241444b7ae2e0efd62c805c8.png

    因此spark划分stage的整体思路是:从后往前推,遇到宽依赖就断开,划分为一个stage;遇到窄依赖就将这个RDD加入该stage中。因此在图2中RDD C,RDD D,RDD E,RDDF被构建在一个stage中,RDD A被构建在一个单独的Stage中,而RDD B和RDD G又被构建在同一个stage中。

    参考链接
    [1] https://data-flair.training/blogs/spark-stage/

    展开全文
  • spark的宽依赖窄依赖

    2018-01-13 12:16:44
    1RDD的依赖关系及容错1.1RDD的依赖关系RDD的依赖关系分为两种:窄依赖(Narrow Dependencies)与宽依赖(Wide Dependencies,源码中称为ShuffleDependencies)依赖有2个作用,其一用来解决数据容错的高效性;其二用来...
  • RDD: rdd是是不可更改的,分区的,可并行执行的分布式数据集。partition是rdd的重要概念也可以说rdd是一组分区数据组成的,而不同的分区可以发送到不同的节点上并行执行,rdd的概念造是数据能够并行执行的基础。...
  • 宽依赖窄依赖深度剖析.pngRDD依赖关系与stage划分Spark中RDD的高效与DAG图有着莫大的关系,在DAG调度中需要对计算过程划分stage,而划分依据就是RDD之间的依赖关系。1. 窄依赖宽依赖针对不同的转换函数,RDD之间...
  • 1、宽依赖窄依赖说明由于RDD是粗粒度的操作数据集,每个Transformation操作都会生成一个新的RDD,所以RDD之间就会形成类似流水线的前后依赖关系;RDD和它依赖的父RDD(s)的关系有两种不同的类型,即窄依赖(narrow ...
  • 宽依赖窄依赖

    2016-05-06 18:42:25
    宽依赖窄依赖,很好用的PPT,对于spreak的宽依赖窄依赖很清楚,分享给有用的朋友。
  • Spark中RDD的高效与DAG图有着莫大的关系,在DAG调度中需要对计算过程划分stage,而划分依据就是RDD之间的依赖关系。...宽依赖与窄依赖窄依赖是指父RDD的每个分区只被子RDD的一个分区所使用,子RDD分区通常对应...
  • 宽依赖窄依赖

    2019-03-19 15:43:49
    宽依赖窄依赖 窄依赖是指父RDD的每个分区只被子RDD的一个分区所使用,子RDD分区通常对应常数个父RDD分区(O(1),与数据规模无关) 相应的,宽依赖是指父RDD的每个分区都可能被多个子RDD分区所使用,子RDD分区通常...
  • 窄依赖宽依赖

    千次阅读 2018-04-10 15:42:55
    个人GitHub地址 :https://github.com/LinMingQiang窄依赖和宽依赖窄依赖:指父RDD的每一个分区最多被一个子RDD的分区所用,表现为一个父RDD的分区对应于一个子RDD的分区,和两个父RDD的分区对应于一个子RDD 的分区...
  • Spark宽依赖窄依赖

    2020-03-26 16:48:45
    Spark宽依赖窄依赖
  • spark宽依赖以及窄依赖
  • RDD和它依赖的父RDD(s)的关系有两种不同的类型,即窄依赖(narrow dependency)和宽依赖(wide dependency)。如图所示显示了RDD之间的依赖关系???? 窄依赖:是指每个父RDD的每个Partition都只被子RDD的一个...
  • RDD 宽依赖窄依赖

    2019-08-14 18:39:02
    RDD依赖关系与stage划分 ...针对不同的转换函数,RDD之间的依赖关系分为窄依赖(narrow dependency)和宽依赖(wide dependency,也成shuffle dependency)。 1.1 窄依赖 窄依赖是指1个父RDD分区...
  • 参考文章:Spark宽依赖窄依赖深度剖析 宽依赖窄依赖深度剖析.png RDD依赖关系与stage划分 Spark中RDD的高效与DAG图有着莫大的关系,在DAG调度中需要对计算过程划分stage,而划分依据就是RDD之间的依赖关系...
  • 宽依赖窄依赖的作用: 1.窄依赖 每一个父RDD的Partition最多被子RDD的一个Partition使用 (一对一的关系) 常见算子:map flatmap filter union sample 等等 2.宽依赖: 指的是多个子RDD的Partition会依赖同一个父...
  • spark的宽依赖窄依赖 spark 划分stage取决于rdd之间的依赖,rdd之间的依赖分为宽依赖窄依赖 窄依赖是指 父rdd的一个分区指被子rdd的一个分区使用,参考下图,父rdd只会被一个子rdd使用 宽依赖父rdd的每一个...
  • 前言:前面我们讲过,RDD的转化Transformation操作是一个RDD生成另一个新的RDD的过程,那么新的RDD必然依赖原来的RDD。那么RDD的依赖分为几种,分别是什么含义呢?为什么要分类呢?作用是什么?先不说概念,看个例子...
  • Spark宽依赖窄依赖

    2020-12-01 00:30:16
    RDD之间的依赖关系分为两种,宽依赖(wide dependency/shuffle dependency)和窄依赖(narrow dependency) 1.窄依赖 窄依赖就是指父RDD的每个分区只被一个子RDD分区使用,子RDD分区通常只对应常数个父RDD分区,如下...
  • 宽依赖窄依赖 什么是依赖关系 当前的RDD和它的上级的RDD之间的一个描述. 一个应用下面有job,job下面有阶段,阶段怎么划分的,就是通过依赖关系划分的. 窄依赖 窄依赖表示每一个父RDD的Partition最多被子RDD的一个...
  • 宽依赖窄依赖区别

    2020-04-16 11:42:26
    窄依赖是指父RDD的每个分区只被子RDD的一个分区所使用。换句话说,一个父RDD的分区对应于一个子RDD的分区,或者多个父RDD的分区对应于一个子RDD的分区。所以窄依赖又可以分为两种情况: 1个子RDD的分区对应于1个父...
  • Spark中RDD是相互依赖的,依赖关系分宽依赖窄依赖
  • RDD的宽依赖窄依赖

    2019-11-30 15:09:47
    1、RDD的宽依赖窄依赖的区别 是否有shuffle操作,也叫洗牌操作 窄依赖: 一对一 或者 多对一 宽依赖: 一对多 窄依赖可以进行流水线优化,宽依赖不可以 优化:fork/join 机制 一个作业可以划分成多个阶段 ...
  • RDD算子操作会使得RDD分区之间产生不同依赖,主要有两种依赖:宽依赖窄依赖宽依赖:是指一个父RDD的各个分区被一个子RDD的各个分区多次依赖, 窄依赖:是指一个父RDD的各个分区被一个子RDD的各个分区一次依赖,...
  • 宽依赖窄依赖的区别 参考: https://blog.csdn.net/u013384984/article/details/80963455 总结一下: 窄依赖:父RDD中,每个分区内的数据,都只会被子RDD中特定的分区所消费,为窄依赖: **宽依赖:**父RDD中,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 648
精华内容 259
关键字:

宽依赖窄依赖