Spark RDD分区数和分区器

已于 2023-05-12 19:52:06 修改
阅读量636 收藏 3
点赞数
文章标签： spark 大数据 hadoop
于 2023-05-11 20:40:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37901366/article/details/130542997
版权

一、分区数如何决定

1、数据源RDD

数据源RDD的分区数由数据源的读取器决定,比如sc.textFile产生的rdd,分区数由TextInputFormat.getInputSplits()方法决定,具体源码追踪及解析如下:
val rdd1 = sc.textFile("data/tbPerson.txt")

 ① Ctrl + B 进入textFile

textFile底层其实就是通过hadoopFile去读文件

 ② Ctrl + B 进入hadoopFile

>>可以发现里面New了一个HadoopRDD实例

  def hadoopFile[K, V](
      path: String,
      inputFormatClass: Class[_ <: InputFormat[K, V]],
      keyClass: Class[K],
      valueClass: Class[V],
      minPartitions: Int = defaultMinPartitions): RDD[(K, V)] = withScope {
    assertNotStopped()

    // This is a hack to enforce loading hdfs-site.xml.
    // See SPARK-11227 for details.
    FileSystem.getLocal(hadoopConfiguration)

    // A Hadoop configuration can be about 10 KiB, which is pretty big, so broadcast it.
    val confBroadcast = broadcast(new SerializableConfiguration(hadoopConfiguration))
    val setInputPathsFunc = (jobConf: JobConf) => FileInputFormat.setInputPaths(jobConf, path)
    new HadoopRDD(
      this,
      confBroadcast,
      Some(setInputPathsFunc),
      inputFormatClass,
      keyClass,
      valueClass,
      minPartitions).setName(path)
  }

 ③Ctrl + B 进入HadoopRDD类

重点关注里面的getPartitions 方法

override def getPartitions: Array[Partition] = {
    val jobConf = getJobConf()
    // add the credentials here as this can be called before SparkContext initialized
    SparkHadoopUtil.get.addCredentials(jobConf)
    try {
      val allInputSplits = getInputFormat(jobConf).getSplits(jobConf, minPartitions)
      val inputSplits = if (ignoreEmptySplits) {
        allInputSplits.filter(_.getLength > 0)
      } else {
        allInputSplits
      }
      if (inputSplits.length == 1 && inputSplits(0).isInstanceOf[FileSplit]) {
        val fileSplit = inputSplits(0).asInstanceOf[FileSplit]
        val path = fileSplit.getPath
        if (fileSplit.getLength > conf.get(IO_WARNING_LARGEFILETHRESHOLD)) {
          val codecFactory = new CompressionCodecFactory(jobConf)
          if (Utils.isFileSplittable(path, codecFactory)) {
            logWarning(s"Loading one large file ${path.toString} with only one partition, " +
              s"we can increase partition numbers for improving performance.")
          } else {
            logWarning(s"Loading one large unsplittable file ${path.toString} with only one " +
              s"partition, because the file is compressed by unsplittable compression codec.")
          }
        }
      }
      val array = new Array[Partition](inputSplits.size)
      for (i <- 0 until inputSplits.size) {
        array(i) = new HadoopPartition(id, i, inputSplits(i))
      }
      array
    } catch {
      case e: InvalidInputException if ignoreMissingFiles =>
        logWarning(s"${jobConf.get(FileInputFormat.INPUT_DIR)} doesn't exist and no" +
            s" partitions returned from this path.", e)
        Array.empty[Partition]
      case e: IOException if e.getMessage.startsWith("Not a file:") =>
        val path = e.getMessage.split(":").map(_.trim).apply(2)
        throw new IOException(s"Path: ${path} is a directory, which is not supported by the " +
          s"record reader when `mapreduce.input.fileinputformat.input.dir.recursive` is false.")
    }
  }

>> 拆解分析1：最终返回的是一个partition数组

 val array = new Array[Partition](inputSplits.size)
      for (i <- 0 until inputSplits.size) {
        array(i) = new HadoopPartition(id, i, inputSplits(i))
      }
      array

>> 拆解分析2：inputSplits是通过getInputFormat(jobConf).getSplits(jobConf, minPartitions)获取，所以需要进入getSplits方法。

大意就是遍历文件，按照一个blockSize大小(默认是128M)进行遍历,然后每一个blockSize文件都会作为一个split放到splits数组。

ps:   split中存放的信息：splits.add(makeSplit(path, length - bytesRemaining, bytesRemaining,
splitHosts[0], splitHosts[1]));可知包括文件路径、起始偏移量、剩余文件大小、block块地址等。

 // generate splits
    ArrayList<FileSplit> splits = new ArrayList<FileSplit>(numSplits);
    NetworkTopology clusterMap = new NetworkTopology();
    for (FileStatus file: files) {
      Path path = file.getPath();
      long length = file.getLen();
      if (length != 0) {
        FileSystem fs = path.getFileSystem(job);
        BlockLocation[] blkLocations;
        if (file instanceof LocatedFileStatus) {
          blkLocations = ((LocatedFileStatus) file).getBlockLocations();
        } else {
          blkLocations = fs.getFileBlockLocations(file, 0, length);
        }
        if (isSplitable(fs, path)) {
          long blockSize = file.getBlockSize();
          long splitSize = computeSplitSize(goalSize, minSize, blockSize);

          long bytesRemaining = length;
          while (((double) bytesRemaining)/splitSize > SPLIT_SLOP) {
            String[][] splitHosts = getSplitHostsAndCachedHosts(blkLocations,
                length-bytesRemaining, splitSize, clusterMap);
            splits.add(makeSplit(path, length-bytesRemaining, splitSize,
                splitHosts[0], splitHosts[1]));
            bytesRemaining -= splitSize;
          }

          if (bytesRemaining != 0) {
            String[][] splitHosts = getSplitHostsAndCachedHosts(blkLocations, length
                - bytesRemaining, bytesRemaining, clusterMap);
            splits.add(makeSplit(path, length - bytesRemaining, bytesRemaining,
                splitHosts[0], splitHosts[1]));
          }
        } else {
          if (LOG.isDebugEnabled()) {
            // Log only if the file is big enough to be splitted
            if (length > Math.min(file.getBlockSize(), minSize)) {
              LOG.debug("File is not splittable so no parallelization "
                  + "is possible: " + file.getPath());
            }
          }
          String[][] splitHosts = getSplitHostsAndCachedHosts(blkLocations,0,length,clusterMap);
          splits.add(makeSplit(path, 0, length, splitHosts[0], splitHosts[1]));
        }
      } else { 
        //Create empty hosts array for zero length files
        splits.add(makeSplit(path, 0, length, new String[0]));
      }
    }

>> 拆解分析3：结合1和2，sc.textFile产生的rdd的分区数 就是文件按照blocksize切片后的数量。

2、后续窄依赖RDD

包括map、flatmap、mappartition 、filter、mapvalues等产生的rdd，分区数和父rdd保持一致

特例：val rdd2 = rdd1.coalesce(2,false)

 rdd2中的一个分区映射了rdd1中多个固定分区。

 3、后续宽依赖RDD

（1）传入了分区数参数

如果shuffle算子传入了分区数参数，则很显然由该参数决定，比如reduceBykey(f,4)、groupBykey(4)等

（2）未传入了分区数参数

如果没有传入参数，则优先根据spark.default.parallelism参数值作为默认分区数，如果参数没配，则参考运行时能用到的cpu核数：

  • Local运行模式下： 
    scheduler.conf.getInt("spark.default.parallelism", totalCores)
  • 集群运行模式下： 
    conf.getInt("spark.default.parallelism", math.max(totalCoreCount.get(), 2))
  • Sample-01
package com.wakedata.partitionNums

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object TextFile {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf();
    conf.setMaster("local[*]")
    conf.setAppName("textFile");
    val sc = new SparkContext(conf);


    val rdd2: RDD[(Char, Int)] = sc.parallelize(Seq(
      ('a', 1),
      ('b', 4),
      ('d', 3),
      ('c', 2),
      ('e', 2),
    ));

    println("rdd2的分区器", rdd2.partitioner);
    println("rdd2的分区数", rdd2.getNumPartitions);
    rdd2.collect();


    val rdd3 = rdd2.groupBy(s => s._1);
    println("rdd3的分区器", rdd3.partitioner);
    println("rdd3的分区数", rdd3.getNumPartitions);

    rdd3.collect();

  }

}

 >>分区数为8,因为Local运行模式下，且未设置spark.default.parallelism参数，最终会取主机的cores数量作为分区数。

 

  •  Sample-02，如果设置spark.default.parallelism的值
package com.wakedata.partitionNums

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object TextFile2 {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf();
    conf.setMaster("local[*]")
    conf.setAppName("textFile");
    conf.set("spark.default.parallelism","4");
    val sc = new SparkContext(conf);


    val rdd2: RDD[(Char, Int)] = sc.parallelize(Seq(
      ('a', 1),
      ('b', 4),
      ('d', 3),
      ('c', 2),
      ('e', 2),
    ));

    println("rdd2的分区器", rdd2.partitioner);
    println("rdd2的分区数", rdd2.getNumPartitions);
    rdd2.collect();


    val rdd3 = rdd2.groupBy(s => s._1);
    println("rdd3的分区器", rdd3.partitioner);
    println("rdd3的分区数", rdd3.getNumPartitions);

    rdd3.collect();

  }

}

如上所示，分区数量会变成4 

 二、分区器如何决定

  1、并非所有RDD都有分区器

  • 数据源RDD通过数据源读取器的内在机制进行分区，不需要Partitioner;
  • 窄依赖rdd,直接一对一依赖于前面rdd的分区，没有发生任何数据分布的变化，因此也不需要Partitioner;
  • 宽依赖才会需要Partitioner（但并非一定有Partitioner），可以手动传入，也可以取默认值，具体逻辑如下：
//求默认分区器的策略和方法  
def defaultPartitioner(rdd: RDD[_], others: RDD[_]*): Partitioner = {
    //合并所有父rdd(多个rdd Join场景)成为一个序列
    val rdds = (Seq(rdd) ++ others)

   //筛选出拥有分区器的父rdd
    val hasPartitioner = rdds.filter(_.partitioner.exists(_.numPartitions > 0))

   //拥有分区器的父rdd中，分区数最大的rdd
    val hasMaxPartitioner: Option[RDD[_]] = if (hasPartitioner.nonEmpty) {
      Some(hasPartitioner.maxBy(_.partitions.length))
    } else {
      None
    }

   // 默认分区数:如果有设置参数,则取其值，如果没有则取父rdd中(包括不含分区器的父rdd)最大的分区数
    val defaultNumPartitions = if (rdd.context.conf.contains("spark.default.parallelism")) {
      rdd.context.defaultParallelism
    } else {
      rdds.map(_.partitions.length).max
    }

    // If the existing max partitioner is an eligible one, or its partitions number is larger
    // than or equal to the default number of partitions, use the existing partitioner.



   //如果父rdd中至少一个拥有分区器，同时[所有父rdd最大分区数]/ [拥有分区器的父rdd中最大的分区数]  < 10 | 默认分区数 小于等于 拥有分区器的父rdd的最大的分区数]，则取拥有分区器的父rdd中最大的分区数 作为最后的分区数
    if (hasMaxPartitioner.nonEmpty && (isEligiblePartitioner(hasMaxPartitioner.get, rdds) ||
        defaultNumPartitions <= hasMaxPartitioner.get.getNumPartitions)) {
      hasMaxPartitioner.get.partitioner.get
    } else {
       //否则就取 默认分区数作为最后的分区数
      new HashPartitioner(defaultNumPartitions)
    }
  }


  private def isEligiblePartitioner(
     hasMaxPartitioner: RDD[_],
     rdds: Seq[RDD[_]]): Boolean = {
    val maxPartitions = rdds.map(_.partitions.length).max
    log10(maxPartitions) - log10(hasMaxPartitioner.getNumPartitions) < 1
  }

2、场景举例

（1）父rdd至少一个存在分区器,但是所有父rdd最大分区数 / 拥有分区器的父rdd中最大的分区数  > 10 且  默认分区数（只有一种场景,即设置了参数）大于拥有分区器的父rdd中最大的分区数。此时子rdd的分区器是hasMaxPartitioner，并且分区数是默认分区数。【本地主机只有8核，无法模拟所有父rdd最大分区数 / 拥有分区器的父rdd中最大的分区数  > 10 】

（2）父RDD1 有分区器且分区数为2，父RDD2没有分区器且分区数为8，不设置spark.default.parallelism参数,则defaultNumPartitions为8,然后父RDD中有一个存在分区器,并且isEligiblePartitioner满足条件,因此子RDD的是 hasMaxPartitioner.get.partitioner.get,即分区器为：父RDD的分区器 & 分区数为2

package com.wakedata.partitionNums

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object DependencyPartitioner {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf();
    conf.setMaster("local[*]")
    conf.setAppName("textFile");
//    conf.set("spark.default.parallelism","4");
    val sc = new SparkContext(conf);

    val rdd1: RDD[(Char, Int)] = sc.parallelize(Seq(
      ('a', 1),
      ('b', 4),
      ('d', 3),
      ('c', 2),
      ('e', 2),
    ));

    //第一个父rdd,分区数为2
    val rdd2: RDD[(Char, Iterable[Int])] = rdd1.groupByKey(
      numPartitions = 2
    );

    //第二个父rdd,没有分区器且分区数是 8(CPU逻辑为8,最大也只能分8个区)
//    val rdd3: RDD[(Char, Int)] = rdd1.coalesce(100)

    val rdd3: RDD[(Char, Int)] = rdd1.coalesce(8)
    println("rdd3分区数",rdd3.getNumPartitions);

    val rdd2_3_join = rdd2.join(rdd3)
    //rdd2_3_join的分区数应该是 2
    println(rdd2_3_join.getNumPartitions)

    //rdd2_3_join的分区器是Hashpartioner
    println(rdd2_3_join.partitioner)

  }

}

 （3）父RDD1 有分区器且分区数为2，父RDD2没有分区器且分区数为8，设置spark.default.parallelism参数为4,则defaultNumPartitions为4, 然后父RDD中有一个存在分区器,并且isEligiblePartitioner满足条件,因此子RDD的是 hasMaxPartitioner.get.partitioner.get,即分区器为：父RDD的分区器 & 分区数为2

package com.wakedata.partitionNums

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object DependencyPartitioner02 {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf();
    conf.setMaster("local[*]")
    conf.setAppName("textFile");
    conf.set("spark.default.parallelism","4");
    val sc = new SparkContext(conf);

    val rdd1: RDD[(Char, Int)] = sc.parallelize(Seq(
      ('a', 1),
      ('b', 4),
      ('d', 3),
      ('c', 2),
      ('e', 2),
    ));

    //第一个父rdd,分区数为2
    val rdd2: RDD[(Char, Iterable[Int])] = rdd1.groupByKey(
      numPartitions = 2
    );

    //第二个父rdd,没有分区器且分区数是 8(CPU逻辑为8,最大也只能分8个区)
//    val rdd3: RDD[(Char, Int)] = rdd1.coalesce(100)

    val rdd3: RDD[(Char, Int)] = rdd1.coalesce(8)
    println("rdd3分区数",rdd3.getNumPartitions);

    val rdd2_3_join = rdd2.join(rdd3)
    //rdd2_3_join的分区数应该是 2
    println(rdd2_3_join.getNumPartitions)

    //rdd2_3_join的分区器是Hashpartioner
    println(rdd2_3_join.partitioner)

  }

}

（4）父RDD1 没有分区器且分区数为2，父RDD2没有分区器且分区数为3，没有设置 spark.default.parallelism参数,则defaultNumPartitions为3, 子RDD是new hasMaxPartitioner,分区数是3.

package com.wakedata.partitionNums

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object DependencyPartitioner03 {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf();
    conf.setMaster("local[*]")
    conf.setAppName("textFile");
//    conf.set("spark.default.parallelism","4");
    val sc = new SparkContext(conf);

    // 第一个父rdd，没有分区器
    val rdd1: RDD[(Char, Int)] = sc.parallelize(Seq(
      ('a', 1),
      ('b', 4),
      ('d', 3),
      ('c', 2),
      ('e', 2),
    ),2);

    // 第二个父rdd，没有分区器
    val rdd2: RDD[(Char, Int)] = sc.parallelize(Seq(
      ('f', 1),
      ('g', 4),
      ('h', 3),
      ('i', 2),
      ('j', 2),
    ),3);

    val rdd_join = rdd1.join(rdd2);

    //join的分区器应该是HashPartitioner
    println(rdd_join.partitioner)

    //join的分区数量应该是3
    println(rdd_join.getNumPartitions)

  }

}

（5）父RDD1 没有分区器且分区数为2，父RDD2没有分区器且分区数为3，且设置 spark.default.parallelism = 4,则defaultNumPartitions为4, 子RDD是new hasMaxPartitioner,分区数是4.

package com.wakedata.partitionNums

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object DependencyPartitioner04 {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf();
    conf.setMaster("local[*]")
    conf.setAppName("textFile");
    conf.set("spark.default.parallelism","4");
    val sc = new SparkContext(conf);

    // 第一个父rdd，没有分区器
    val rdd1: RDD[(Char, Int)] = sc.parallelize(Seq(
      ('a', 1),
      ('b', 4),
      ('d', 3),
      ('c', 2),
      ('e', 2),
    ),2);

    // 第二个父rdd，没有分区器
    val rdd2: RDD[(Char, Int)] = sc.parallelize(Seq(
      ('f', 1),
      ('g', 4),
      ('h', 3),
      ('i', 2),
      ('j', 2),
    ),3);

    val rdd_join = rdd1.join(rdd2);

    //join的分区器应该是HashPartitioner
    println(rdd_join.partitioner)

    //join的分区数量应该是4
    println(rdd_join.getNumPartitions)

  }

}

 

maplea2012
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spark：任务中如何确定spark分区数、task数目、core个数、worker节点个数、excutor数量
budalawork的专栏
04-30 1039
先上图： 每一个过程的任务数，对应一个inputSplit1, Partition输入可能以多个文件的形式存储在HDFS上，每个File都包含了很多块，称为Block。 当Spark读取这些文件作为输入时，会根据具体数据格式对应的InputFormat进行解析，一般是将若干个Block合并成一个输入分片，称为InputSplit，注意InputSplit不能跨越文件。 随后将为这些...
Spark的RDD分区器
最新发布
2401_84046645的博客
04-17 327
说明用户可以根据自己的需要，自定义分区个数。案例实操自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
Caused by: java.io.IOException: Path: //single is a directory
wang5g的博客
03-16 3391
报错信息： Caused by: java.io.IOException: Path: //single is a directory, which is not supported by the record reader when `mapreduce.input.fileinputformat.input.dir.recursive` is false. 问题解决 spark读入的路径和最终输出落盘的路径不能一致，否则会触发io异常 ...
Spark RDD 分区数计算详解
石榴姐yyds
04-21 776
基础知识 spark.default.parallelism：（默认的并发数）= 2 当配置文件spark-default.conf中没有显示的配置，则按照如下规则取值： 1、本地模式（不会启动executor，由SparkSubmit进程生成指定数量的线程数来并发）： spark-shell spark.default.parallelism = 1 spark-shell --master local[N] spark.default.parallel...
Spark RDD 创建和分区规则
qq_43192537的博客
11-28 1285
Spark RDD 创建和分区规则
【SparkCore篇06】RDD数据分区1
08-04
在处理Key-Value类型的RDD时，分区器尤其重要，因为它决定了数据经过Shuffle过程后的分区归属。默认的分区策略是HashPartitioner，它根据Key的哈希值进行分区。对于非Key-Value类型的RDD，其分区器的值为None。 让...
spark-textFile构建RDD的分区及compute计算策略
04-08
这个过程主要涉及到三个步骤：获取所有 FileStatus、创建路径过滤器和并发执行分区任务。 在获取所有 FileStatus 的过程中，spark-textFile 会使用 listStatus 方法来获取文件的状态信息，然后根据需要递归的参数来...
Spark学习笔记之Spark中的RDD的具体使用
08-25
* 交互式计算：RDD使得Spark可以完美的运用scala的解释器，使得其中的scala可以向操作本地集合对象一样轻松操作分布式数据集。 知识点四：Spark中的名词解释 * ClusterManager：在Standalone模式中即为Master（主...
Spark学习--RDD编码
05-09
当Spark对数据操作和转换时，会自动将RDD中的数据分发到集群，并将操作并行化执行。 Spark中的RDD是一个不可变的分布式对象集合。每个RDD都倍分为多个分区，这些分区运行在集群中的不同节点。RDD可以包含Python、...
spark 累加器，广播变量.docx
03-29
Spark 中的数据结构主要有三种：RDD、累加器和广播变量。本文将对这三种数据结构进行详细介绍。 一、RDD（Resilient Distributed Datasets） RDD 是 Spark 中的基本数据结构，表示一个可以被分区、并行处理的数据...
Spark大数据处理学习笔记3.3 掌握RDD分区
qq_62847100的博客
05-08 415
在有些情况下，使用Spark自带的分区器满足不了特定的需求。例如，某学生有以下3科成绩数据：科目成绩chinese98math88english96chinese89math96english67chinese88math78english89现需要将每一科成绩单独分配到一个分区中，然后将3科成绩输出到HDFS的指定目录（每个分区对应一个结果文件），此时就需要对数据进行自定义分区。在net.zhj.rdd.day04中创建SubjectPartitioner类/**
Spark的reduceByKey方法使用
benben044的专栏
03-01 1332
Spark的reduceByKey方法使用。reduce操作之字符串方式。reduce操作之列表方式。reduce之partition属性。reduceByKey和groupByKey的区别。
Spark 中 Partition，Task，core，Executor的个数决定因素和关系
mzqadl的博客
02-08 8519
分区（Partition）数 我们都知道一个 RDD 中有多个 Partition，Partition 是 Spark RDD 计算的最小单元，决定了计算的并发度。 分区数如果远小于集群可用的 CPU 数，不利于发挥 Spark 的性能，还容易导致数据倾斜等问题。 分区数如果远大于集群可用的 CPU 数，会导致资源分配的时间过长，从而影响性能。 那么，Partition 的数量是由什么决定的呢？...
Spark中reduceByKey(_+_)的说明
Gloria的博客
07-27 2164
https://blog.csdn.net/CDW2328/article/details/90319420
Spark阶段RDD的分区数计算
weixin_43690478的博客
06-24 773
1.调用textFile() def textFile( path: String, minPartitions: Int = defaultMinPartitions): RDD[String] = withScope { assertNotStopped() hadoopFile(path, classOf[TextInputFormat], classOf[LongWritable], classOf[Text], minPartitions).map(pair =&g
Spark中Key-Value类型|partitionBy()按照Key重新分区|reduceByKey()按照K聚合V|groupByKey()按照K重新分组
SmallScorpion
04-17 1642
代码实现 Shuffle过程(落盘) 需要把所有哦分区的数据拿到一起处理，会有shuffle 自定义分区器 源码分析 class HashPartitioner(partitions: Int) extends Partitioner { require(partitions >= 0, s"Number of partitions ($partitions) canno...
Spark查看每个分区的数据
ks_1998的博客
03-30 3031
Spark查看每个分区的数据
Spark学习之路 （十七）Spark分区
weixin_30345577的博客
05-03 211
一、分区的概念 　　分区是RDD内部并行计算的一个计算单元，RDD的数据集在逻辑上被划分为多个分片，每一个分片称为分区，分区的格式决定了并行计算的粒度，而每个分区的数值计算都是在一个任务中进行的，因此任务的个数，也是由RDD(准确来说是作业最后一个RDD)的分区数决定。 二、为什么要进行分区 　　数据分区，在分布式集群里，网络通信的代价很大，减少网络传输可以极大提升性能。mapreduce框...
sparkrdd转换算子
03-18
Spark RDD（弹性分布式数据集）是Spark中最基本的数据抽象，它代表了一个不可变、可分区、可并行计算的数据集合。转换算子是用于对RDD进行转换操作的方法，可以通过转换算子对RDD进行各种操作和变换，生成新的RDD。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值