【GO语言】简单测试下，Go打不过Java，Why？

本文链接：https://blog.youkuaiyun.com/PxFuture/article/details/144227890

文章目录

起因，最近github上火了一个非常简单的测试项目， Go完全打不过 Java和 Kotlin，且作者没有给 .net的结果：
基准代码： bddicken/languages: Compare languages
测试结果： benjdd.com/languages/

十亿次双层嵌套循环测试结果

语言	耗时
C/clang -03	0.50s
Rust	0.50s
Java	0.54s
Kotlin	0.56s
Go	0.80s
Node.js	1.03s
Dart	1.34s
PyPy	1.53s
PHP	9.93s
Python	74.42s

递归斐波那契数列生成（S₄₀=F₄₀−1）结果

语言	耗时
C/clang -03	0.40s
Rust	0.41s
Java	0.48s
Kotlin	0.49s
Go	0.87s
Node.js	1.11s
Dart	0.78s
PyPy	2.75s
PHP	10.85s
Python	29.00s

测试环境

m3 mbp 16g

Clang version: Apple clang version 16.0.0 (clang-1600.0.26.4)
R version: Rscript ® version 4.4.2 (2024-10-31)
Kotlin version: kotlinc-jvm 2.0.21 (JRE 23.0.1)
Java version: javac 23.0.1
Rust version: cargo 1.82.0
Node version: v22.11.0
Python version: 3.9.6
PHP version: 8.3.13
Dart version: 3.5.4
Go version: 1.21.2
PyPy: 7.3.17

循环测试Golang为什么慢，如何优化

package main // 基准测试代码
import (
    "fmt"
    "math/rand"
    "strconv"
    "os"
)

func main() {
  input, e := strconv.Atoi(os.Args[1]) // Get an input number from the command line
  if e != nil { panic(e) }
  u := int32(input)
  r := int32(rand.Intn(10000))           // Get a random number 0 <= r < 10k
  var a[10000]int32                      // Array of 10k elements initialized to 0
  for i := int32(0); i < 10000; i++ {         // 10k outer loop iterations
    for j := int32(0); j < 100000; j++ {      // 100k inner loop iterations, per outer loop iteration
      a[i] = a[i] + j%u                // Simple sum
    }
    a[i] += r                          // Add a random value to each element in array
  }
  fmt.Println(a[r])                    // Print out a single element from the array
}

问题的根源出在对a[i]的读写每次都需要去内存或缓存中进行，而老牌编译器会对这种嵌套循环中的变量创建一个临时变量，等内层循环结束，在写回原始变量，而临时变量更有可能被放入寄存器。如果我们把Go的代码稍微改一下，手动去做这段优化。

//...上文代码不变
  for i := int32(0); i < 10000; i++ {
	tmp := a[i]
    for j := int32(0); j < 100000; j++ {      // 100k inner loop iterations, per outer loop iteration
      tmp = tmp + j%u                // Simple sum
    }
    tmp += r                          // Add a random value to each element in array
    a[i] = tmp
  }
//...下文代码不变

具体测试结果我就不测了（电脑上OpenJDK都没装），可以看参考文献中：GoCN的文章

GO语言的递归为什么比不过Java

栈空间处理
- Go默认的栈空间较小(2KB-8KB),递归调用容易发生栈溢出
- Java的栈空间默认更大(64KB-1MB),且可以轻松配置
- Java的JVM对递归有专门的优化
尾递归优化
- Go编译器目前不支持尾递归优化
- Java的HotSpot JVM会对热点代码进行尾递归优化
- 这导致Go在深度递归时性能下降明显
JIT vs AOT
- Java的JIT可以在运行时优化递归代码
- Go是AOT编译,缺乏运行时优化机会
- JIT能根据实际运行情况做更多优化

思考

其实我之前一直没想过，想当然的以为编译语言性能会高于Java这种需要依托类JVM运行的语言。事实上无论是多线程（当然Go语言也有优秀的三方协程池）还是基本逻辑代码等等，在很多方面Go都打不过Java，.net这种老牌编译工具链，这个github上的简单项目，不到两周的时间就一千个star，估计也是很多人没想到，在最简单的场景下，各种语言的表现和预期差别很大。虽然在业务上看，即便慢了一百倍的CPython在大多数场景也不会是性能瓶颈的根源，但作为一个程序人总要深思，不是么？