Ben Dicken (@BenjDicken) 做了一项测试，执行双层循环， 1 万 * 10 万= 10 亿次循环，看看哪种编程语言快。 目前测试了下面的语言， Zip、Julia、Perl、Elixir、Fortan、C#、Lua 等编程语言也被热心网友提了 PR,下一次的测试必然热闹了。一些语言的优化版本也提交了 PR。各种语言的代码实现都在项目代码库中可以找到：1 Billion nested loop iterations[1]。

比如 C 语言的代码：

#include "stdio.h"
#include "stdlib.h"
#include "stdint.h"
// 堆代码 duidaima.com
int main (int argc, char** argv) {
  int u = atoi(argv[1]);               // Get an input number from the command line
  int r = rand() % 10000;              // Get a random integer 0 <= r < 10k
  int32_t a[10000] = {0};              // Array of 10k elements initialized to 0
  for (int i = 0; i < 10000; i++) {    // 10k outer loop iterations
    for (int j = 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
  }
  printf("%d\n", a[r]);                // Print out a single element from the array
}

Rust 代码：

use rand::Rng;
fn main() {
    let n: usize = std::env::args()             // Get an input number from the command line
        .nth(1)
        .unwrap()
        .parse()
        .unwrap();
    let r: usize = rand::thread_rng()           // Get a random number 0 <= r < 10k
        .gen_range(0..10000);
    let mut a = [0; 10000];                     // Array of 10k elements initialized to 0
    for i in 0..10000 {                         // 10k outer loop iterations
        for j in 0..100000 {                    // 100k inner loop iterations
            a[i] = a[i] + j % n;                // Simple sum
        }
        a[i] += r;                              // Add a random value to each element in array
    }
    println!("{}", a[r]);                       // Print out a single element from the array
}

Zig 代码：

const std = @import("std");
const rand = std.crypto.random;
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    // Get an input number from the command line
    var args = std.process.args();
    _ = args.next() orelse unreachable; // skip first, which is program name
    const arg = args.next() orelse unreachable;
    const u = try std.fmt.parseInt(usize, arg, 10);

    // Get a random number 0 <= r < 10k
    const r = rand.intRangeAtMost(usize, 0, 10000);

    // Array of 10k elements initialized to 0
    var a: [10000]usize = undefined;
    @memset(&a, 0);

    // 10k outer loop iterations
    for (0..10000) |i| {
        // 100k inner loop iterations, per outer loop iteration
        for (0..100000) |j| {
            a[i] += j % u; // Simple sum
        }
        a[i] += r; // Add a random value to each element in array
    }

    try stdout.print("{d}\n", .{a[r]}); // Print out a single element from the array
}

Go 代码：

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 := int(input)
  r := int(rand.Intn(10000))           // Get a random number 0 <= r < 10k
  var a[10000]int                      // Array of 10k elements initialized to 0
  for i := 0; i < 10000; i++ {         // 10k outer loop iterations
    for j := 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
}

测试的结果如下(作者每种语言测试几遍，每个语言挑选了最快的一次)，作者还非常好的使用动画演示每种语言的快慢，执行越快，执行时间越短，小球移动的越快：

我自己的测试也是 c、zip、rust 属于第一梯队。作者还提供了的斐波那契函数的测试，所以总体来说主要堆这两个场景进行了测试。你支持哪种编程语言呢，还是置身事外？

参考资料
[1]1 Billion nested loop iterations: https://github.com/bddicken/languages