Spark -- RDD数据分区(分区器)

最新推荐文章于 2023-06-06 08:41:58 发布

Keep hunger

最新推荐文章于 2023-06-06 08:41:58 发布

阅读量909

点赞数

分类专栏： Spark 文章标签： spark

本文链接：https://blog.csdn.net/ITgagaga/article/details/105653748

版权

Spark 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

Spark – RDD数据分区

Spark目前支持Hash分区和Range分区，用户也可以自定义分区，Hash分区为当前的默认分区，Spark中分区器直接决定了RDD中分区的个数、RDD中每条数据经过Shuffle过程属于哪个分区和Reduce的个数

注意：

(1)只有Key-Value类型的RDD才有分区器的，非Key-Value类型的RDD分区器的值是None
(2)每个RDD的分区ID范围：0~numPartitions-1，决定这个值是属于那个分区的。

1. 获取RDD分区

可以通过使用RDD的partitioner 属性来获取 RDD 的分区方式。它会返回一个 scala.Option 对象，通过get方法获取其中的值。相关源码如下：

def getPartition(key: Any): Int = key match {
  case null => 0
  case _ => Utils.nonNegativeMod(key.hashCode, numPartitions)
}

def nonNegativeMod(x: Int, mod: Int): Int = {
  val rawMod = x % mod
  rawMod + (if (rawMod < 0) mod else 0)
}

如下可以使用partitioner方法获取分区器

object getRDDpartition {
  def main(args: Array[String]): Unit = {
    //获取上下文对象
    val conf = new SparkConf().setMaster("local[*]").setAppName("getRDDpartition")
    val sc = new SparkContext(conf)

    val pairs = sc.parallelize(List((1,1),(2,2),(3,3)))
    //可以通过partitioner查看分区器
    println("分区器："+pairs.partitioner)
    println("分区：")
    pairs.partitions.foreach(println)
  }
}

打印：
分区器：None
分区：
org.apache.spark.rdd.ParallelCollectionPartition@691
org.apache.spark.rdd.ParallelCollectionPartition@692
org.apache.spark.rdd.ParallelCollectionPartition@693
org.apache.spark.rdd.ParallelCollectionPartition@694

使用partitionBy()方法重新分区，使用HashPartitioner(num)分区器
object getRDDpartition {
  def main(args: Array[String]): Unit = {
    //获取上下文对象
    val conf = new SparkConf().setMaster("local[*]").setAppName("getRDDpartition")
    val sc = new SparkContext(conf)

    val pairs = sc.parallelize(List((1,1),(2,2),(3,3)))
    val Hashpartiton = pairs.partitionBy(new HashPartitioner(3))
    //可以通过partitioner查看分区器
    println("分区器："+Hashpartiton.partitioner)
    println("分区：")
    Hashpartiton.partitions.foreach(println)
  }
}

打印：
分区器：Some(org.apache.spark.HashPartitioner@3)
分区：
org.apache.spark.rdd.ShuffledRDDPartition@0
org.apache.spark.rdd.ShuffledRDDPartition@1
org.apache.spark.rdd.ShuffledRDDPartition@2

2. Hash分区

Spark中非常重要的一个分区器，也是默认分区器，默认用于90%以上的RDD相关API上；功能：依据RDD中key值的hashCode的值将数据取模后得到该key值对应的下一个RDD的分区id值，支持key值为null的情况，当key为null的时候，返回0；该分区器基本上适合所有RDD数据类型的数据进行分区操作；但是需要注意的是，由于JAVA中数组的hashCode是基于数组对象本身的，不是基于数组内容的，所以如果RDD的key是数组类型，那么可能导致数据内容一致的数据key没法分配到同一个RDD分区中，这个时候最好自定义数据分区器，采用数组内容进行分区或者将数组的内容转换为集合

scala> nopar.partitioner
res20: Option[org.apache.spark.Partitioner] = None

scala> val nopar = sc.parallelize(List((1,3),(1,2),(2,4),(2,3),(3,6),(3,8)),8)
nopar: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[10] at parallelize at <console>:24

scala>nopar.mapPartitionsWithIndex((index,iter)=>{ Iterator(index.toString+" : "+iter.mkString("|")) }).collect
res0: Array[String] = Array("0 : ", 1 : (1,3), 2 : (1,2), 3 : (2,4), "4 : ", 5 : (2,3), 6 : (3,6), 7 : (3,8)) 
scala> val hashpar = nopar.partitionBy(new org.apache.spark.HashPartitioner(7))
hashpar: org.apache.spark.rdd.RDD[(Int, Int)] = ShuffledRDD[12] at partitionBy at <console>:26

scala> hashpar.count
res18: Long = 6

scala> hashpar.partitioner
res21: Option[org.apache.spark.Partitioner] = Some(org.apache.spark.HashPartitioner@7)

scala> hashpar.mapPartitions(iter => Iterator(iter.length)).collect()
res19: Array[Int] = Array(0, 3, 1, 2, 0, 0, 0)

partitioner分区详情

在对父RDD执行完Map阶段任务后和在执行Reduce阶段任务前，会对Map阶段中间结果进行分区。
分区由父RDD的partitioner确定，主要包括两部分工作：

确定分区数量（也就是reduce task数量），也是子RDD的partition数量。
决定将Map阶段中间结果的每个key-value对分到哪个分区上。

假设一个父RDD要执行reduceByKey任务，我们可以显式的指定分区器：

val rdd_child = rdd_parent.reduceByKey(new HashPartitioner(3), _+_)

HashPartitioner构造参数3就是分区数量，也是启动的reduce task数量，也是reduceByKey结果返回的子RDD的partitions方法返回的数组的长度。

如果没有显式指定分区器，则会调用org.apache.spark包下伴生对象Partitioner的defaultPartitioner静态方法返回的分区器作为默认分区器。

defaultPartitioner返回默认分区器的过程如下：
尝试利用父RDD的partitioner，如果父RDD没有partitioner，则会查看sparkConf中是否定义了 spark.default.parallelism 配置参数，如果定义了就返回new HashPartitioner(sc.defaultParallelism)作为默认分区器，如果没定义就返回new HashPartitioner(rdd_parent.partitions.length)作为默认分区器——
以下是源码：

//org.apache.spark包下伴生对象object Partitioner的方法
def defaultPartitioner(rdd: RDD[_], others: RDD[_]*): Partitioner = {
  val rdds = (Seq(rdd) ++ others)
  val hasPartitioner = rdds.filter(_.partitioner.exists(_.numPartitions > 0))
  if (hasPartitioner.nonEmpty) {
    hasPartitioner.maxBy(_.partitions.length).partitioner.get
  } else {
    if (rdd.context.conf.contains("spark.default.parallelism")) {
      new HashPartitioner(rdd.context.defaultParallelism)
    } else {
      new HashPartitioner(rdds.map(_.partitions.length).max)
    }
  }
}

2. Ranger分区

sortByKey底层使用的数据分区器就是RangePartitioner分区器 .

HashPartitioner分区弊端：可能导致每个分区中数据量的不均匀，极端情况下会导致某些分区拥有RDD的全部数据。

RangePartitioner作用：将一定范围内的数映射到某一个分区内，尽量保证每个分区中数据量的均匀，而且分区与分区之间是有序的，一个分区中的元素肯定都是比另一个分区内的元素小或者大，但是分区内的元素是不能保证顺序的。简单的说就是将一定范围内的数映射到某一个分区内。实现过程为：

第一步：先从整个RDD中抽取出样本数据，将样本数据排序，计算出每个分区的最大key值，形成一个Array[KEY]类型的数组变量rangeBounds；

第二步：判断key在rangeBounds中所处的范围，给出该key值在下一个RDD中的分区id下标；该分区器要求RDD中的KEY类型必须是可以排序的

object getRDDpartition {
  def main(args: Array[String]): Unit = {
    //获取上下文对象
    val conf = new SparkConf().setMaster("local[*]").setAppName("getRDDpartition")
    val sc = new SparkContext(conf)

    val pairs = sc.parallelize(List((1,1),(2,2),(3,3)))
    val Hashpartiton = pairs.partitionBy(new RangePartitioner(2,pairs))
    //可以通过partitioner查看分区器
    println("分区器："+Hashpartiton.partitioner)
    println("分区：")
    Hashpartiton.partitions.foreach(println)
  }
}

new RangePartitioner(2,pairs) 参数：分区，参数2：rdd

4. 自定义分区

要实现自定义的分区器，你需要继承 org.apache.spark.Partitioner 类并实现下面三个方法。

（1）numPartitions: Int:返回创建出来的分区数。

（2）getPartition(key: Any): Int:返回给定键的分区编号(0到numPartitions-1)。

（3）equals():Java 判断相等性的标准方法。这个方法的实现非常重要，Spark 需要用这个方法来检查你的分区器对象是否和其他分区器实例相同，这样 Spark 才可以判断两个 RDD 的分区方式是否相同。

需求：将相同后缀的数据写入相同的文件，通过将相同后缀的数据分区到相同的分区并保存输出来实现。

object Spark12_getPartition {
  def main(args: Array[String]): Unit = {
    //得到spark的上下文对象
    val conf:SparkConf=new SparkConf().setMaster("local[*]").setAppName("makeRDD")
    val sc = new SparkContext(conf)

    //val listRDD: RDD[Int] = sc.makeRDD(Array(1,2,2,3,5,5,5,6,7,7),3)

    val listRDD=sc.makeRDD(List(("a",1),("b",2),("c",3)))

    val unit: RDD[(String, Int)] = listRDD.partitionBy(new MyPatitoner(4))

    unit.saveAsTextFile("OOUT")
  }

}

//声明分区器，自定义分区规则
//numPartitions:分区数
//getPartition：定义规则放在哪个分区
class MyPatitoner(partitions:Int) extends  Partitioner{
    
  override def numPartitions: Int = {
    partitions
  }

  override def getPartition(key: Any): Int = {
    1
  }
}

5. Hash分区和Rang分区优缺点

hash分区器会根据key-value的键值key的hashcode进行分区，速度快，但是可能产生数据偏移，造成每个分区中数据量不均衡。
range分区器会对现有rdd中的key-value数据进行抽样，尽量找出均衡分割点，一定程度上解决了数据偏移问题，力求分区后的每个分区内数据量均衡，但是速度相对慢。