切片和容器/列表的区别

Question

我刚刚开始使用 Go，我遇到了一种情况，我需要创建一组实体，其大小/长度仅在运行时才知道。我最初认为使用列表会很合适，但很快意识到切片是 Go 中惯用的数据结构。 好奇，我写了以下基准

package main

import (
    "container/list"
    "testing"
)

var N = 10000000

func BenchmarkSlices(B *testing.B) {
    s := make([]int, 1)
    for i := 0; i < N; i += 1 {
        s = append(s, i)
    }
}

func BenchmarkLists(B *testing.B) {
    l := list.New()
    for i := 0; i < N; i += 1 {
        l.PushBack(i)
    }
}

这给了我

BenchmarkSlices-4       2000000000               0.03 ns/op
BenchmarkLists-4               1        1665489308 ns/op

鉴于append 会创建一个新数组，并在旧数组已满时将所有数据从旧数组复制到新数组，因此在上面的示例中，我预计列表的性能优于切片。但是，我的期望显然是错误的，我正在尝试了解原因。

为了更好地理解append 在需要时如何创建新数组，我编写了以下内容：

package main

import "fmt"

func describe(s []int) {
    fmt.Printf("len = %d, cap = %d\n", len(s), cap(s))
}

func main() {
    s := make([]int, 2)
    for i := 0; i < 15; i += 1 {
        fmt.Println(i)
        describe(s)
        s = append(s, i)
    }
}

这给了我

0
len = 2, cap = 2
1
len = 3, cap = 4
2
len = 4, cap = 4
3
len = 5, cap = 8
4
len = 6, cap = 8
5
len = 7, cap = 8
6
len = 8, cap = 8
7
len = 9, cap = 16
8
len = 10, cap = 16
9
len = 11, cap = 16
10
len = 12, cap = 16
11
len = 13, cap = 16
12
len = 14, cap = 16
13
len = 15, cap = 16
14
len = 16, cap = 16

目前我唯一的猜测是，为什么切片比列表性能更好的是，为大小为两倍的新数组分配内存并复制所有数据比每次插入时为单个元素分配内存要快。 我的猜测正确吗？我错过了什么吗？

Answer 1

您运行的基准测试有误。您应该首先设置初始数据结构，然后按照testing.B 实例指示的次数运行被基准测试的操作。

我将您的代码替换为：

var N = 1

func BenchmarkSlices(B *testing.B) {
    s := make([]int, 1)
    for n := 0; n < B.N; n++ {
        for i := 0; i < N; i++ {
            s = append(s, i)
        }
    }
}

func BenchmarkLists(B *testing.B) {
    l := list.New()
    for n := 0; n < B.N; n++ {
        for i := 0; i < N; i++ {
            l.PushBack(i)
        }
    }
}

得到了这个结果：

BenchmarkSlices-4       100000000               14.3 ns/op
BenchmarkLists-4         5000000               275 ns/op

至少这次差异似乎是合理的，而不是一万亿倍。

请注意，我还将N 的值替换为1，因此ns/op 实际上表示nanoseconds per operation 而不是nanoseconds per N operations。但是，这也可能会影响结果。

现在谈谈你的问题：在 Go 中实现的链表与简单地向预先分配的切片添加另一个 int 相比会产生额外的成本：list 方法需要创建一个新的Element，将你的值包含在interface{} 并重新分配一些指针。

同时，追加到一个尚未达到最大容量的切片将导致 CPU 级别的几条指令：将一个 int 移动到内存位置，增加切片的长度，然后就完成了。

还有一个事实是，底层分配器可能会重新分配切片，因此根本不需要复制现有的底层数组元素。