黑猴子的家：Spark 键值对 RDD 之 数据分区

Spark中主要用的分区模式有Hash分区或者RangePartitioner分区两种，用户也可以自定义分区，Hash分区为当前的默认分区，hash分区主要是通过Key对于分区数求余来进行实现，Rang分区主要是通过水塘抽样算法进行实现，让每一个分区数据尽可能数据一致，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方法获取其中的值。

scala> val pairs = sc.parallelize(List((1,1),(2,2),(3,3)))
pairs: org.apache.spark.rdd.RDD[(Int, Int)] 
               = ParallelCollectionRDD[29] at parallelize at <console>:27

scala> pairs.partitioner
res19: Option[org.apache.spark.Partitioner] = None

scala> val partitioned = pairs.partitionBy(new org.apache.spark.HashPartitioner(2))
partitioned: org.apache.spark.rdd.RDD[(Int, Int)] 
               = ShuffledRDD[31] at partitionBy at <console>:29

scala> partitioned.partitioner
res20: Option[org.apache.spark.Partitioner] = Some(org.apache.spark.HashPartitioner@2)

2、Hash分区方式

HashPartitioner分区的原理：对于给定的key，计算其hashCode，并除于分区的个数取余，如果余数小于0，则用余数+分区的个数，最后返回的值就是这个key所属的分区ID

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[25] at parallelize at <console>:27

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

scala> nopar.mapPartitionsWithIndex((index,iter)=>{ \
               Iterator(index.toString+" : "+iter.mkString("|")) }).collect
res15: 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[27] at partitionBy at <console>:29

scala> hashpar.count
res16: Long = 6                                                                 

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

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

3、Range分区方式

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

RangePartitioner分区优势：尽量保证每个分区中数据量的均匀，而且分区与分区之间是有序的，一个分区中的元素肯定都是比另一个分区内的元素小或者大

但是分区内的元素是不能保证顺序的。简单的说就是将一定范围内的数映射到某一个分区内。

RangePartitioner作用：将一定范围内的数映射到某一个分区内，在实现中，分界的算法尤为重要。用到了水塘抽样算法。

4、自定义分区方式

要实现自定义的分区器，

（1）需要继承org.apache.spark.Partitioner抽象类。

（2）实现 override def numPartitions: Int 返回给定键的分区编号(0到numPartitions-1)这个方法就是返回创建出来的分区数。

（3）实现 override def getPartition(key: Any): Int 这个方法是根据你传入的key返回分区号。

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

假设我们需要将相同后缀的数据写入相同的文件，我们通过将相同后缀的数据分区到相同的分区并保存输出来实现。
code

import org.apache.spark.{Partitioner, SparkConf, SparkContext}

class CustomerPartitioner(numParts:Int) extends Partitioner {

  //覆盖分区数
  override def numPartitions: Int = numParts

  //覆盖分区号获取函数
  override def getPartition(key: Any): Int = {
    val ckey: String = key.toString
    ckey.substring(ckey.length-1).toInt%numParts
  }
}

object CustomerPartitioner1 {
//主方法
  def main(args: Array[String]): Unit = {

    val conf=new SparkConf().setAppName("partitioner")
    val sc=new SparkContext(conf)
    val data=sc.parallelize(List("aa.2","bb.2","cc.3","dd.3","ee.5"))
    data.map((_,1)).partitionBy(
        new CustomerPartitioner(5)).keys
        .saveAsTextFile("hdfs://hadoop102:9000/partitioner")
    sc.stop()
    
  }
}

REPL

scala> val data=sc.parallelize(List("aa.2","bb.2","cc.3","dd.3","ee.5").zipWithIndex,2)
data: org.apache.spark.rdd.RDD[(String, Int)] 
                          = ParallelCollectionRDD[32] at parallelize at <console>:27

scala> data.collect
res21: Array[(String, Int)] = Array((aa.2,0), (bb.2,1), (cc.3,2), (dd.3,3), (ee.5,4))

scala> data.mapPartitionsWithIndex( \
(index,iter)=>Iterator(index.toString +" : "+ iter.mkString("|"))).collect
res22: Array[String] = Array(0 : (aa.2,0)|(bb.2,1), 1 : (cc.3,2)|(dd.3,3)|(ee.5,4))

scala> :paste
// Entering paste mode (ctrl-D to finish)

class CustomerPartitioner(numParts:Int) extends org.apache.spark.Partitioner{

  //覆盖分区数
  override def numPartitions: Int = numParts

  //覆盖分区号获取函数
  override def getPartition(key: Any): Int = {
    val ckey: String = key.toString
    ckey.substring(ckey.length-1).toInt%numParts
  }
}
//Ctrl + D 退出块编辑
// Exiting paste mode, now interpreting.

defined class CustomerPartitioner

scala> val datap = data.partitionBy(new CustomerPartitioner(4))
datap: org.apache.spark.rdd.RDD[(String, Int)] 
                          = ShuffledRDD[37] at partitionBy at <console>:30

scala> datap.mapPartitionsWithIndex( \
          (index,iter)=>Iterator(index.toString +" : "+ iter.mkString("|"))).collect
res26: Array[String] 
         = Array("0 : ", 1 : (ee.5,4), 2 : (aa.2,0)|(bb.2,1), 3 : (cc.3,2)|(dd.3,3))

使用自定义的 Partitioner 是很容易的:只要把它传给 partitionBy() 方法即可。Spark 中有许多依赖于数据混洗的方法，比如 join() 和 groupByKey()，它们也可以接收一个可选的 Partitioner 对象来控制输出数据的分区方式。

5、分区Shuffle优化

在分布式程序中， 通信的代价是很大的，因此控制数据分布以获得最少的网络传输可以极大地提升整体性能。

Spark 中所有的键值对 RDD 都可以进行分区。系统会根据一个针对键的函数，对元素进行分组。 主要有哈希分区和范围分区，当然用户也可以自定义分区函数。

通过分区可以有效提升程序性能。如下例子：

分析这样一个应用，它在内存中保存着一张很大的用户信息表，也就是一个由 (UserID, UserInfo) 组成的 RDD，其中 UserInfo 包含一个该用户所订阅的主题的列表。该应用会周期性地将这张表与一个小文件进行组合，这个小文件中存着过 去五分钟内发生的事件，其实就是一个由 (UserID, LinkInfo) 对组成的表，存放着过去 五分钟内某网站各用户的访问情况。例如，我们可能需要对用户访问其未订阅主题的页面 的情况进行统计。

解决方案一

//初始化代码；从HDFS上的一个Hadoop SequenceFile 中读取用户信息
//userData 中的元素会根据它们被读取时的来源，即HDFS块所在的节点来分布
//Spark 此时无法获知某个特定的User ID 对应的记录位于哪个节点上
val sc = new SparkContext(…)
val userData = sc.sequenceFile[UserID,UserInfo]("hdfs://…").persist()

//周期性调用函数来处理过去5分钟产生的事件日志
//假设这是一个包含（UserID,LinkInfo）对的SequenceFile
def processNewLogs(logFileName:String){
val events = sc.sequenceFile[UserID,LinkInfo](logFileName)
val joined = userData.join(events)// RDD of (UserID,(UserInfo,LinkInfo)) pairs
val offTopicVisits = joined.filter{
    vase (userId,(userInfo,LinkInfo)) => //Expand the tuple into its components !  
    userInfo.topics.contains(linkInfo.topic)
    }.count()
    println("Number of visits to non-subscribed topics: " + offTopicVists)
}

这段代码可以正确运行，但是不够高效。这是因为在每次调用 processNewLogs() 时都会用 到 join() 操作，而我们对数据集是如何分区的却一无所知。默认情况下，连接操作会将两个数据集中的所有键的哈希值都求出来，将该哈希值相同的记录通过网络传到同一台机器上，然后在那台机器上对所有键相同的记录进行连接操作。因为 userData 表比 每五分钟出现的访问日志表 events 要大得多，所以要浪费时间做很多额外工作:在每次调 用时都对 userData 表进行哈希值计算和跨节点数据混洗，降低了程序的执行效率。

优化方法

val sc = new SparkContext(…)
val userData = sc.sequenceFile[UserID,UserInfo]("hdfs:// …")
              .partitionBy(new HashPartitioner(100)) //构造100个分区
              .persist()

我们在构 建 userData 时调用了 partitionBy()，Spark 就知道了该 RDD 是根据键的哈希值来分 区的，这样在调用 join() 时，Spark 就会利用到这一点。具体来说，当调用 userData. join(events) 时，Spark 只会对 events 进行数据混洗操作，将 events 中特定 UserID 的记 录发送到 userData 的对应分区所在的那台机器上。这样，需要通过网络传输的 数据就大大减少了，程序运行速度也可以显著提升了。

6、基于分区进行操作

基于分区对数据进行操作可以让我们避免为每个数据元素进行重复的配置工作。诸如打开 数据库连接或创建随机数生成器等操作，都是我们应当尽量避免为每个元素都配置一次的 工作。Spark 提供基于分区的 mapPartition 和 foreachPartition，让你的部分代码只对 RDD 的每个分区运行 一次，这样可以帮助降低这些操作的代价。

7、从分区中获益的操作

能够从数据分区中获得性能提升的操作有cogroup()、 groupWith()、join()、leftOuterJoin()、rightOuterJoin()、groupByKey()、reduceByKey()、 combineByKey() 以及 lookup()等。