Golang优化slice与数组内存使用方法

smallSlice := largeSlice[start:end]

smallSlice

largeSlice

smallSlice

largeSlice

largeSlice

copy

func processData(data []byte) []byte {
    // 假设data是一个非常大的slice，我们只需要其中一小段
    // 比如，我们只需要data的中间部分，从索引100到200
    // 如果直接这样做：
    // smallSlice := data[100:200]
    // 那么，即使data不再被引用，整个data的底层数组也会因为smallSlice的存在而无法被GC

    // 正确的做法：将所需部分拷贝到一个新的slice中
    // 1. 创建一个具有合适长度和容量的新slice
    neededPart := data[100:200]
    newSlice := make([]byte, len(neededPart))

    // 2. 将数据从neededPart拷贝到newSlice
    copy(newSlice, neededPart)

    // 现在，newSlice拥有独立的底层数组。
    // 如果data在processData函数外部不再被引用，
    // 并且没有其他引用指向data的底层数组，
    // 那么data的底层数组就可以被GC了。
    // 如果你想更明确地帮助GC，可以在这里将原始的data引用设为nil (如果data是局部变量且不再使用)
    // data = nil // 仅作为示例，在函数参数中通常不这么做

    return newSlice
}

func main() {
    largeData := make([]byte, 1024*1024) // 1MB的大数据
    // 填充一些数据...
    for i := 0; i < len(largeData); i++ {
        largeData[i] = byte(i % 256)
    }

    // 假设我们只需要largeData的一小部分
    // 调用processData，它会返回一个拥有独立底层数组的slice
    processedResult := processData(largeData)

    // 在这里，如果largeData不再被其他地方引用，它的底层数组就可以被GC了
    // 因为processedResult持有的是一个全新的slice，而不是largeData的视图
    // ...
}

make

copy

slice

append

[]byte

make

make([]T, length, capacity)

capacity

length

capacity

// 示例：构建一个包含10000个整数的slice
// 低效的做法：不预分配容量
func buildSliceWithoutPrealloc() []int {
    var s []int // s的len=0, cap=0
    for i := 0; i < 10000; i++ {
        s = append(s, i) // 每次容量不足时都会发生扩容和拷贝
    }
    return s
}

// 高效的做法：预分配容量
func buildSliceWithPrealloc() []int {
    // 知道最终会有10000个元素，直接预分配容量
    s := make([]int, 0, 10000) // len=0, cap=10000
    for i := 0; i < 10000; i++ {
        s = append(s, i) // 在达到10000之前，不会发生底层数组的重新分配
    }
    return s
}

// 另一种预分配方式：如果知道最终长度，可以直接设置长度
func buildSliceWithKnownLength() []int {
    s := make([]int, 10000) // len=10000, cap=10000
    for i := 0; i < 10000; i++ {
        s[i] = i // 直接赋值，不需要append
    }
    return s
}

slice = slice[:newLen]

[ptr, len, cap]

slice = slice[:newLen]

len

ptr

cap

package main

import "fmt"

func main() {
    // 创建一个初始容量为10的slice
    originalSlice := make([]int, 5, 10)
    fmt.Printf("Original: len=%d, cap=%d, ptr=%p\n", len(originalSlice), cap(originalSlice), originalSlice)

    // 填充一些数据
    for i := 0; i < len(originalSlice); i++ {
        originalSlice[i] = i
    }

    // "缩短"slice
    shorterSlice := originalSlice[:3] // len变为3，cap仍然是10
    fmt.Printf("Shorter:  len=%d, cap=%d, ptr=%p\n", len(shorterSlice), cap(shorterSlice), shorterSlice)

    // 可以看到，shorterSlice和originalSlice指向同一个底层数组，容量也没有变
    // 内存并没有被释放
}

originalSlice

shorterSlice

ptr

cap

len

package main

import "fmt"
import "runtime"
import "time"

func main() {
    // 创建一个非常大的slice
    largeSlice := make([]byte, 10*1024*1024) // 10MB
    for i := 0; i < len(largeSlice); i++ {
        largeSlice[i] = byte(i % 256)
    }
    fmt.Printf("Large slice: len=%d, cap=%d, ptr=%p\n", len(largeSlice), cap(largeSlice), largeSlice)

    // 模拟只保留其中一小部分
    neededPart := largeSlice[:1024] // 只需要前1KB

    // 真正地“缩容”并释放内存
    // 1. 创建一个新slice，容量只够容纳neededPart
    newSlice := make([]byte, len(neededPart))
    // 2. 将数据拷贝过去
    copy(newSlice, neededPart)

    fmt.Printf("New slice:   len=%d, cap=%d, ptr=%p\n", len(newSlice), cap(newSlice), newSlice)

    // 此时，largeSlice仍然引用着10MB的底层数组。
    // 为了让GC回收largeSlice的底层数组，我们需要让largeSlice失去引用。
    largeSlice = nil // 将largeSlice设置为nil

    // 强制运行GC，观察内存变化（在实际生产代码中不建议频繁手动GC）
    runtime.GC()
    time.Sleep(100 * time.Millisecond) // 给GC一点时间

    fmt.Println("After setting largeSlice to nil and GC, memory might be reclaimed.")
    // newSlice现在是独立的，只占用1KB左右的内存
    _ = newSlice // 避免编译器优化掉newSlice
}

newSlice

largeSlice

nil

len

cap