java - 斯卡拉性能 : Why is this Scala app 30x slower than the equivalent Java app?

Question

我是一名非常精通 C# 的开发人员，但需要开始编写适用于 JVM 的代码。如今，与 C# 相比，Java 语言的功能很差，所以我对 Scala 提供的功能很感兴趣。

但是，当听说在 Scala 中，所有运算符都是简单的方法时，我开始怀疑这会对大量数学计算产生的性能影响(这对于我的团队编写的应用程序类型很重要)

所以我运行了一些简单的基于 int 的测试，发现 Scala 比等效的 Java 代码慢大约 30 倍。不好!谁能告诉我我做错了什么？或者如何提高 scala 示例的计算性能以与 Java 相提并论？

UPDATE1:正如前两个答案所指出的，我是一个 super 菜鸟并在 IntelliJ IDE 中运行它。我不知道如何通过 java 命令行运行 scala 应用程序，这可能是 IntelliJ 问题。感谢大家的帮助，在我继续进行 perf 测试之前，我需要调查 scala 的简单命令行执行，因为 IDE 给出的结果显然太不准确。

UPDATE2:评论中的 Luigi 说在 IntelliJ 中他获得了相同的时间，所以看来我的巨大差异不是因为 IntelliJ？关于这可能是什么的任何其他想法？我将尝试通过命令行运行它并发布更新结果。

更新 3:通过命令行运行后，我得到了相同的 30 倍性能差异。
我的电脑是 3 核 AMD x64 3.4Ghz，运行 J2SE 6 jdk 64 位 1.6.0_31，Window7。

这是我的运行时:Java:210 毫秒。
Scala:在 2000 到 7400 毫秒之间(通常在 7000 毫秒范围内)

所以，我想这个问题仍然悬而未决。为什么 Scala 在我的平台上运行这么慢？ Java 64 位运行时或 Java 6 的东西？

运行时版本:

C:\Users\jason>java -showversion
java version "1.6.0_31"
Java(TM) SE Runtime Environment (build 1.6.0_31-b05)
Java HotSpot(TM) 64-Bit Server VM (build 20.6-b01, mixed mode)

C:\Users\jason>scala
Welcome to Scala version 2.9.1-1 (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_31).

更新 4 虽然我的原始测试有 30 倍的差异，但将迭代次数增加到 100000000 会导致差异缩小到大约 33%，所以我的机器上似乎 scala 仍然被一些未知的初始化成本所支配。我会用评分最高的答案来结束这个，因为我认为我们不会发现性能问题，因为除了我之外没有人看到这个问题:(

*更新 5，解决方案:根据我得到的 2 个答案的帮助，我找到了问题所在，请参阅下面的答案以了解更多详细信息(摘要:第一次调用 System.nanoTime() 需要一个很长一段时间)*

这是我的示例应用程序:

//scala
object HelloWorld {
  //extends Application {
  def main(args: Array[String]) {
    println("hello scala")
    var total: Long = 0
    var i: Long = 0
    var x: Long=0;
    //warm up of the JVM to avoid timing of runtime initialization
    while (i < 100000)
    {
      x=i;
      x += x - 1;
      x -= x + 1;
      x += 1;
      x -= 1;
      total += x;
      i+=1;
    }
    //reset variables
    total = 0
    i = 0;
    //start timing
    var start: Long = System.nanoTime

    //run test
    while (i < 100000) {
      x=i;
      x += x - 1;
      x -= x + 1;
      x += 1;
      x -= 1;

      total += x;
      i+=1;
    }
    var end: Long = System.nanoTime
    System.out.println("ms, checksum = ")
    System.out.println((end - start) / 1000)
    System.out.println(total)
  }
}

这是 java 的等价物，快 30 倍

//java
public class app {
    public static void main(String[] args)
    {
        String message = "hello, java";
        System.out.println(message);
        long total = 0;
        //warm up of the JVM to avoid timing of runtime initialization
        for(long i=0;i< 100000;i++)
        {
            long x=i;
            x+=x-1;
            x-=x+1;
            x++;
            x--;
            total+=x;
        }
        //reset variables
        total = 0;
        //start timing and run test
        long start = System.nanoTime();
        for(long i=0;i< 100000;i++)
        {
            long x=i;
            x+=x-1;
            x-=x+1;
            x++;
            x--;
            total+=x;
        }
        long end = System.nanoTime();
        System.out.println("ms, checksum = ");
        System.out.println((end-start)/1000);
        System.out.println(total);
    }
}

Answer 1

所以，我想我自己找到了答案。

问题出在对 System.nanoTime 的调用中。这样做会产生一些初始化成本(加载 Java 基础库等)，与从 Scala 运行时调用相比，从 Java 运行时调用时加载成本要低得多。

我通过更改 total 的初始值而不是将其设置为来证明这一点

var total: Long = System.nanoTime()

这是在第一个“预热”循环之前添加的，现在这样做会使应用程序的两个版本(Java 和 Scala)同时运行:1000000 次迭代大约需要 2100 次。

感谢你们在这方面的帮助，没有你们的帮助我无法解决这个问题。

ps:我将按原样保留“接受的答案”，因为如果没有他的帮助，我不会找到这个。