Go語言實戰(zhàn)之切片內存優(yōu)化

更新時間：2023年03月08日 09:14:17 作者：TtrOps

Go 語言的切片是一個動態(tài)的數(shù)據結構，可以方便地對其進行擴容和縮容操作。這篇文章主要為大家詳細介紹了Go語言如何實現(xiàn)切片內存優(yōu)化，需要的可以參考一下

切片為什么要做內存優(yōu)化

Go 語言的切片是一個動態(tài)的數(shù)據結構，可以方便地對其進行擴容和縮容操作。由于切片的底層實現(xiàn)是通過數(shù)組來實現(xiàn)的，因此在使用切片時，需要注意內存分配和釋放的開銷。這也是為什么需要對切片的內存使用進行優(yōu)化的原因。

內存分配和釋放是非常耗時的操作，因此頻繁地對切片進行重新分配和釋放會影響程序的性能和效率。當程序中的數(shù)據量增加時，內存分配和釋放的開銷也會增加，這會導致程序變得更加緩慢。

因此，在使用切片時，需要注意內存使用的優(yōu)化，盡可能地避免頻繁地進行內存分配和釋放操作。優(yōu)化內存使用可以減少程序的運行時間和內存占用，提高程序的性能和效率。

切片優(yōu)化內存的技巧

Go 語言中的切片是一個非常方便的數(shù)據結構，它可以動態(tài)地增加或縮小其長度。在處理大量數(shù)據的情況下，對切片的內存使用進行優(yōu)化是非常重要的。下面是一些優(yōu)化切片內存使用的技巧：

預分配切片的容量在創(chuàng)建切片時，如果能夠預先知道其容量，最好設置好預期的容量。這樣可以避免內存重新分配的開銷。
重用底層數(shù)組盡可能地重用底層數(shù)組可以減少內存分配和釋放的開銷?？梢允褂们衅那衅僮骱?copy 函數(shù)來復制數(shù)據，避免創(chuàng)建新的切片。
使用 append 函數(shù)時預分配容量如果在使用 append 函數(shù)時預先分配足夠的容量，可以避免內存重新分配的開銷。盡可能地避免在循環(huán)中多次使用 append 函數(shù)，這將導致多次內存重新分配。
使用 sync.Pool 減少內存分配和釋放的開銷 sync.Pool 是 Go 語言中用于池化對象的包。通過使用 sync.Pool，可以重復使用之前分配的對象，避免頻繁的內存分配和釋放操作。

總之，在使用切片時，需要注意內存分配和釋放的開銷，并盡可能地優(yōu)化內存使用，以提高程序的性能和效率。

實戰(zhàn)案例

1.通過重用底層數(shù)組來避免內存分配和釋放的開銷

package?main

import?"fmt"

func?main()?{
????var?s1?[]int
????var?s2?[]int

????for?i?:=?0;?i?<?10000000;?i++?{
????????s1?=?append(s1,?i)
????????s2?=?append(s2,?i*2)
????}

????fmt.Printf("s1:?%d,?s2:?%d\n",?len(s1),?len(s2))

????s1?=?s1[:0]
????s2?=?s2[:0]

????for?i?:=?0;?i?<?10000000;?i++?{
????????s1?=?append(s1,?i)
????????s2?=?append(s2,?i*2)
????}

????fmt.Printf("s1:?%d,?s2:?%d\n",?len(s1),?len(s2))

????s1?=?s1[:0]
????s2?=?s2[:0]

????for?i?:=?0;?i?<?10000000;?i++?{
????????if?i?<?len(s1)?{
????????????s1[i]?=?i
????????}?else?{
????????????s1?=?append(s1,?i)
????????}

????????if?i?<?len(s2)?{
????????????s2[i]?=?i?*?2
????????}?else?{
????????????s2?=?append(s2,?i*2)
????????}
????}

????fmt.Printf("s1:?%d,?s2:?%d\n",?len(s1),?len(s2))
}

這個程序中，首先通過 append 函數(shù)向兩個切片 s1 和 s2 中添加了 10000000 個元素。然后，通過將切片設置為切片的零長度來重用底層數(shù)組，避免頻繁的內存分配和釋放操作。最后，通過直接訪問切片中的元素來避免創(chuàng)建新的切片。

運行該程序，可以看到輸出結果：

[root@devhost temp-test]# go run test-temp.go
s1: 10000000, s2: 10000000
s1: 10000000, s2: 10000000
s1: 10000000, s2: 10000000
[root@devhost temp-test]#

可以看到，在重用底層數(shù)組之后，程序的運行時間沒有顯著變化，并且內存使用也更加高效。

2.使用 sync.Pool 減少內存分配和釋放的開銷案例假設我們需要對一個較大的二維數(shù)組進行遍歷，并對每個元素進行處理。由于該數(shù)組的大小較大，為了減少內存分配和釋放的開銷，我們可以使用 sync.Pool 來緩存一部分已經分配的內存。

package?main

import?(
?"fmt"
?"math/rand"
?"sync"
?"time"
)

const?(
?rows?=?10000
?cols?=?10000
)

func?main()?{
?//?生成二維數(shù)組
?rand.Seed(time.Now().UnixNano())
?arr?:=?make([][]int,?rows)
?for?i?:=?range?arr?{
??arr[i]?=?make([]int,?cols)
??for?j?:=?range?arr[i]?{
???arr[i][j]?=?rand.Intn(1000)
??}
?}

?//?使用?sync.Pool?緩存一部分內存
?pool?:=?sync.Pool{
??New:?func()?interface{}?{
???return?make([]int,?cols)
??},
?}

?//?遍歷二維數(shù)組并對每個元素進行處理
?for?i?:=?range?arr?{
??row?:=?pool.Get().([]int)
??copy(row,?arr[i])
??go?func(row?[]int)?{
???for?j?:=?range?row?{
????row[j]?=?process(row[j])
???}
???pool.Put(row)
??}(row)
?}

?fmt.Println("All?elements?are?processed!")
}

//?對元素進行處理的函數(shù)
func?process(x?int)?int?{
?time.Sleep(time.Duration(x)?*?time.Millisecond)
?return?x?*?2
}

運行該程序，可以看到輸出結果：

[root@devhost temp-test]# go run test-temp.go
All elements are processed!

上述代碼中，我們使用 sync.Pool 緩存了一部分大小為 cols 的整型數(shù)組，并在遍歷二維數(shù)組時使用 Get() 方法從緩存中獲取一個數(shù)組進行處理。由于 Get() 方法返回的是一個 interface{} 類型的對象，需要使用類型斷言轉換為正確的類型。在處理完一個數(shù)組后，我們將其歸還到緩存池中，以便下一次使用時能夠直接獲取已經分配的內存，而不需要重新進行分配。

在處理元素時，我們還使用了 go 關鍵字開啟了一個新的協(xié)程來執(zhí)行處理操作，以充分利用 CPU 的多核能力。在處理完成后，我們將該數(shù)組歸還到緩存池中，以便下一次使用。

通過使用 sync.Pool 緩存一部分已經分配的內存，可以避免頻繁地進行內存分配和釋放，從而提高程序的性能和效率。

3.使用 append 函數(shù)時預分配容量的案例假設我們需要向一個空的切片中添加 1000000 個元素，并對每個元素進行處理。由于 append 函數(shù)會在需要時自動擴展切片的容量，頻繁的擴容操作會帶來較大的性能開銷，因此我們可以在使用 append 函數(shù)前預分配切片的容量，以減少擴容操作的次數(shù)。

package?main

import?(
?"fmt"
?"math/rand"
?"time"
)

const?(
?n?=?1000000
)

func?main()?{
?//?預分配切片的容量
?data?:=?make([]int,?0,?n)

?//?向切片中添加元素并處理
?rand.Seed(time.Now().UnixNano())
?for?i?:=?0;?i?<?n;?i++?{
??data?=?append(data,?rand.Intn(1000))
?}
?for?i?:=?range?data?{
??data[i]?=?process(data[i])
?}

?fmt.Println("All?elements?are?processed!")
}

//?對元素進行處理的函數(shù)
func?process(x?int)?int?{
?time.Sleep(time.Duration(x)?*?time.Millisecond)
?return?x?*?2
}

在上述代碼中，我們使用 make([]int, 0, n) 預分配了一個切片，其長度為 0，容量為 n，即預留了 n 個元素的存儲空間。在向切片中添加元素時，由于容量已經預分配好了，append 函數(shù)不會進行擴容操作，從而減少了性能開銷。

需要注意的是，如果預分配的容量過小，仍然會進行擴容操作，從而導致性能下降。因此，預分配的容量應根據實際情況進行調整。

4.使用預分配切片容量的案例假設我們有一個函數(shù) readData()，可以讀取一個很大的數(shù)據文件，并將數(shù)據逐行解析為字符串數(shù)組，我們需要將這些字符串進行進一步處理。由于我們無法事先確定數(shù)據文件的大小，因此我們需要動態(tài)地將讀取到的字符串添加到切片中。

為了避免 append 函數(shù)頻繁地進行擴容操作，我們可以在讀取數(shù)據前，預估數(shù)據文件的大小，并預分配切片的容量。

package?main

import?(
?"fmt"
?"os"
?"bufio"
?"strings"
)

func?main()?{
?//?預估數(shù)據文件的大小
?const?estSize?=?1000000

?//?預分配切片的容量
?data?:=?make([]string,?0,?estSize)

?//?讀取數(shù)據文件
?file,?err?:=?os.Open("data.txt")
?if?err?!=?nil?{
??panic(err)
?}
?defer?file.Close()

?scanner?:=?bufio.NewScanner(file)
?for?scanner.Scan()?{
??line?:=?scanner.Text()
??//?將讀取到的字符串添加到切片中
??data?=?append(data,?line)
?}

?if?err?:=?scanner.Err();?err?!=?nil?{
??panic(err)
?}

?//?對字符串進行處理
?for?i,?str?:=?range?data?{
??data[i]?=?process(str)
?}

?fmt.Println("All?strings?are?processed!")
}

//?對字符串進行處理的函數(shù)
func?process(s?string)?string?{
?return?strings.ToUpper(s)
}

在上述代碼中，我們使用 make([]string, 0, estSize) 預分配了一個空的字符串切片，其長度為 0，容量為 estSize，即預留了 estSize 個元素的存儲空間。在讀取數(shù)據文件時，由于容量已經預分配好了，append 函數(shù)不會進行擴容操作，從而減少了性能開銷。

需要注意的是，預估數(shù)據文件的大小應該根據實際情況進行調整，容量過小仍然會進行擴容操作，容量過大則會浪費空間。