面试题：Go语言切片扩容与内存优化

可能出现的问题

数据竞争：多个协程同时向切片追加元素时，由于切片的扩容操作不是线程安全的，可能导致数据竞争。例如，多个协程同时检测到切片需要扩容，都进行扩容操作，最终可能导致数据丢失或覆盖等问题。
扩容不一致：不同协程对切片的扩容时机判断不一致，可能会导致切片的大小和容量在多个协程操作后出现不符合预期的情况，影响程序逻辑。

避免方法

互斥锁：使用互斥锁（如Go语言中的sync.Mutex）来保护对切片的追加操作。在追加元素前加锁，操作完成后解锁，这样可以保证同一时间只有一个协程能对切片进行操作，避免数据竞争。示例代码（以Go语言为例）：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var mu sync.Mutex
    var slice []int
    var wg sync.WaitGroup

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(num int) {
            defer wg.Done()
            mu.Lock()
            slice = append(slice, num)
            mu.Unlock()
        }(i)
    }

    wg.Wait()
    fmt.Println(slice)
}

读写锁：如果读操作远多于写操作，可以使用读写锁（如Go语言中的sync.RWMutex）。读操作时使用读锁，写操作（如追加元素）时使用写锁，以提高并发性能。

内存使用优化

预分配容量：在高并发场景下，提前根据预估的元素数量预分配切片的容量。这样可以减少切片在追加元素过程中的扩容次数，从而减少内存的频繁分配和复制。例如，在Go语言中：

package main

import (
    "fmt"
)

func main() {
    // 预分配容量为100
    slice := make([]int, 0, 100)
    for i := 0; i < 100; i++ {
        slice = append(slice, i)
    }
    fmt.Println(slice)
}

及时释放内存：当切片中的元素不再使用时，及时将切片置为nil，让垃圾回收器回收内存。例如：

package main

import (
    "fmt"
)

func main() {
    slice := make([]int, 100)
    // 使用完后
    slice = nil
    fmt.Println(slice)
}

对象池：对于频繁创建和销毁的对象，可以使用对象池（如Go语言中的sync.Pool）来复用对象，减少内存分配开销。例如，假设切片中存储的是自定义结构体对象：

package main

import (
    "fmt"
    "sync"
)

type MyStruct struct {
    // 结构体字段
}

var pool = sync.Pool{
    New: func() interface{} {
        return &MyStruct{}
    },
}

func main() {
    var slice []*MyStruct
    for i := 0; i < 10; i++ {
        obj := pool.Get().(*MyStruct)
        // 使用obj
        slice = append(slice, obj)
    }

    for _, obj := range slice {
        pool.Put(obj)
    }
    slice = nil
}

面试题：Go语言切片扩容与内存优化

知识考点

面试题答案

可能出现的问题

避免方法

内存使用优化