大数据Spark面试，distinct去重原理，是如何实现的

最近，有位朋友问我，distinct去重原理是怎么实现的？

“在面试时，面试官问他了解distinct算子吗？”

“了解啊，Spark的rdd，一种transFormation去重的算子，主要用来去重的”。

“哟，看来你经常使用distinct算子，对distinct算子很熟悉啊”。

“好说，好说”。

“那你能说说distinct是如何实现去重的吗？”

我朋友支支吾吾半天：“就是这样、那样去重的啊”。

“这样、那样是怎么去重的呢”

“具体有点忘记了(其实是根本就不知道)”。

那么distinct，底层到底是如何实现去重功能的呢？这个是面试spark部分时，经常被问到的问题。

先来看一段代码，我们测试一下distinct去重的作用：

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object SparkDistinct {  
  def main(args: Array[String]): Unit = {    
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkDistinct")    
    val sc: SparkContext = new SparkContext(conf)    //定义一个数组    
    val array: Array[Int] = Array(1,1,1,2,2,3,3,4)    //把数组转为RDD算子,后面的数字2代表分区，也可以指定3，4....个分区，也可以不指定。   
    val line: RDD[Int] = sc.parallelize(array,2)      
    line.distinct().foreach(x => println(x))  //输出的结果已经去重：1，2，3，4 
 }
}

通过上面的代码可以看出，使用distinct以后，会对重复的元素进行去重。我们来看下源码

/**   * Return a new RDD containing the distinct elements in this RDD.   */  
def distinct(numPartitions: Int(implicit ord: Ordering[T] = null): RDD[T] = withScope {    
    map(x => (x, null)).reduceByKey((x, y) => x, numPartitions).map(_._1)  
}  

/**   * Return a new RDD containing the distinct elements in this RDD.   */
def distinct(): RDD[T] = withScope {    
    distinct(partitions.length)  
}

上面是distinct的源码，有带参和无参两种。当我们调用无参的distinct时，底层调用的是如下源码：

def distinct(): RDD[T] = withScope {    
  distinct(partitions.length)  
}

而无参distinct()中又调用了带参数的distinct(partitions.length)。

其中，partitions.length代表是分区数，而这个分区则是我们在使用 sc.parallelize(array,2) 时指定的2个分区。

带参数的distinct其内部就很容易理解了，这就是一个wordcount统计单词的方法，区别是：后者通过元组获取了第一个单词元素。

map(x => (x, null)).reduceByKey((x, y) => x, numPartitions).map(_._1)

其中，numPartitions就是分区数。

我们也可以写成这样：

map(x => (x, null)).reduceByKey((x, y) => x).map(_._1)

也可以这样写：

line.map(x =>(x,1)).reduceByKey(_+_).map(_._1)

通过上面的流程图很清晰的看出来，distinct的原理流程。

使用map算子把元素转为一个带有null的元组；使用reducebykey对具有相同key的元素进行统计；之后再使用map算子，取得元组中的单词元素，实现去重的效果。