Golang中如何进一步优化性能？

Golang中如何进一步优化性能？ 有没有更快/更高效的方法来为 int64 切片分配内存？

r := make([]int64, 0, 90000)

在 Kotlin 中，长整型数组的初始化速度比上述代码快两倍，我希望能让 Go 版本更快。

var result = LongArray(90000)

更新 以下是我尝试实现的代码：https://gist.github.com/danielcasler/5508dfb3323ddbe5060e3867216a548d

我已经在这方面取得了很大进展，通过传入指针，generate 函数正在对指针地址处的数组进行修改。这个练习确实帮助我进一步理解了 Go。有没有办法进一步改进这一点？


更多关于Golang中如何进一步优化性能？的实战教程也可以访问 https://www.itying.com/category-94-b0.html

2 回复

你只是声明了变量，但尚未分配内存。如果打印 len(r) 会得到 0，因为切片没有任何元素。现在你可以生成 90000 个元素并初始化为零值，只需执行：

r := make([]int64, 90000, 90000)

这个过程非常快！

更多关于Golang中如何进一步优化性能？的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


在Go中，对于int64切片的内存分配优化，可以考虑以下几种方法：

1. 使用数组代替切片（如果大小固定）

// 如果大小固定为90000，直接使用数组
var result [90000]int64

2. 预分配并重用切片

// 一次性预分配，避免重复分配
var resultPool = make([]int64, 0, 90000)

func getSlice() []int64 {
    // 重置并复用切片
    return resultPool[:0]
}

3. 使用sync.Pool管理切片对象

var slicePool = sync.Pool{
    New: func() interface{} {
        return make([]int64, 0, 90000)
    },
}

func getPooledSlice() []int64 {
    return slicePool.Get().([]int64)
}

func returnSlice(s []int64) {
    s = s[:0] // 重置切片
    slicePool.Put(s)
}

4. 直接使用unsafe进行内存操作

import "unsafe"

func allocateInt64Slice(size int) []int64 {
    // 直接分配内存
    data := make([]int64, size)
    return data
}

// 或者使用更底层的方式
func unsafeAllocate(size int) []int64 {
    slice := struct {
        addr uintptr
        len  int
        cap  int
    }{}
    slice.len = size
    slice.cap = size
    
    // 分配内存
    data := make([]int64, size)
    slice.addr = uintptr(unsafe.Pointer(&data[0]))
    
    return *(*[]int64)(unsafe.Pointer(&slice))
}

5. 针对你的具体场景优化

基于你提供的代码，可以这样优化：

func generateOptimized(result *[]int64) {
    // 确保切片有足够容量
    if cap(*result) < 90000 {
        *result = make([]int64, 90000)
    } else {
        *result = (*result)[:90000]
    }
    
    // 直接操作底层数组
    for i := 0; i < 90000; i++ {
        (*result)[i] = int64(i * 2)
    }
}

// 使用示例
func main() {
    var data []int64
    generateOptimized(&data)
}

6. 批量操作优化

// 使用批量赋值或系统调用
func batchFill(data []int64, value int64) {
    for i := range data {
        data[i] = value
    }
}

// 或者使用copy进行批量操作
func copyFill(data []int64) {
    template := make([]int64, len(data))
    for i := range template {
        template[i] = int64(i * 2)
    }
    copy(data, template)
}

关键优化点：

  • 避免不必要的内存分配和垃圾回收
  • 重用已分配的内存
  • 直接操作底层数组减少间接访问
  • 使用合适的数据结构（数组vs切片）

这些方法可以显著提升性能，特别是在高频调用的场景中。

回到顶部