Scala深海奇遇记-当case class遇到了Spark的聚集函数

自从知道有case class这个东西以后,一直都比较常用这个东西。但是,最近在测试的时候,突然发现,其实这个东西并不简单,它导致了一个看起来很无厘头的错误,并且花了我两天的时间来调试。

在这篇文章里,我会详细记录调试的过程,以及结论。

致谢

在调试的过程中,得到了我们Hadoop组老大,项目组老大,以及其他同事的深度支持与帮助,非常感谢他们。

结论

先说结论。如果有朋友不感兴趣,不想深究原理,只是想知道怎么用,可以跳过后面的部分。

不要把case class放在class里面。例如:

class Test {

  case class A(a: String)

}

可以放到object里面,或者放到package里面。例如:

object Test {

  case class A(a: String)

}

或者

package Test {

  case class A(a: String)

}

如果不遵循这条原则,那么有极大的概率,Spark在执行的时候,相同的key并不会聚集到一起。

分析

首先,我们有如下代码:

package org.apache.spark.test

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

import scala.util.Random

object VerifySparkBug {

  def main(args: Array[String]): Unit = {
    new VerifySparkBug().run()
  }

}

class VerifySparkBug extends Serializable {

  def run() = {

    val sparkConf = new SparkConf()
    sparkConf.setMaster("local")
    sparkConf.setAppName("VerifySparkBug")
    val sparkContext = new SparkContext(sparkConf)

    val inputRDD = sparkContext.parallelize(Seq(
      (UidAndPartition("1", "2"), 1L),
      (UidAndPartition("1", "1"), 1L),
      (UidAndPartition("1", "3"), 1L),
      (UidAndPartition("2", "1"), 1L),
      (UidAndPartition("2", "2"), 1L),
      (UidAndPartition("3", "3"), 1L)
    )).partitionBy(new RandomPartitioner(10))

    inputRDD.foreachPartition {
      case iterator => {
        val partitionId = new Random().nextInt()
        while (iterator.hasNext) {
          val item = iterator.next()
          System.out.println("------ inputRDD partitionId: " + partitionId
            + ", key: " + item._1
            + ", hash:" + item._1.hashCode()
            + ",value: " + item._2)
        }
      }
    }

    val uidRDD = inputRDD.map{
      case pair => {
        (Uid(pair._1.uid), pair._2)
      }
    }

    uidRDD.foreachPartition {
      case iterator => {
        val partitionId = new Random().nextInt()
        while (iterator.hasNext) {
          val item = iterator.next()
          System.out.println("------ uidRDD partitionId: " + partitionId
            + ", key: " + item._1
            + ", hash:" + item._1.hashCode()
            + ",value: " + item._2)
        }
      }
    }

    val result = uidRDD.aggregateByKey(0L)(
      (counter: Long, number: Long) => {
        counter + number
      },
      (counter1: Long, counter2: Long) => {
        counter1 + counter2
      }
    ).collect()

    for (pair <- result) {
      System.out.println("------ key: " + pair._1 + ", uv: " + pair._2)
    }

  }

  case class UidAndPartition(uid: String, partition: String)

  case class Uid(idType: String)
}

class RandomPartitioner(partitions: Int) extends Partitioner {
  override def numPartitions: Int = partitions

  override def getPartition(key: Any): Int = {
    new Random().nextInt(partitions)
  }
}

它的输出如下:

------ key: Uid(1), uv: 1
------ key: Uid(1), uv: 1
------ key: Uid(1), uv: 1
------ key: Uid(3), uv: 1
------ key: Uid(2), uv: 1
------ key: Uid(2), uv: 1

很诡异,对吧?明明key相同,却并没有被聚合到一起。而且,更诡异的是,key相同的hash值也相同。

猜想1

开始,我们怀疑是case class虽然默认实现了Serializable接口,但是并没有生成serialVersionUID,所以在序列化以及反序列化时,生成的类其实并不是同一个。导致反序列化出来的对象不是同一个。

反编译后的Uid的部分代码如下:

于是,我就用Netty写了一个服务器端和客户端的程序,来测试这个问题:

服务器端:

package org.apache.spark.test

import java.io._

import io.netty.bootstrap.ServerBootstrap
import io.netty.buffer.ByteBuf
import io.netty.channel.{ChannelHandlerContext, ChannelInboundHandlerAdapter, ChannelInitializer, SimpleChannelInboundHandler}
import io.netty.channel.nio.NioEventLoopGroup
import io.netty.channel.socket.nio.{NioServerSocketChannel, NioSocketChannel}
import org.apache.spark.test.VerifySparkBug.Uid

object ServerForCaseClassEquals {

  def main(args: Array[String]): Unit = {

    val serverBootstrap = new ServerBootstrap()
    val bossEventLoopGroup = new NioEventLoopGroup()
    val workerEventLoopGroup = new NioEventLoopGroup()

    serverBootstrap.group(bossEventLoopGroup, workerEventLoopGroup)
      .channel(classOf[NioServerSocketChannel])
      .childHandler(new ChannelInitializer[NioSocketChannel] {
        override def initChannel(c: NioSocketChannel) = {
          c.pipeline().addLast(new ChannelInboundHandlerAdapter {
            override def channelRead(ctx: ChannelHandlerContext, msg: scala.Any): Unit = {
              val byteBuf = msg.asInstanceOf[ByteBuf]
              val length = byteBuf.readInt()
              val bytes = new Array[Byte](length)
              byteBuf.readBytes(bytes)

              val byteInputStream = new ByteArrayInputStream(bytes)
              val objectInputStream = new ObjectInputStream(byteInputStream)

              println(objectInputStream.readObject() == Uid("a"))

            }
          })
        }
      })
      .bind(8000)

  }

}

客户端:

package org.apache.spark.test

import java.io.{ByteArrayOutputStream, ObjectOutputStream}

import io.netty.bootstrap.Bootstrap
import io.netty.channel.nio.NioEventLoopGroup
import io.netty.channel.socket.nio.NioSocketChannel
import io.netty.channel.{ChannelHandlerContext, ChannelInboundHandlerAdapter, ChannelInitializer}
import org.apache.spark.test.VerifySparkBug.Uid

object ClientForCaseClassEquals {

  def main(args: Array[String]): Unit = {

    val bootstrap = new Bootstrap()
    val eventLoopGroup = new NioEventLoopGroup()

    bootstrap.group(eventLoopGroup)
      .channel(classOf[NioSocketChannel])
      .handler(new ChannelInitializer[NioSocketChannel] {
        override def initChannel(c: NioSocketChannel) = {
          c.pipeline().addLast(new ChannelInboundHandlerAdapter {
            override def channelActive(ctx: ChannelHandlerContext): Unit = {
              val uid = Uid("a")
              val byteArrayOutputStream = new ByteArrayOutputStream()
              val objectOutputStream = new ObjectOutputStream(byteArrayOutputStream)

              objectOutputStream.writeObject(uid)

              objectOutputStream.close()

              val bytes = byteArrayOutputStream.toByteArray

              val byteBuf = ctx.alloc().buffer()
              byteBuf.writeInt(bytes.length)
              byteBuf.writeBytes(bytes)

              ctx.channel().writeAndFlush(byteBuf)
            }
          })
        }
      })
      .connect("localhost", 8000)

  }

}

而这个测试自然失败了。测试的结果是,反序列化解析出来的对象,是==反序列化之前的对象的。

为什么用==?因为在scala中,==其实就是equals()方法的语法糖。而且,spark的代码中,聚合函数中,对key进行比较时,也是用的==

其实这种假设根本就经不起推敲。

如果序列化和反序列的时候,类不是一个,即serialVersionUID不同,那么,其实反序列化是不会成功的,它是会直接报错的。而我们的程序中并没有报错。说明其实是同一个。

那么既然case class在生成的时候,并没有生成serialVersionUID。那我们怎么能够确定,在运行的时候,即使是在不同的节点,不同的JVM上,它们就是同一个呢?这个问题,在Java Specification中的序列化和反序列化部分有详细描述。总之,就是根据类的相关信息,生成一个serialVersionUID。由于这个信息跟内存地址无关,所以即使是运行时生成,也是唯一且相同的。

猜想2

这个假设给推掉了。为了复现这个问题,我写了如下代码,打算来进行复现。上面的代码是最终版的复现版本。在下面的代码中,虽然问题看似得到了复现,实际上是完全不同的问题。

package org.apache.spark.test

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

import scala.util.Random

object VerifySparkBug {

  def main(args: Array[String]): Unit = {
    new VerifySparkBug().run()
  }

}

class VerifySparkBug extends Serializable {

  def run() = {

    val sparkConf = new SparkConf()
    sparkConf.setMaster("local")
    sparkConf.setAppName("VerifySparkBug")
    val sparkContext = new SparkContext(sparkConf)

    val inputRDD = sparkContext.parallelize(Seq(
      (UidAndPartition("1", "2"), 1L),
      (UidAndPartition("1", "1"), 1L),
      (UidAndPartition("1", "3"), 1L),
      (UidAndPartition("2", "1"), 1L),
      (UidAndPartition("2", "2"), 1L),
      (UidAndPartition("3", "3"), 1L)
    ))

    inputRDD.foreachPartition {
      case iterator => {
        val partitionId = new Random().nextInt()
        while (iterator.hasNext) {
          val item = iterator.next()
          System.out.println("------ inputRDD partitionId: " + partitionId
            + ", key: " + item._1
            + ", hash:" + item._1.hashCode()
            + ",value: " + item._2)
        }
      }
    }

    val uidRDD = inputRDD.map{
      case pair => {
        (Uid(pair._1.uid), pair._2)
      }
    }.partitionBy(new RandomPartitioner(10))

    uidRDD.foreachPartition {
      case iterator => {
        val partitionId = new Random().nextInt()
        while (iterator.hasNext) {
          val item = iterator.next()
          System.out.println("------ uidRDD partitionId: " + partitionId
            + ", key: " + item._1
            + ", hash:" + item._1.hashCode()
            + ",value: " + item._2)
        }
      }
    }

    val result = uidRDD.aggregateByKey(0L)(
      (counter: Long, number: Long) => {
        counter + number
      },
      (counter1: Long, counter2: Long) => {
        counter1 + counter2
      }
    ).collect()

    for (pair <- result) {
      System.out.println("------ key: " + pair._1 + ", uv: " + pair._2)
    }

  }

  case class UidAndPartition(uid: String, partition: String)

  case class Uid(idType: String)
}

class RandomPartitioner(partitions: Int) extends Partitioner {
  override def numPartitions: Int = partitions

  override def getPartition(key: Any): Int = {
    new Random().nextInt(partitions)
  }
}

代码跟上面的很相似,只是partitionBy()的位置变了一下。

初衷很简单,因为我们并不能保证相同的Uid会在同一个partition,于是就通过RandomPartitioner来模拟随机分区的效果。

这段代码的问题是,如果在进行聚集(如aggregateByKey, reduceByKey等)之前,你有进行过partitionBy操作,那么,Spark会认为,你已经将相同的Key放到一个分区了,所以它在进行聚集的时候,是不会考虑聚集不同partition上,相同的key的情况的。

我们通过调试聚集函数通用的PairRDDFunctions.combineByKeyWithClassTag方法,就能看到这个结论:

我们看到,如果聚集函数前面刚好调用了partitionBy方法,聚集函数内部是不会调用partitionBy来将相同的Key分到一个分区的。

这是因为partitionBy以及聚集函数,其实都是ShuffleDependency。Spark内部做了优化,如果ShuffleDependency前面已经是Narrow Dependency了,那么就会把这个ShuffleDependency转换成Narrow Dependency

所以上面看似正确的复现,实际上刚好走进了这个陷阱里面。

那么,上面的代码,如果考虑到这个问题,该怎么解决?一种方案是,通过HashPartitioner,将相同的key确实分到同一个分区里面去。另一种方法就是,在上面的代码中的partitionBy(new RandomPartitioner(10)) 后面,加一个map(r => r)。 为什么加个这个就会生效?

我们先看map() 函数,以及MapPartitionRDD的代码。

我们可以看到,map()函数,实际上是生成了一个没有partitioner的MapPartitionRDD。就是这个没有partitioner,帮了我们的大忙。没有partitioner,聚集函数就不知道前面是Narrow Dependency,所以就会考虑相同的key在不同分区的问题。

下面这张图片,是我采用第二种方式,调试的过程。可以看到,现在走的是ShuffleRDD

然后,我们可以看到,丫的,相同的key还是没有被聚集到一起。

其实当时在写这个复现的Demo的时候,是聚到一起了,一度手舞足蹈。但是聚到一起的原因,是case class是放在Object里面了,没有放到class里,所以并没有正确的复现问题。

猜想3

采用猜想2中的第1种方法,我们把不同分区中,相同的Key放到同一个分区里,有如下代码:

package org.apache.spark.test

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

import scala.util.Random

object VerifySparkBug {

  def main(args: Array[String]): Unit = {
    new VerifySparkBug().run()
  }

}

class VerifySparkBug extends Serializable {

  def run() = {

    val sparkConf = new SparkConf()
    sparkConf.setMaster("local")
    sparkConf.setAppName("VerifySparkBug")
    val sparkContext = new SparkContext(sparkConf)

    val inputRDD = sparkContext.parallelize(Seq(
      (UidAndPartition("1", "2"), 1L),
      (UidAndPartition("1", "1"), 1L),
      (UidAndPartition("1", "3"), 1L),
      (UidAndPartition("2", "1"), 1L),
      (UidAndPartition("2", "2"), 1L),
      (UidAndPartition("3", "3"), 1L)
    ))

    inputRDD.foreachPartition {
      case iterator => {
        val partitionId = new Random().nextInt()
        while (iterator.hasNext) {
          val item = iterator.next()
          System.out.println("------ inputRDD partitionId: " + partitionId
            + ", key: " + item._1
            + ", hash:" + item._1.hashCode()
            + ",value: " + item._2)
        }
      }
    }

    val uidRDD = inputRDD.map{
      case pair => {
        (Uid(pair._1.uid), pair._2)
      }
    }.partitionBy(new RandomPartitioner(10)).partitionBy(new HashPartitioner(10))

    uidRDD.foreachPartition {
      case iterator => {
        val partitionId = new Random().nextInt()
        while (iterator.hasNext) {
          val item = iterator.next()
          System.out.println("------ uidRDD partitionId: " + partitionId
            + ", key: " + item._1
            + ", hash:" + item._1.hashCode()
            + ",value: " + item._2)
        }
      }
    }

    val result = uidRDD.aggregateByKey(0L)(
      (counter: Long, number: Long) => {
        counter + number
      },
      (counter1: Long, counter2: Long) => {
        counter1 + counter2
      }
    ).collect()

    for (pair <- result) {
      System.out.println("------ key: " + pair._1 + ", uv: " + pair._2)
    }

  }

  case class UidAndPartition(uid: String, partition: String)

  case class Uid(idType: String)
}

class RandomPartitioner(partitions: Int) extends Partitioner {
  override def numPartitions: Int = partitions

  override def getPartition(key: Any): Int = {
    new Random().nextInt(partitions)
  }
}

其实这些代码差距很小,用文本比较工具,很容易看出差距。

在运行这个过程中,我们发现,丫的,把它们放到同一个分区,还是不能聚到一起?太他么过分了。

于是,我们查看聚集函数中,是如何比较key的。

我们可以看到,是调用equals方法。

于是,我们就想,case class的equals方法,到底长什么样子?

这里有一点很坑,就是你看反编译出来的代码,在这里是会反编译错误的。你必须找其他的方式来看。我们采用的方式,是看Scala编译的中间结果。

运行scalac -Xprint:typer VerifySparkBug.scala,我们能看到,上面的代码中,Uid的equals()方法,scala会被编译成这种形式:

override  def equals(x$1: Any): Boolean = Uid.this.eq(x$1.asInstanceOf[Object]).||(x$1 match {
  case (_: VerifySparkBug.this.Uid) => true
  case _ => false
}.&&({
         val Uid$1: VerifySparkBug.this.Uid = x$1.asInstanceOf[VerifySparkBug.this.Uid];
        Uid.this.idType.==(Uid$1.idType).&&(Uid$1.canEqual(Uid.this))
      }))
    };

我们再来看看,把Uid放到Object里面,生成的equals方法是什么样子。

代码如下:

package org.apache.spark.test

import org.apache.spark.test.VerifySparkBug.{Uid, UidAndPartition}
import org.apache.spark.{HashPartitioner, Partitioner, SparkConf, SparkContext}

import scala.util.Random

object VerifySparkBug {

  def main(args: Array[String]): Unit = {
    new VerifySparkBug().run()
  }

  case class UidAndPartition(uid: String, partition: String)

  case class Uid(idType: String)
}

class VerifySparkBug extends Serializable {

  def run() = {

    val sparkConf = new SparkConf()
    sparkConf.setMaster("local")
    sparkConf.setAppName("VerifySparkBug")
    val sparkContext = new SparkContext(sparkConf)

    val inputRDD = sparkContext.parallelize(Seq(
      (UidAndPartition("1", "2"), 1L),
      (UidAndPartition("1", "1"), 1L),
      (UidAndPartition("1", "3"), 1L),
      (UidAndPartition("2", "1"), 1L),
      (UidAndPartition("2", "2"), 1L),
      (UidAndPartition("3", "3"), 1L)
    ))

    inputRDD.foreachPartition {
      case iterator => {
        val partitionId = new Random().nextInt()
        while (iterator.hasNext) {
          val item = iterator.next()
          System.out.println("------ inputRDD partitionId: " + partitionId
            + ", key: " + item._1
            + ", hash:" + item._1.hashCode()
            + ",value: " + item._2)
        }
      }
    }

    val uidRDD = inputRDD.map{
      case pair => {
        (Uid(pair._1.uid), pair._2)
      }
    }.partitionBy(new RandomPartitioner(10)).partitionBy(new HashPartitioner(10))

    uidRDD.foreachPartition {
      case iterator => {
        val partitionId = new Random().nextInt()
        while (iterator.hasNext) {
          val item = iterator.next()
          System.out.println("------ uidRDD partitionId: " + partitionId
            + ", key: " + item._1
            + ", hash:" + item._1.hashCode()
            + ",value: " + item._2)
        }
      }
    }

    val result = uidRDD.aggregateByKey(0L)(
      (counter: Long, number: Long) => {
        counter + number
      },
      (counter1: Long, counter2: Long) => {
        counter1 + counter2
      }
    ).collect()

    for (pair <- result) {
      System.out.println("------ key: " + pair._1 + ", uv: " + pair._2)
    }

  }

}

class RandomPartitioner(partitions: Int) extends Partitioner {
  override def numPartitions: Int = partitions

  override def getPartition(key: Any): Int = {
    new Random().nextInt(partitions)
  }
}

生成的equals()方法如下:

override  def equals(x$1: Any): Boolean = Uid.this.eq(x$1.asInstanceOf[Object]).||(x$1 match {
  case (_: org.apache.spark.test.VerifySparkBug.Uid) => true
  case _ => false
}.&&({
         val Uid$1: org.apache.spark.test.VerifySparkBug.Uid = x$1.asInstanceOf[org.apache.spark.test.VerifySparkBug.Uid];
        Uid.this.idType.==(Uid$1.idType).&&(Uid$1.canEqual(Uid.this))
      }))
    };

我们可以看到,它们的区别,就在于放在class中的Uid,调用的是VerifySparkBug.this.Uid。而放在object中的Uid,调用的是com.hyper.cdp.label.spark.test.VerifySparkBug.Uid。后者很容易理解,它肯定是唯一且相同的。但是前者呢?它包含了一个VerifySparkBug.this啊。

那么什么是VerifySparkBug.this呢?我也不清楚。但是我写了一个Demo,验证了一个事实,对于每一个VerifySparkBug实例,它们的值都是不同的。

代码如下:

package org.apache.spark.test

class VerifyCaseClassInClass {

    case class Test(a: String)

    def test() = {
        println(VerifyCaseClassInClass.this)
    }
}

object VerifyCaseClassInClass {

    def main(args: Array[String]): Unit = {

        println(new VerifyCaseClassInClass().Test("a").equals(new VerifyCaseClassInClass().Test("a")))

        new VerifyCaseClassInClass().test()
        new VerifyCaseClassInClass().test()

    }

}

这就很容易解释为什么case class在Class中时,即使Key相同,仍然不会不会聚到一起了。

在Shuffle的时候,对于收到的其他分区的Key,肯定是为每个分区都new一个VerifySparkBug。这样就导致看起来相同的key,即使它们的hash值也一样,但是就是聚不到一起。

case class的hashCode()方法倒是很中立,它跟内存地址等都无关。只要字段的值一样,生成的hash就相同。感兴趣的读者可以自行查看scala.runtime.ScalaRunTime._hashCode这个方法。

这次调试,也深刻验证了,两个对象的hashcode相同,它们却不一定equals这一个简单却并没有重视过的问题。

最终,能够正常工作的代码如下:

package org.apache.spark.test

import org.apache.spark.test.VerifySparkBug.{Uid, UidAndPartition}
import org.apache.spark.{HashPartitioner, Partitioner, SparkConf, SparkContext}

import scala.util.Random

object VerifySparkBug {

  def main(args: Array[String]): Unit = {
    new VerifySparkBug().run()
  }

  case class UidAndPartition(uid: String, partition: String)

  case class Uid(idType: String)
}

class VerifySparkBug extends Serializable {

  def run() = {

    val sparkConf = new SparkConf()
    sparkConf.setMaster("local")
    sparkConf.setAppName("VerifySparkBug")
    val sparkContext = new SparkContext(sparkConf)

    val inputRDD = sparkContext.parallelize(Seq(
      (UidAndPartition("1", "2"), 1L),
      (UidAndPartition("1", "1"), 1L),
      (UidAndPartition("1", "3"), 1L),
      (UidAndPartition("2", "1"), 1L),
      (UidAndPartition("2", "2"), 1L),
      (UidAndPartition("3", "3"), 1L)
    ))

    inputRDD.foreachPartition {
      case iterator => {
        val partitionId = new Random().nextInt()
        while (iterator.hasNext) {
          val item = iterator.next()
          System.out.println("------ inputRDD partitionId: " + partitionId
            + ", key: " + item._1
            + ", hash:" + item._1.hashCode()
            + ",value: " + item._2)
        }
      }
    }

    val uidRDD = inputRDD.map{
      case pair => {
        (Uid(pair._1.uid), pair._2)
      }
    }.partitionBy(new RandomPartitioner(10)).partitionBy(new HashPartitioner(10))

    uidRDD.foreachPartition {
      case iterator => {
        val partitionId = new Random().nextInt()
        while (iterator.hasNext) {
          val item = iterator.next()
          System.out.println("------ uidRDD partitionId: " + partitionId
            + ", key: " + item._1
            + ", hash:" + item._1.hashCode()
            + ",value: " + item._2)
        }
      }
    }

    val result = uidRDD.aggregateByKey(0L)(
      (counter: Long, number: Long) => {
        counter + number
      },
      (counter1: Long, counter2: Long) => {
        counter1 + counter2
      }
    ).collect()

    for (pair <- result) {
      System.out.println("------ key: " + pair._1 + ", uv: " + pair._2)
    }

  }

}

class RandomPartitioner(partitions: Int) extends Partitioner {
  override def numPartitions: Int = partitions

  override def getPartition(key: Any): Int = {
    new Random().nextInt(partitions)
  }
}

你可能感兴趣的:(Scala深海奇遇记-当case class遇到了Spark的聚集函数)