将我的一个计算量大的后端程序从 Java 迁移到 Go 后，我发现性能没有提高而是下降了。我测试了一些，似乎数组排序代码是罪魁祸首(我在我的程序中大量使用它)。我写了下面两个简化的程序来做一个比较，Go 内置的排序功能似乎比 Java 的 Arrays.sort 方法慢很多？

package main

import (
    "fmt"
    "math/rand"
    "sort"
    "time"
)

func main() {
    fmt.Println("Starting")
    const x = 1000000
    const y = x * 10
    var s [y]float64
    s1 := rand.NewSource(time.Now().UnixNano())
    r1 := rand.New(s1)
    start1 := time.Now()
    for i := 0; i < y; i++ {
        s[i] = r1.Float64()
    }
    end1 := time.Since(start1)
    ss := s[:]
    start2 := time.Now()
    sort.Float64s(ss)
    end2 := time.Since(start2)
    fmt.Println(end1)
    fmt.Println(end2)
    fmt.Println("Number: ", ss[x])
}

它会产生这样的结果:

Starting
136.6331ms  // The time taken to generate 10,000,000 random numbers
3.456781s   // The time taken to sort the 10,000,000 random numbers
Number:  0.10000285497001288

这里是Java程序

import java.util.*;

class RSTest {
    public static void main(String[] args) {
        System.out.println("Starting");
        int x = 1000000;
        int y = x * 10;
        Random gen = new Random(System.currentTimeMillis());
        double[] s = new double[y];
        long start1 = System.nanoTime();
        for (int i = 0; i < y; i++) {
            s[i] = gen.nextDouble();
        }
        long end1 = System.nanoTime();
        long start2 = System.nanoTime();
        Arrays.sort(s);
        long end2 = System.nanoTime();
        System.out.println((end1 - start1) / (1000000000.0));
        System.out.println((end2 - start2) / (1000000000.0));
        System.out.println(s[x]);
    }
}

结果是这样的

Starting
0.2252634  // The time taken to generate 10,000,000 random numbers
1.0303157  // The time taken to sort the 10,000,000 random numbers
0.0999513608326642

Go 程序需要大约 130 毫秒来生成 1000 万个随机数并将它们分配给一个数组，而 Jave 需要大约 230 毫秒来生成 1000 万个随机数并将它们分配给一个数组，我认为这部分是我期望的改进从 Java 到 Go。

但是对于排序部分，Java 只用了 1 秒左右就可以对 1000 万个随机数进行排序，而 Go 需要 3.5 秒左右才能完成 1000 万个随机数排序？这与多次运行的测试非常一致。

那么这是否意味着 Go 的内置排序函数真的比 Java 的 Arrays.sort 方法差这么多？还是我用错了 Go 的排序功能？还是我的程序有问题？

谢谢。

注意:这是来自 Go 1.11 和 Java 8，我在我的服务器上运行的当前版本。另外，请注意我在这里发布的两个程序纯粹是为了测试目的，我在几分钟内编写了这些程序，因此可能(或者更确切地说，肯定是)包含一些对实际生产系统没有多大意义的代码。

一些更新:

感谢@nussjustin 的建议，我尝试了 sort.Slice 并取得了一些有希望的结果。

由于目前我不在办公室并且使用较慢的笔记本电脑，所以上述两个测试的基线结果现在是这样的:

对于 Java Arrays.sort 测试

Starting
0.3590694
1.6030528 // The time taken to sort the 10,000,000 random numbers
0.10000905418967532

对于 Go sort.Float64s 测试

Go
Starting
233.1957ms
5.4633992s // The time taken to sort the 10,000,000 random numbers
Number:  0.10002801819954663

现在在使用 sort.Slice 修改 Go 测试之后

package main

import (
    "fmt"
    "math/rand"
    "sort"
    "time"
)

func main() {
    fmt.Println("Starting")
    const x = 1000000
    const y = x * 10
    var s [y]float64
    s1 := rand.NewSource(time.Now().UnixNano())
    r1 := rand.New(s1)
    start1 := time.Now()
    for i := 0; i < y; i++ {
        s[i] = r1.Float64()
    }
    end1 := time.Since(start1)
    ss := s[:]
    start2 := time.Now()
    sort.Slice(ss, func(i, j int) bool { return ss[i] < ss[j] })
    end2 := time.Since(start2)
    fmt.Println(end1)
    fmt.Println(end2)
    fmt.Println("Number: ", ss[x])
}

结果比sort.Float64s有了很大的改进，但还是不如Java的数组排序

Starting
281.4262ms
3.6745684s // The time taken to sort the 10,000,000 random numbers
Number:  0.10010604106864159

而且我认为有人提示测试只有 1 个分布(后来删除了他的评论)，我也测试了对随机数的正态分布进行排序(尽管我会说排序均匀分布的性能差异如此之大随机数已经是一个非常糟糕的迹象，因为随机数均匀分布的排序算法应该已经很成熟了)

我只是将随机数生成器从均匀分布替换为这样的正态分布

开始:

s[i] = r1.NormFloat64()

Java:

s[i] = gen.nextGaussian();

而Java的Arrays.sort方法的结果是

Starting
1.4126348
1.6118655
-1.2820310313627319

Go 的 sort.Slice

Starting
434.9106ms
3.8936811s
Number:  -1.2818667132095363

所以 Go 是 sort.Slice 仍然比 Java 的 Arrays.sort 慢两倍左右，与随机数的均匀分布相同。好消息是，在生成随机数的正态分布方面，Go 比 Java 快三倍，而在生成随机数的均匀分布方面快了大约 70%。

最佳答案

感谢@JimB 和@nussjustin 的建议，我自己编写了一个简单的快速排序实现，它发挥了神奇的作用!

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func qsort(s []float64) []float64 {
    if len(s) < 2 {
        return s
    }

    left, right := 0, len(s)-1

    pivot := 0

    s[pivot], s[right] = s[right], s[pivot]

    for i := range s {
        if s[i] < s[right] {
            s[left], s[i] = s[i], s[left]
            left++
        }
    }

    s[left], s[right] = s[right], s[left]

    qsort(s[:left])
    qsort(s[left+1:])

    return s
}

func main() {
    fmt.Println("Starting")
    const x = 1000000
    const y = x * 10
    var s [y]float64
    s1 := rand.NewSource(time.Now().UnixNano())
    r1 := rand.New(s1)
    start1 := time.Now()
    for i := 0; i < y; i++ {
        s[i] = r1.NormFloat64()
    }
    end1 := time.Since(start1)
    ss := s[:]
    start2 := time.Now()
    ss = qsort(ss)
    end2 := time.Since(start2)
    fmt.Println(end1)
    fmt.Println(end2)
    fmt.Println("Number: ", ss[x])
}

通过这种 super 粗略的快速排序，现在我能够获得以下结果

Starting
276.763ms
1.589941s
Number:  -1.281875446690731 

现在它始终比 Java 的 Arrays.sort 方法快 15% 左右!

我还在 Java 中实现了一个专门用于 double 组的快速排序方法来替换 Arrays.sort 方法，看看我是否可以获得任何性能提升，性能最终与 Arrays.sort 大致相同，仍然在 10% 到 15 左右比 Go 慢 %。似乎 Arrays.sort 已经以某种方式在 Java 中实现了可能的最佳性能，并且您不会通过剥离抽象获得任何好处。

所以我想教训是，如果你想要 Go 的排序性能，那么自己实现一个快速排序函数，不要使用内置的排序函数，即使是 sort.Slice 也比自己写的慢两倍左右sort 函数，而 sort.Float64s 慢了三倍多(有时是四倍)!

我想这些结果最终可以让那些评论者对他们所谓的“无效基准”东西闭嘴。就像我说的，从 Java 迁移到 Go 后的性能下降对于我的生产系统来说是非常真实的，如果它不能尽快修复我会很紧张，现在希望在替换所有这些排序函数之后，我们终于可以看到一个我们的生产系统的性能得到了不错的改进，所以我今晚可以睡个安稳觉:)

关于java - 为什么我的 Go 数组排序代码比 Java 慢很多？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/55263220/