spark mapPartition方法与map方法的区别 以及 join的用法

转载：http://wanshi.iteye.com/blog/2183906 

rdd的mapPartitions是map的一个变种，它们都可进行分区的并行处理。

    两者的主要区别是调用的粒度不一样：map的输入变换函数是应用于RDD中每个元素，而mapPartitions的输入函数是应用于每个分区。

    假设一个rdd有10个元素，分成3个分区。如果使用map方法，map中的输入函数会被调用10次；而使用mapPartitions方法的话，其输入函数会只会被调用3次，每个分区调用1次。

   

    //生成10个元素3个分区的rdd a，元素值为1~10的整数（1 2 3 4 5 6 7 8 9 10），sc为SparkContext对象

    val a = sc.parallelize(1 to 10, 3)

    //定义两个输入变换函数，它们的作用均是将rdd a中的元素值翻倍

    //map的输入函数，其参数e为rdd元素值   

    def myfuncPerElement(e:Int):Int = {

           println("e="+e)

           e*2

      }

     //mapPartitions的输入函数。iter是分区中元素的迭代子，返回类型也要是迭代子

    def myfuncPerPartition ( iter : Iterator [Int] ) : Iterator [Int] = {

         println("run in partition")

         var res = for (e <- iter ) yield e*2

          res

    }

    

    val b = a.map(myfuncPerElement).collect

    val c =  a.mapPartitions(myfuncPerPartition).collect

    在spark shell中运行上述代码，可看到打印了3次run in partition，打印了10次e=。

 

      从输入函数（myfuncPerElement、myfuncPerPartition）层面来看，map是推模式，数据被推到myfuncPerElement中；mapPartitons是拉模式，myfuncPerPartition通过迭代子从分区中拉数据。

 

    这两个方法的另一个区别是在大数据集情况下的资源初始化开销和批处理处理，如果在myfuncPerPartition和myfuncPerElement中都要初始化一个耗时的资源，然后使用，比如数据库连接。在上面的例子中，myfuncPerPartition只需初始化3个资源（3个分区每个1次），而myfuncPerElement要初始化10次（10个元素每个1次），显然在大数据集情况下（数据集中元素个数远大于分区数），mapPartitons的开销要小很多，也便于进行批处理操作。

    

   mapPartitionsWithIndex和mapPartitons类似，只是其参数多了个分区索引号

转载http://dongxicheng.org/framework-on-yarn/apache-spark-join-two-tables/

在大数据处理场景中，多表Join是非常常见的一类运算。为了便于求解，通常会将多表join问题转为多个两表连接问题。两表Join的实现算法非常多，一般我们会根据两表的数据特点选取不同的join算法，其中，最常用的两个算法是map-side join和reduce-side join。本文将介绍如何在apache spark中实现这两种算法。

（1）Map-side Join

Map-side Join使用场景是一个大表和一个小表的连接操作，其中，“小表”是指文件足够小，可以加载到内存中。该算法可以将join算子执行在Map端，无需经历shuffle和reduce等阶段，因此效率非常高。

在Hadoop MapReduce中， map-side join是借助DistributedCache实现的。DistributedCache可以帮我们将小文件分发到各个节点的Task工作目录下，这样，我们只需在程序中将文件加载到内存中（比如保存到Map数据结构中），然后借助Mapper的迭代机制，遍历另一个大表中的每一条记录，并查找是否在小表中，如果在则输出，否则跳过。

在Apache Spark中，同样存在类似于DistributedCache的功能，称为“广播变量”（Broadcast variable）。其实现原理与DistributedCache非常类似，但提供了更多的数据/文件广播算法，包括高效的P2P算法，该算法在节点数目非常多的场景下，效率远远好于DistributedCache这种基于HDFS共享存储的方式，具体比较可参考“Performance and Scalability of Broadcast in Spark”。使用MapReduce DistributedCache时，用户需要显示地使用File API编写程序从本地读取小表数据，而Spark则不用，它借助Scala语言强大的函数闭包特性，可以隐藏数据/文件广播过程，让用户编写程序更加简单。

假设两个文件，一小一大，且格式类似为：

Key,value,value

Key,value,value

则利用Spark实现map-side的算法如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

vartable1= sc.textFile(args(1))

vartable2= sc.textFile(args(2))

 

// table1 is smaller, so broadcast it as a map<String, String>

varpairs =table1.map { x =>

  varpos =x.indexOf(',')

  (x.substring(0, pos), x.substring(pos + 1))

}.collectAsMap

varbroadCastMap =sc.broadcast(pairs) //save table1 as map, and broadcast it

 

// table2 join table1 in map side

varresult =table2.map { x =>

  varpos =x.indexOf(',')

  (x.substring(0, pos), x.substring(pos + 1))

}.mapPartitions({ iter =>

  varm =broadCastMap.value

  for{

    (key, value) <- iter

    if(m.contains(key))

  }yield(key, (value, m.get(key).getOrElse("")))

})

 

result.saveAsTextFile(args(3))//save result to local file or HDFS

（2）Reduce-side Join

当两个文件/目录中的数据非常大，难以将某一个存放到内存中时，Reduce-side Join是一种解决思路。该算法需要通过Map和Reduce两个阶段完成，在Map阶段，将key相同的记录划分给同一个Reduce Task（需标记每条记录的来源，便于在Reduce阶段合并），在Reduce阶段，对key相同的进行合并。

Spark提供了Join算子，可以直接通过该算子实现reduce-side join，但要求RDD中的记录必须是pair，即RDD[KEY, VALUE]，同样前一个例利用Reduce-side join实现如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

vartable1= sc.textFile(args(1))

vartable2= sc.textFile(args(2))

 

varpairs =table1.map{x=>

  varpos =x.indexOf(',')

  (x.substring(0, pos), x.substring(pos + 1))

}

 

varresult =table2.map{x=>

  varpos =x.indexOf(',')

  (x.substring(0, pos), x.substring(pos + 1))

}.join(pairs)

 

result.saveAsTextFile(args(3))

（3）总结

本文介绍了Spark中map-side join和reduce-side join的编程思路，希望对大家有借鉴意义。但需要注意的是，在使用这两种算法处理较大规模的数据时，通常需要对多个参数进行调优，否则可能会产生OOM问题。通常需要调优的相关参数包括，map端数据输出buffer大小，reduce端数据分组方法（基于map还是基于sort），等等。

（4）两个问题

问题1：如果在map-side join中，不使用以下语句对文件1进行广播，

var broadCastMap = sc.broadcast(pairs)也可以在后面程序中直接使用变量pairs存储的数据进行join，这两种方式有什么异同，性能会有何不同？问题2：将map-side join中的以下语句：
1
2
3
4
5
6
mapPartitions({ iter =>
  var m = broadCastMap.value
  for{
    (key, value) <- iter
    if(m.contains(key))
  } yield (key, (value, m.get(key).getOrElse("")))
改为：
1
2
3
4
var m = broadCastMap.value //这一句放在var table2 = sc.textFile(args(2))后面
map {case (key, value) =>
  if(m.contains(key)) (key, (value, m.get(key).getOrElse("")))
}