spark中aggregateByKey算子详解

参数：(zeroValue:U,[partitioner: Partitioner]) (seqOp: (U, V) => U,combOp: (U, U) => U)

1. 作用：在kv对的RDD中，，按key将value进行分组合并，合并时，将每个value和初始值作为seq函数的参数，进行计算，返回的结果作为一个新的kv对，然后再将结果按照key进行合并，最后将每个分组的value传递给combine函数进行计算（先将前两个value进行计算，将返回结果和下一个value传给combine函数，以此类推），将key与计算结果作为一个新的kv对输出。

2. 参数描述：

（1）zeroValue：给每一个分区中的每一个key一个初始值；

（2）seqOp：函数用于在每一个分区中用初始值逐步迭代value；

（3）combOp：函数用于合并每个分区中的结果。

也就是说，使用aggregateByKey算子，可以先对分区内进行seqOp处理，对于分区键使用combOp处理

比如：

val listRdd: RDD[(String, Int)] = sc.parallelize(List(("a",3),("a",2),("c",4),("b",3),("c",6),("c",8)),2)
listRdd.aggregateByKey(0)((x,y)=>math.max(x, y), (x, y)=>x+y).collect().foreach(println)

分区结果为

listRdd.glom().collect().foreach(x=>println(x.mkString(", ")))
	(a,3), (a,2), (c,4)
	(b,3), (c,6), (c,8)

得到结果

(b,3)
(a,3)
(c,12)

此处有个疑问，key为a的数据只在第一个分区中，key为b的数据只在第二个分区中，那他们怎么计算的？直接+0？

仅凭+运算无法证实，那么再运行combOp为-

val listRdd: RDD[(String, Int)] = sc.parallelize(List(("a",3),("a",2),("c",4),("b",3),("c",6),("c",8)),2)
listRdd.aggregateByKey(0)((x,y)=>math.max(x, y), (x, y)=>x-y).collect().foreach(println)

得到结果

(b,3)
(a,3)
(c,-4)

如果combOp变为y-x结果会不会有变化呢？

val listRdd: RDD[(String, Int)] = sc.parallelize(List(("a",3),("a",2),("c",4),("b",3),("c",6),("c",8)),2)
listRdd.aggregateByKey(0)((x,y)=>math.max(x, y), (x, y)=>y-x).collect().foreach(println)

得到结果

(b,3)
(a,3)
(c,4)

此处可以得出证明，x-y和y-x结果确实，不同，但是如果说一个数据只在一个分区中出现运算时会有0补位，那么a、b的结果就难以解释

为此，我们构造一个combOp函数输出中间的运算过程

def comb(x: Int, y: Int): Int={
    println(s"x:${x},y:${y}")
    x*y
  }
val listRdd: RDD[(String, Int)] = sc.parallelize(List(("a",3),("a",2),("c",4),("b",3),("c",6),("c",8)),2)
listRdd.aggregateByKey(0)((x,y)=>math.max(x, y), (x, y)=>comb(x, y)).collect().foreach(println)

得到结果

(b,3)
(a,3)
(c,32)

以及comb函数的输出：
----------x:4,y:8-------------

这里可以证明，如果一类数据只在一个分区中出现，则comb运算时直接忽略

同理，我们对seqOp进行探索

def comb(x: Int, y: Int): Int={
  println(s"----------x:${x},y:${y}-------------")
  x*y
}
def seqOp(x: Int, y: Int): Int={
  println(s"++++++++++x:${x},y:${y}+++++++++++++")
  math.max(x, y)
}
val listRdd: RDD[(String, Int)] = sc.parallelize(List(("a",3),("a",2),("c",4),("b",3),("c",6),("c",8)),2)
listRdd.aggregateByKey(0)((x,y)=>seqOp(x, y), (x, y)=>comb(x, y)).collect().foreach(println)

结果以及中间结果

(b,3)
(a,3)
(c,32)


++++++++++x:0,y:3+++++++++++++
++++++++++x:0,y:3+++++++++++++
++++++++++x:3,y:2+++++++++++++
++++++++++x:0,y:6+++++++++++++
++++++++++x:0,y:4+++++++++++++
++++++++++x:6,y:8+++++++++++++

----------x:4,y:8-------------

由此可知seqOp的运算会有初始值的参与，但是combOp的运算不会有初始值参与