Go 切片详解

Go 切片

切片的长度和容量

func main() {
    data := make([]int, 5, 10)
    fmt.Println("Length of data:", len(data))
    fmt.Println("Capacity of data:", cap(data))
}

运行这段代码，输出如下：

Length of data: 5
Capacity of data: 10

切片的长度表示当前长度，也可以说是数组已经占用的空间。切片的容量表示从当前位置到最后位置的长度，也可以说是数组总的空间。可以这样理解：切片 = 从起始位置到结束位置的长度。切片的容量可以大于或者等于长度，但切片的长度必须小于容量。

make()函数创建一个有指定长度和容量的切片。

添加元素到切片

func main() {
    data := make([]int, 0, 5)

    data = append(data, 1)
    data = append(data, 2)
    data = append(data, 3)

    fmt.Println("Length of data:", len(data))
    fmt.Println("Capacity of data:", cap(data))
}

运行这段代码，输出如下：

Length of data: 3
Capacity of data: 5

可以观察到，data切片在添加新元素时自动扩大了容量。

删除元素

func main() {
    data := []int{1, 2, 3, 4, 5}

    data = append(data[:3], data[4:]...)
    fmt.Println(data)
}

运行这段代码，输出如下：

[1 2 3 5]

删除切片中的指定元素。

切片越界

func main() {
    data := []int{1, 2, 3, 4, 5}
    fmt.Println(data[:6])
}

运行这段代码，输出如下：

panic: runtime error: slice bounds out of range

切片越界，程序会抛出异常。

切片遍历

func main() {
    data := []int{1, 2, 3, 4, 5}

    for i, v := range data {
        fmt.Printf("Element at index %d is %d\n", i, v)
    }
}

运行这段代码，输出如下：

Element at index 0 is 1
Element at index 1 is 2
Element at index 2 is 3
Element at index 3 is 4
Element at index 4 is 5

切片元素索引从 0 开始，到最后一个元素的索引为切片长度减 1。

切片原理

切片底层的数据结构是个结构体：

type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

数组初始化时会分配内存，切片在初始化时会先初始化一个底层数组，然后初始化一个切片结构体，指向该底层数组。

make()函数创建的切片，底层数组是在堆上分配的，而直接初始化切片的数组是栈上分配的。

切片的容量可以大于或者等于长度，但切片的长度必须小于容量。

在添加元素到切片时，如果达到容量上限，会将切片复制到新的更大的数组中，并将旧数组的切片指向新的数组。

删除切片中的元素不会影响切片容量，但可能会导致内存浪费。

切片扩容

当添加元素到切片时，如果达到容量上限，会把切片复制到新的更大的数组中，并将旧数组的切片指向新的数组。

func main() {
    data := make([]int, 0, 5)

    data = append(data, 1)
    data = append(data, 2)
    data = append(data, 3)
    data = append(data, 4)
    data = append(data, 5)

    fmt.Println("Length of data:", len(data))
    fmt.Println("Capacity of data:", cap(data))
}

运行这段代码，输出如下：

Length of data: 5
Capacity of data: 10

可以观察到，data切片容量从 5 扩展到 10。

扩容原理

当添加元素到切片时，如果达到容量上限，会把切片复制到新的更大的数组中，并将旧数组的切片指向新的数组。

func growslice(et *_type, old slice, cap int) slice {
    ...
    mem, overflow := math.MulUintptr(et.size, uintptr(cap))
    ...
}

growslice()函数用于在切片添加新元素时，分配新的切片容量。

计算新切片的容量时会使用math.MulUintptr()函数，这是一个无符号整数乘法函数，使用此函数可以避免溢出风险。

扩容细节

growslice()函数内部会使用mallocgc()函数分配内存，该函数会调用 gcDrain() 函数。gcDrain()函数是 GC 机制，当执行 GC 时，会暂停 GC 操作并执行当前线程的任务。

func mallocgc(size uintptr, typ unsafe.Pointer, flag flag) unsafe.Pointer {
    ...
    return mallocgc(size, typ, flag)
}

func gcDrain(syscallSafe bool) {
    ...
}

GC 暂停后，如果此时有其他 goroutines 在释放对象，那么当前 goroutine 会读取到其他 goroutines 释放的对象，导致数据竞争错误。

因此，为了保证安全的并发访问，应该使用append()函数添加元素到切片，而不是直接修改切片。

扩容规则

func main() {
    data := make([]int, 0, 5)

    for i := 0; i < 5; i++ {
        data = append(data, i)
    }

    fmt.Println("Length of data:", len(data))
    fmt.Println("Capacity of data:", cap(data))
}

运行这段代码，输出如下：

Length of data: 5
Capacity of data: 8

growslice()函数中，在分配新切片容量时，会判断当前容量是否小于 1024。

如果当前容量小于 1024，新切片的容量会翻倍。

如果当前容量大于等于 1024，新切片的容量会加倍再加 7。

growslice()函数中的代码如下：

func growslice(et *_type, old slice, cap int) slice {
    ...
    if uintptr(cap) > maxSliceCap {
        panic(errorString("growing slice capacity exceeds maximum capacity"))
    }

    if et.size == 0 {
        return slice{}
    }

    if cap < uint(old.cap) {
        panic("capacity smaller than old capacity")
    }

    newcap := old.cap
    doublecap := newcap + newcap
    if cap > uint(doublecap) {
        newcap = cap
    } else {
        if uint(doublecap) > uint(maxSliceCap) {
            newcap = maxSliceCap
        } else {
            newcap = doublecap
        }
    }

    ...
}

容量与性能

当添加元素到切片时，如果达到容量上限，会把切片复制到新的更大的数组中，并将旧数组的切片指向新的数组。

当切片的元素较少时，不会触发扩容操作，所以容量设置可以小于切片的长度。

但是随着元素数量增加，可能需要多次对切片进行扩容，这时容量的设置会影响性能，所以尽量确保切片的容量大于或等于切片长度。

小结

切片是 Go 语言中非常重要的一部分，切片的原理、实现和细节都是理解切片的关键。