自动装箱比自定义包装类型的性能更好吗？

Question

如果我有一个泛型参数，我通过模式匹配到基元（如 Int）来解析该参数，那么自动装箱是否比使用自定义包装器类型便宜？例如

def test[A](x: A): Int = x match {
  case i: Int => i
  case _ => -1
}

对抗

case class NumChannels(value: Int)

def test[A](x: A): Int = x match {
  case n: NumChannels => n.value
  case _ => -1
}

第一种方法是否提供任何性能优势？如果该方法使用any代替，这种情况是否相同：

def test(x: Any): Int = ...

?

Answer 1

如果您正在查看javap的输出（仅查看不同的部分）：

• 使用Int的版本：

 10: invokestatic  #17                 // Method scala/runtime/BoxesRunTime.unboxToInt:(Ljava/lang/Object;)I
 13: istore_3      
 14: iload_3       

< li >使用< code>NumChannels的版本:

  10: checkcast     #12                 // class app/benchmark/scala/benchmark3b/NumChannels
  13: astore_3      
  14: aload_3       
  15: invokevirtual #16                 // Method app/benchmark/scala/benchmark3b/NumChannels.value:()I

人们可以假设第一个版本应该更快。使用“任何”的第三个版本将与第一个版本相同。

然而，使用JMH的微观基准测试并没有显示出真正的区别：

Benchmark                             Mode   Samples         Mean   Mean error    Units 
a.b.s.benchmark3a.Benchmark3a.run    thrpt         5       42,352        0,480   ops/ms 
a.b.s.benchmark3b.Benchmark3b.run    thrpt         5       42,793        1,439   ops/ms 

使用甲骨文JDK 1.8，Scala 2.10.3，Linux 32位。

第一个基准：

@State(Scope.Benchmark)
object BenchmarkState {
  final val n = 10000

  val input = 
    Array.range(0, n).map {
      n =>
        if (n % 2 == 0) {
          n
        } else {
          "" + n
        }
    }
}

class Benchmark3a {
  def test[A](x: A): Int = x match {
    case i: Int => i
    case _ => -1
  }

  @GenerateMicroBenchmark
  def run() = {
    var sum = 0
    var i = 0
    while (i < BenchmarkState.n) {
      sum += test(BenchmarkState.input(i))
      i +=1
    }
    sum
  }
}

第二基准

case class NumChannels(value: Int)

@State(Scope.Benchmark)
object BenchmarkState {
  final val n = 10000

  val input = 
    Array.range(0, n).map {
      n =>
        if (n % 2 == 0) {
          NumChannels(n)
        } else {
          "" + n
      }
    }
}

class Benchmark3b {
  def test[A](x: A): Int = x match {
    case n: NumChannels => n.value
    case _ => -1
  }

  @GenerateMicroBenchmark
  def run() = {
    var sum = 0
    var i = 0
    while (i < BenchmarkState.n) {
      sum += test(BenchmarkState.input(i))
      i +=1
    }
    sum
  }
}

在以前的版本中，我使用了< code>Seq和方法< code>map和< code>sum，两个版本的性能相当，但它们只能实现大约4 ops/ms。

即使在期间使用Array和也不会揭示真正的区别。

所以我认为这个(孤立的)API设计决策不会影响性能。

资源

< li >如何将JMH与sbt一起用于Scala基准测试？(我使用了所选答案中描述的设置)