performance - Scala隐式类型转换对性能有何影响？

Question

在Scala中，与其他可能的实现选择相比，使用隐式类型转换来增强类的功能是否会对CPU或内存产生重大影响？

例如，考虑一个愚蠢的String操作函数。此实现使用字符串连接:

object Funky {
  def main(args: Array[String]) {
    args foreach(arg => println("Funky " + arg))
  }
}

此实现通过使用隐式类型转换将串联隐藏在成员方法后面:

class FunkyString(str: String) {
  def funkify() = "Funky " + str
}

object ImplicitFunky {
  implicit def asFunkyString(str: String) = new FunkyString(str)

  def main(args: Array[String]) {
    args foreach(arg => println(arg.funkify()))
  }
}

两者都做同样的事情:

scala> Funky.main(Array("Cold Medina", "Town", "Drummer"))        
Funky Cold Medina
Funky Town
Funky Drummer

scala> ImplicitFunky.main(Array("Cold Medina", "Town", "Drummer"))
Funky Cold Medina
Funky Town
Funky Drummer

性能上有区别吗？一些注意事项:

Scala是否内联到asFunkyString方法的隐式调用？

Scala是否实际上为每个arg创建一个新的包装器FunkyString对象，还是可以优化掉多余的对象分配？

假设FunkyString具有3种不同的方法(funkify1，funkify2和funkify3)，并且foreach的主体依次调用每个方法:

println(arg.funkify1())
println(arg.funkify2())
println(arg.funkify3())

Scala会重复执行3次转换，还是会优化多余的转换并为每次循环迭代执行一次？

假设我明确地在另一个变量中捕获了转换，如下所示:

val fs = asFunkyString(arg)
println(fs.funkify1())
println(fs.funkify2())
println(fs.funkify3())

这会改变情况吗？

实际上，隐式转换的广泛使用是否是潜在的性能问题，还是通常无害？

Answer 1

我尝试使用出色的Scala-Benchmark-Template设置微基准测试。

编写一个仅测试隐式转换的有意义的基准(未经JIT优化)非常困难，因此我不得不增加一些开销。

这是代码:

class FunkyBench extends SimpleScalaBenchmark {
  val N = 10000
  def timeDirect( reps: Int ) = repeat(reps) {
    var strs = List[String]()
    var s = "a"
    for( i <- 0 until N ) {
      s += "a"
      strs ::= "Funky " + s 
    }
    strs
  }
  def timeImplicit( reps: Int ) = repeat(reps) {
    import Funky._
    var strs = List[String]()
    var s = "a"
    for( i <- 0 until N ) {
      s += "a"
      strs ::= s.funkify
    }
    strs
  }
}

结果如下:

[info] benchmark  ms linear runtime
[info]    Direct 308 =============================
[info]  Implicit 309 ==============================

我的结论:在任何非平凡的代码段中，隐式转换(对象创建)的影响都是无法衡量的。

编辑:我使用了scala 2.9.0和Java 1.6.0_24(在服务器模式下)