概述

Slice（切片）是Go语言中最常用的数据结构之一，它提供了比数组更灵活、更强大的序列操作能力。理解Slice的底层实现，对于编写高性能Go程序至关重要。本文将深入剖析Slice的内存布局、扩容策略、常见陷阱与最佳实践。

SliceHeader 结构

Slice在运行时的底层结构定义在 reflect.SliceHeader 中（Go 1.20+ 推荐使用 unsafe.Slice）：

type SliceHeader struct {
    Data uintptr // 指向底层数组的指针
    Len  int     // 切片长度（已使用元素数）
    Cap  int     // 切片容量（底层数组总长度）
}

在 runtime/slice.go 中，实际使用的结构为：

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

一个slice变量本身占用24字节（64位系统），包含三个字段。

创建切片的方式

// 1. 字面量
s1 := []int{1, 2, 3}

// 2. make创建，指定长度和容量
s2 := make([]int, 5, 10)

// 3. 从数组切片
arr := [5]int{1, 2, 3, 4, 5}
s3 := arr[1:3] // len=2, cap=4

// 4. 从已有切片再切片
s4 := s3[:cap(s3)]

Append 扩容策略

当 append 操作导致长度超过容量时，Go运行时会分配一个更大的底层数组并复制数据。扩容策略在Go 1.18之后做了调整：

// Go 1.18+ 扩容策略（runtime/slice.go - growslice）
func growslice(oldPtr unsafe.Pointer, newLen, oldCap, num int, et *_type) slice {
    newcap := oldCap
    doublecap := newcap + newcap
    if newLen > doublecap {
        newcap = newLen
    } else {
        const threshold = 256
        if oldCap < threshold {
            newcap = doublecap // 小于256时翻倍
        } else {
            for newcap < newLen {
                newcap += (newcap + 3*threshold) >> 2 // 约1.25倍增长
            }
        }
    }
    // 还会进行内存对齐，实际容量可能更大
}

验证扩容行为

func main() {
    s := make([]int, 0)
    prev := cap(s)
    for i := 0; i < 2000; i++ {
        s = append(s, i)
        if cap(s) != prev {
            fmt.Printf("len=%4d cap: %4d -> %4d (ratio: %.2f)\n",
                len(s), prev, cap(s), float64(cap(s))/float64(prev))
            prev = cap(s)
        }
    }
}
// 输出示例：
// len=   1 cap:    0 ->    1 (ratio: Inf)
// len=   2 cap:    1 ->    2 (ratio: 2.00)
// len=   5 cap:    4 ->    8 (ratio: 2.00)
// ...
// len= 257 cap:  256 ->  512 (ratio: 2.00)
// len= 513 cap:  512 ->  848 (ratio: 1.66)

Slice Expression（切片表达式）

简单切片表达式

a := []int{0, 1, 2, 3, 4, 5, 6, 7}
s := a[2:5] // len=3, cap=6, 共享底层数组

完整切片表达式（三索引）

s := a[2:5:6] // len=3, cap=4, 限制容量

三索引切片可以限制新切片的容量，防止意外覆盖底层数组中其他切片的数据：

func processSlice(data []int) {
    // 使用三索引切片避免append影响调用方
    local := data[0:len(data):len(data)]
    local = append(local, 99) // 不会影响原始data
}

nil Slice vs Empty Slice

var nilSlice []int          // nil slice: ptr=nil, len=0, cap=0
emptySlice := []int{}       // empty slice: ptr!=nil, len=0, cap=0
makeSlice := make([]int, 0) // empty slice: ptr!=nil, len=0, cap=0

fmt.Println(nilSlice == nil)    // true
fmt.Println(emptySlice == nil)  // false
fmt.Println(len(nilSlice))      // 0（安全调用）

实际影响：

• json.Marshal(nilSlice) 输出 null
• json.Marshal(emptySlice) 输出 []
• 两者的 len()、cap() 行为一致，append 行为一致

内存泄漏场景

场景一：大切片截取小切片

// 错误：小切片持有大数组的引用，导致大数组无法被GC
func getFirstThree(data []int) []int {
    return data[:3] // 底层数组仍然是整个data
}

// 正确：复制到新切片
func getFirstThree(data []int) []int {
    result := make([]int, 3)
    copy(result, data[:3])
    return result
}

场景二：指针元素未清除

// 当切片缩短时，超出len但在cap范围内的指针元素不会被GC
type User struct{ Name string }

func removeFirst(users []*User) []*User {
    // 错误：users[0]仍在底层数组中
    // return users[1:]

    // 正确：清除引用
    users[0] = nil
    return users[1:]
}

copy vs append 复制

src := []int{1, 2, 3, 4, 5}

// 方式一：copy（需要预分配）
dst1 := make([]int, len(src))
n := copy(dst1, src) // 返回复制的元素数

// 方式二：append（自动分配）
dst2 := append([]int(nil), src...)

// 方式三：slices.Clone（Go 1.21+）
dst3 := slices.Clone(src)

性能优化技巧

// 1. 预分配容量，避免频繁扩容
s := make([]int, 0, expectedSize)

// 2. 重用切片，避免重复分配
s = s[:0] // 重置长度但保留底层数组

// 3. 使用sync.Pool缓存常用切片
var bufPool = sync.Pool{
    New: func() interface{} {
        b := make([]byte, 0, 4096)
        return &b
    },
}

// 4. 批量append比逐个append高效
s = append(s, batch...) // 一次扩容

总结

特性	说明
内存布局	24字节header：指针 + len + cap
扩容策略	<256翻倍，>=256约1.25倍（Go 1.18+）
共享底层数组	切片表达式默认共享，三索引可限制cap
nil vs empty	序列化行为不同，其余行为一致
内存泄漏	注意大数组引用和指针元素清除
最佳实践	预分配、重用、三索引限制

理解Slice底层实现是写出高效Go代码的基础。在实际开发中，合理预分配容量、注意底层数组共享、避免内存泄漏是最重要的三个原则。

贡献者

withesse

更新日志

2026/3/14 13:09

查看所有更新日志

• 9f6c2-feat: organize wiki content and refresh site setup于 2026/3/14

编辑此页