文章目录

零、本讲学习目标
一、RRD分区
- （一）RDD分区概念
- （二）RDD分区作用
二、RDD分区数量
- （一）RDD分区原则
- （二）影响分区的因素
- （三）使用parallelize()方法创建RDD时的分区数量
- - 1、指定分区数量
  - 2、默认分区数量
  - 3、分区源码分析
- （四）使用textFile()方法创建RDD时的分区数量
- - 1、指定最小分区数量
  - 2、默认最小分区数量
  - 3、默认实际分区数量
- （五）RDD分区方式
三、Spark分区器
- （一）分区器 - Partitioner抽象类
- （二）哈希分区器 - HashPartitioner类
四、自定义分区器
- （一）提出问题
- （二）解决问题
- - 1、准备数据文件
  - 2、新建科目分区器
  - 3、测试科目分区器

零、本讲学习目标

学会如何指定分区数量
会定义与使用自定义分区器

一、RRD分区

（一）RDD分区概念

RDD是一个大的数据集合，该集合被划分成多个子集合分布到了不同的节点上，而每一个子集合就称为分区（Partition）。因此，也可以说，RDD是由若干个分区组成的。

（二）RDD分区作用

在分布式程序中，网络通信的开销是很大的，因此控制数据分布以获得最少的网络传输可以极大的提升程序的整体性能，Spark程序可以通过控制RDD分区方式来减少通信开销。Spark中所有的RDD都可以进行分区，系统会根据一个针对键的函数对元素进行分区。虽然Spark不能控制每个键具体划分到哪个节点上，但是可以确保相同的键出现在同一个分区上。

二、RDD分区数量

（一）RDD分区原则

RDD各个分区中的数据可以并行计算，因此分区的数量决定了并行计算的粒度。Spark会给每一个分区分配一个单独的Task任务对其进行计算，因此并行Task的数量是由分区的数量决定的。RDD分区的一个分区原则是使得分区的数量尽量等于集群中CPU核心数量。

（二）影响分区的因素

RDD的创建有两种方式：一种是使用parallelize()或makeRDD()方法从对象集合创建；另一种是使用textFile()方法从外部存储系统创建。而RDD分区的数量与RDD的创建方式以及Spark集群的运行模式有关。

（三）使用parallelize()方法创建RDD时的分区数量

1、指定分区数量

使用parallelize()方法创建RDD时，可以传入第二个参数，指定分区数量。
分区的数量应尽量等于集群中所有CPU的核心总数，以便可以最大程度发挥CPU的性能。
利用mapPartitionsWithIndex()函数实现带分区索引的映射
第1个分区完成了3个元素的映射，第2个分区完成了3个元素的映射，第3个分区完成了4个元素的映射

2、默认分区数量

若不指定分区数量，则默认分区数量为Spark配置文件spark-defaults.conf中的参数spark.default.parallelism的值。若没有配置该参数，则Spark会根据集群的运行模式自动确定分区数量。
如果是本地模式，默认分区数量就等于本机CPU核心总数，这样每个CPU核心处理一个分区的计算任务，可以最大程度发挥CPU的性能。
如果是Spark Standalone或Spark On YARN模式，默认分区数量就取集群中所有CPU的核心总数与2中的较大值，即最少分区数为2。
我们采用的是Standalone模式的Spark集群
先用spark-shell本地模式启动
由此可见，本地机器master的CPU核数为4。
以集群模式启动Spark Shell
注意：Spark集群是一个Master(master虚拟机)和两个Worker(slave1和slave2虚拟机)
默认分区数是8。为什么是8呢？集群两个工作节点（slave1和slave2）的CPU核数总和是4 + 4 = 8

3、分区源码分析

parallelize()方法是在SparkContext类定义的
numSlices参数为指定的分区数量，该参数有一个默认值defaultParallelism，是一个无参函数
上述代码中的taskScheduler的类型为特质TaskScheduler，通过调用该特质的defaultParallelism方法取得默认分区数量，而类TaskSchedulerImpl继承了特质TaskScheduler并实现了defaultParallelism方法。
上述代码中的backend的类型为特质SchedulerBackend，通过调用该特质的defaultParallelism()方法取得默认分区数量，特质SchedulerBackend主要用于申请资源和对Task任务的执行和管理；而类LocalSchedulerBackend和类CoarseGrainedSchedulerBackend则继承了特质SchedulerBackend并分别实现了其中的defaultParallelism()方法。
类LocalSchedulerBackend用于Spark的本地运行模式（Executor和Master等在同一个JVM中运行），其调用顺序在TaskSchedulerImpl类之后；类CoarseGrainedSchedulerBackend则用于Spark的集群运行模式。
类LocalSchedulerBackend中的defaultParallelism()方法
上述代码中的字符串spark.default.parallelism为Spark配置文件spark-defaults.conf中的参数spark.default.parallelism；totalCores为本机CPU核心总数。
类CoarseGrainedSchedulerBackend中的defaultParallelism()方法
上述代码中，math.max(totalCoreCount.get(), 2)表示取集群中所有CPU核心总数与2两者中的较大值。

（四）使用textFile()方法创建RDD时的分区数量

textFile()方法通常用于读取HDFS中的文本文件，使用该方法创建RDD时，Spark会对文件进行分片操作（类似于MapReduce的分片，实际上调用的是MapReduce的分片接口），分片操作完成后，每个分区将存储一个分片的数据，因此分区的数量等于分片的数量。

1、指定最小分区数量

使用textFile()方法创建RDD时可以传入第二个参数指定最小分区数量。最小分区数量只是期望的数量，Spark会根据实际文件大小、文件块（Block）大小等情况确定最终分区数量。
在HDFS中有一个文件/park/test.txt，读取该文件，并指定最小分区数量为5，但是实际分区数量是6。

2、默认最小分区数量

若不指定最小分区数量，则Spark将采用默认规则计算默认最小分区数量。
查看textFile()源码
上述代码中的minPartitions参数为期望的最小分区数量，该参数有一个默认值defaultMinPartitions，这是一个无参函数，我们来查看其源码。
从上述代码中可以看出，默认最小分区数取默认并行度与2中的较小值；而默认并行度则是parallelize()方法的默认分区数。

3、默认实际分区数量

最小分区数量确定后，Spark接下来将计算实际分区数量。查看textFile()方法的源码可知，textFile()方法最后调用了一个hadoopFile()方法，并对该方法的结果执行了map()算子。
查看hadoopFile()方法的源码
从上述代码可以看出，最终返回一个HadoopRDD对象。
查看HadoopRDD类的部分源码
HadoopRDD类中的getPartitions()方法的功能是获取实际分区数量。通过调用getInputFormat()方法得到InputFormat的实例，然后调用该实例的getSplits()方法获得输入数据的所有分片，getSplits()方法是决定最终分区数量的关键方法，该方法的第二个参数即为RDD的最小分区数量。
查看InputFormt接口getSplits()抽象方法
InputFormat有个实现类FileInputFormat，它实现了getSplits()方法
根据期望分片数量（numSplits，即最小分区数量）计算期望分片大小（goalSize）。计算实际分片大小（splitSize）。splitSize最终决定了分片的数量。
splitSize由3个因素决定：最小分片大小（minSize）、期望分片大小（goalSize）、分块大小（blockSize）。

  public InputSplit[] getSplits(JobConf job, int numSplits)
    throws IOException {
    StopWatch sw = new StopWatch().start();
    FileStatus[] files = listStatus(job);
    
    // Save the number of input files for metrics/loadgen
    job.setLong(NUM_INPUT_FILES, files.length);
    long totalSize = 0;                           // compute total size
    for (FileStatus file: files) {                // check we have valid files
      if (file.isDirectory()) {
        throw new IOException("Not a file: "+ file.getPath());
      }
      totalSize += file.getLen();
    }

    long goalSize = totalSize / (numSplits == 0 ? 1 : numSplits);
    long minSize = Math.max(job.getLong(org.apache.hadoop.mapreduce.lib.input.
      FileInputFormat.SPLIT_MINSIZE, 1), minSplitSize);

    // 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 {
          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]));
      }
    }
    sw.stop();
    if (LOG.isDebugEnabled()) {
      LOG.debug("Total # of splits generated by getSplits: " + splits.size()
          + ", TimeTaken: " + sw.now(TimeUnit.MILLISECONDS));
    }
    return splits.toArray(new FileSplit[splits.size()]);
  }

结论：在MapReduce中，每个分片对应一个Map任务，多个Map任务以完全并行的方式处理；而在Spark中，每个分片对应一个分区，每个分区对应一个Task任务，多个Task任务以完全并行的方式处理。

（五）RDD分区方式

Spark框架为RDD提供了两种分区方式，分别是哈希分区（HashPartitioner）和范围分区（RangePartitioner）。其中，哈希分区是根据哈希值进行分区；范围分区是将一定范围的数据映射到一个分区中。这两种分区方式已经可以满足大多数应用场景的需求。与此同时，Spark也支持自定义分区方式，即通过一个自定义的Partitioner对象来控制RDD的分区，从而进一步减少通信开销。

三、Spark分区器

（一）分区器 - Partitioner抽象类

Spark RDD的Shuffle过程与MapReduce类似，涉及数据重组和重新分区，且要求RDD的元素必须是(key, value)形式的。分区规则是由分区器（Partitioner）控制的，Spark的主要分区器是HashPartitioner和RangePartitioner，都继承了Partitioner抽象类。
抽象类Partitioner中有两个方法，分别用于指定分区数量和设置分区规则

（二）哈希分区器 - HashPartitioner类

HashPartitioner是Spark使用的默认分区器，其分区规则为：取(key,value)对中key的hashCode值，然后除以分区数量后取余数。若余数小于0（一般余数都大于等于0），则用余数与分区数量的和作为分区ID，否则将余数作为分区ID。分区ID一致的(key,value)对则会被分配到同一个分区。因此，默认情况下，key值相同的(key,value)对一定属于同一个分区，但是同一个分区中可能有多个key值不同的(key,value)对。该分区器还支持key值为null的情况，当key值等于null时，将直接返回0作为分区ID。
HashPartitioner分区器中，对key取hashCode值实际上调用的是Java类Object中的hashCode()方法。由于Java数组的hashCode值基于的是数组标识，而不是数组内容，因此具有相同内容的数组的hashCode值不同。如果将数组作为RDD的key，就可能导致内容相同的key不能分配到同一个分区中。这个时候可以将数组转为集合，或者使用自定义分区器，根据数组内容进行分区。

四、自定义分区器

（一）提出问题

在有些情况下，使用Spark自带的分区器满足不了特定的需求。
例如，某学生有以下3科成绩数据。

科目	成绩
chinese	98
math	88
english	96
chinese	89
math	96
english	67
chinese	88
math	78
english	89

现需要将每一科成绩单独分配到一个分区中，然后将3科成绩输出到HDFS的指定目录（每个分区对应一个结果文件），此时就需要对数据进行自定义分区。

（二）解决问题

1、准备数据文件

在master虚拟机的/home目录里创建marks.txt
将数据文件上传到HDFS指定目录

2、新建科目分区器

创建net.huawei.rdd.day04包，在包里创建SubjectPartitioner类

package net.huawei.rdd.day04

import org.apache.spark.Partitioner

/**
 * 功能：科目分区器
 * 作者：华卫
 * 日期：2023年05月04日
 */
class SubjectPartitioner(partitions: Int) extends Partitioner {
  /**
   * @return 分区数量
   */
  override def numPartitions: Int = partitions

  /**
   * @param key
   * @return 分区索引
   */
  override def getPartition(key: Any): Int = {
    val partitionIndex = key.toString match {
      case "chinese" => 0
      case "math" => 1
      case "english" => 2
    }
    partitionIndex
  }
}

3、测试科目分区器

调用RDD的partitionBy()方法传入科目分区器类SubjectPartitioner的实例，可以对RDD按照自定义规则进行重新分区。
在net.huawei.rdd.day04包里创建TestSubjectPartitioner单例对象

package net.huawei.rdd.day04

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

/**
 * 功能：测试科目分区器
 * 作者：华卫
 * 日期：2023年05月04日
 */
object TestSubjectPartitioner {
  def main(args: Array[String]): Unit = {
    // 创建Spark配置对象
    val conf = new SparkConf()
      .setAppName("TestSubjectPartitioner") // 设置应用名称
      .setMaster("local[*]") // 设置主节点位置（本地调试）
    // 基于Spark配置对象创建Spark容器
    val sc = new SparkContext(conf)
    // 读取HDFS文件，生成RDD
    val lines = sc.textFile("hdfs://master:9000/partition/input/marks.txt")
    // 将每行数据映射成(科目,成绩)二元组
    val data: RDD[(String, Int)] = lines.map(line => {
        val fields = line.split(" ")
        (fields(0), fields(1).toInt) // (科目,成绩)
    })
    // 将数据重新分区
    val partitionData = data.partitionBy(new SubjectPartitioner(3))
    // 在控制台输出分区数据
    partitionData.collect.foreach(println)
    // 保存分区数据到HDFS指定目录
    partitionData.saveAsTextFile("hdfs://master:9000/partition/output")
  }
}