Golang內存泄漏場景以及解決方案詳析
1、字符串截取
func main() {
var str0 = "12345678901234567890"
str1 := str0[:10]
}以上代碼，會有10字節(jié)的內存泄漏，我們知道，str0和str1底層共享內存，只要str1一直活躍，str0 就不會被回收，10字節(jié)的內存被使用，剩下的10字節(jié)內存就造成了臨時性的內存泄漏，直到str1不再活躍
如果str0足夠大，str1截取足夠小，或者在高并發(fā)場景中頻繁使用，那么可想而知，會造成臨時性內存泄漏，對性能產生極大影響。
解決方案1：string to []byte， []byte to string
func main() {
var str0 = "12345678901234567890"
str1 := string([]byte(str0[:10]))
}將需要截取的部分先轉換成[]byte，再轉換成string，但是這種方式會產生兩個10字節(jié)的臨時變量，string轉換[]byte時產生一個10字節(jié)臨時變量，[]byte轉換string時產生一個10字節(jié)的臨時變量
解決方案2：
func main() {
var str0 = "12345678901234567890"
str1 := (" " + str0[:10])[1:]
}這種方式仍舊會產生1字節(jié)的浪費
解決方案3：strings.Builder
func main() {
var str0 = "12345678901234567890"
var builder strings.Builder
builder.Grow(10)
builder.WriteString(str0[:10])
str1 := builder.String()
}這種方式的缺點就是代碼量過多
解決方案4：strings.Repeat
func main() {
var str0 = "12345678901234567890"
str1 := strings.Repeat(str0[:10], 1)
}這種方式底層還是用到了strings.Builder，優(yōu)點就是將方案3進行了封裝，代碼量得到了精簡
2、切片截取引起子切片內存泄漏
func main() {
var s0 = []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
s1 := s0[:5]
}這種情況與字符串截取引起的內存泄漏情況類似，s1活躍情況下，造成s0中部分內存泄漏
解決方案：append
func main() {
var s0 = []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
s1 := append(s0[:0:0], s0[:5]...)
}append為內置函數，go源碼src/builtin/builtin.go中釋義：
// The append built-in function appends elements to the end of a slice. If
// it has sufficient capacity, the destination is resliced to accommodate the
// new elements. If it does not, a new underlying array will be allocated.
// Append returns the updated slice. It is therefore necessary to store the
// result of append, often in the variable holding the slice itself:
// slice = append(slice, elem1, elem2)
// slice = append(slice, anotherSlice...)
// As a special case, it is legal to append a string to a byte slice, like this:
// slice = append([]byte("hello "), "world"...)
func append(slice []Type, elems ...Type) []Type3、沒有重置丟失的子切片元素中的指針
func main() {
var s0 = []*int{new(int), new(int), new(int), new(int), new(int)}
s1 := s0[1:3]
}原切片元素為指針類型，原切片被截取后，丟失的子切片元素中的指針元素未被置空，導致內存泄漏
解決方案：元素置空
func main() {
var s0 = []*int{new(int), new(int), new(int), new(int), new(int)}
s0[0], s0[3], s0[4] = nil, nil, nil
s1 := s0[1:3]
}4、函數數組傳參
Go數組是值類型，賦值和函數傳參都會復制整個數組
func main() {
var arrayA = [3]int{1, 2, 3}
var arrayB = [3]int{}
arrayB = arrayA
fmt.Printf("arrayA address: %p, arrayA value: %+v\n", &arrayA, arrayA)
fmt.Printf("arrayB address: %p, arrayB value: %+v\n", &arrayB, arrayB)
array(arrayA)
}
func array(array [3]int) {
fmt.Printf("array address: %p, array value: %+v\n", &array, array)
}打印結果：
arrayA address: 0xc0000ae588, arrayA value: [1 2 3]
arrayB address: 0xc0000ae5a0, arrayB value: [1 2 3]
array address: 0xc0000ae5e8, array value: [1 2 3]
可以看到，三條打印的地址都不相同，說明數組是值傳遞的，這會導致什么問題呢？
如果我們在函數傳參的時候用到了數組傳參，且這個數組夠大（我們假設數組大小為100萬，64位機上消耗的內存約為800w字節(jié)，即8MB內存），或者該函數短時間內被調用N次，那么可想而知，會消耗大量內存，對性能產生極大的影響，如果短時間內分配大量內存，而又來不及GC，那么就會產生臨時性的內存泄漏，對于高并發(fā)場景相當可怕。
解決方案1：采用指針傳遞
func main() {
var arrayA = [3]int{1, 2, 3}
var arrayB = &arrayA
fmt.Printf("arrayA address: %p, arrayA value: %+v\n", &arrayA, arrayA)
fmt.Printf("arrayB address: %p, arrayB value: %+v\n", arrayB, *arrayB)
arrayP(&arrayA)
}
func arrayP(array *[3]int) {
fmt.Printf("array address: %p, array value: %+v\n", array, *array)
}打印結果：
arrayA address: 0xc00000e6a8, arrayA value: [1 2 3]
arrayB address: 0xc00000e6a8, arrayB value: [1 2 3]
array address: 0xc00000e6a8, array value: [1 2 3]
可以看到，三條打印的地址相同，說明指針是引用傳遞的 ，三個數組指向的都是同一塊內存，就算數組很大，或者函數短時間被調用N次，也不會產生額外的內存開銷，這樣會不會有隱患呢？
有，如果arrayA的指針地址發(fā)生變化，那么，arrayB和函數內array的指針地址也隨之改變，稍不注意，容易發(fā)生bug
解決方案2：利用切片可以很好的解決以上兩個問題
func main() {
var arrayA = [3]int{1, 2, 3}
var arrayB = arrayA[:]
fmt.Printf("arrayA address: %p, arrayA value: %+v\n", &arrayA, arrayA)
fmt.Printf("arrayB address: %p, arrayB value: %+v\n", &arrayB, arrayB)
arrayS(arrayB)
}
func arrayS(array []int) {
fmt.Printf("array address: %p, array value: %+v\n", &array, array)
}打印結果：
arrayA address: 0xc00000e6a8, arrayA value: [1 2 3]
arrayB address: 0xc0000040d8, arrayB value: [1 2 3]
array address: 0xc000004108, array value: [1 2 3]
可以看到，三條打印的地址都不相同，而切片本身是一個引用類型，arrayA和arrayB底層共享內存，不會產生額外內存開銷，而且arrayA的指針地址發(fā)生改變，arrayB的指針地址也不會改變，切片的數據結構如下：
type slice struct {
array unsafe.Pointer
len int
cap int
}5、goroutine
“Go里面10次內存泄漏有9次都是goroutine泄漏引起的”
有些編碼不當的情況下，goroutine被長期掛住，導致該協(xié)程中的內存也無法被釋放，就會造成永久性的內存泄漏。例如協(xié)程結束時協(xié)程中的channel沒有關閉，導致一直阻塞；例如協(xié)程中有死循環(huán)；等等
我們來看下
func main() {
ticker := time.NewTicker(time.Second * 1)
for {
<-ticker.C
ch := make(chan int)
go func() {
for i := 0; i < 100; i++ {
ch <- i
}
}()
for v := range ch {
if v == 50 {
break
}
}
}
}將代碼運行起來，并利用pprof工具，在web輸入http://localhost/debug/pprof/，我們可以看到，goroutine的數量隨著時間在不斷的增加，而且絲毫沒有減少的跡象
這是因為break的時候，協(xié)程中的channel并沒有關閉，導致協(xié)程一直存活，無法被回收
解決方案：
func main() {
ticker := time.NewTicker(time.Second * 1)
for {
<-ticker.C
cxt, cancel := context.WithCancel(context.Background())
ch := make(chan int)
go func(cxt context.Context) {
for i := 0; i < 100; i++ {
select {
case <-cxt.Done():
return
case ch <- i:
}
}
}(cxt)
for v := range ch {
if v == 50 {
cancel()
break
}
}
}
}利用context，在break之前cancel，目的就是通知協(xié)程退出，這樣就避免了goroutine泄漏
6、定時器
1）time.After
func main() {
ch := make(chan int)
go func() {
for {
timerC := time.After(100 * time.Second)
//timerC 每次都是重新創(chuàng)建的，什么意思呢？簡單說來，當 select 成功監(jiān)聽 ch 并進入它的處理分支，下次循環(huán) timerC 重新創(chuàng)建了，時間肯定就重置了。
select {
//如果有多個 case 都可以運行，select 會隨機公平選擇出一個執(zhí)行。其余的則不會執(zhí)行
case num := <-ch:
fmt.Println("get num is", num)
case <-timerC:
//等價于 case <-time.After(100 * time.Second)
fmt.Println("time's up!!!")
//done<-true
}
}
}()
for i := 1; i < 100000; i++ {
ch <- i
time.Sleep(time.Millisecond)
}
}以上代碼會造成內存泄漏，time.After底層實現是一個timer，而定時器未到觸發(fā)時間，該定時器不會被gc回收，從而導致臨時性的內存泄漏，而如果定時器一直在創(chuàng)建，那么就造成了永久性的內存泄漏了。
解決方案：采用timer定時器
func main() {
ch := make(chan int)
go func() {
timer := time.NewTimer(100 * time.Second)
defer timer.Stop()
for {
timer.Reset(100 * time.Second)
select {
case num := <-ch:
fmt.Println("get num is", num)
case <-timer.C:
fmt.Println("time's up!!!")
}
}
}()
for i := 1; i < 100000; i++ {
ch <- i
time.Sleep(time.Millisecond)
}
}創(chuàng)建timer定時器，每次需要啟動定時器的時候，使用Reset方法重置定時器，這樣就不用每次都要創(chuàng)建新的定時器了
2）timer、ticker
在高并發(fā)、高性能場景中，使用time.NewTimer或者time.NewTicker定時器，都需要注意及時調用Stop方法來及時釋放資源，否則可能造成臨時性或者永久性的內存泄漏。
總結
到此這篇關于Golang內存泄漏場景以及解決方案的文章就介紹到這了,更多相關Golang內存泄漏場景及解決內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
Go返回int64類型字段超出javascript Number范圍的解決方法
這篇文章主要介紹了Go返回int64類型字段超出javascript Number范圍的解決方法，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2019-07-07
sudog代表在等待隊列中的goroutine,比如channel發(fā)送接受,由于goroutine和同步對象的關系是多對多,因此需要sudog映射,本文重點介紹golang sudog指的是什么,感興趣的朋友一起看看吧2024-02-02
在Go實際開發(fā)中,并發(fā)安全是老生常談的事情,在并發(fā)下,goroutine之間的存在數據資源等方面的競爭,為了保證數據一致性、防止死鎖等問題的出現,在并發(fā)中需要使用一些方式來實現并發(fā)控制,本文給大家總結了幾種實現方式,需要的朋友可以參考下2023-12-12
在Go語言中,chan（通道）是一種用于在不同的goroutine之間進行通信的機制,通道可以是無緩沖的（同步的）或有緩沖的（異步的）,本文給大家詳細介紹了Golang中Channel的高級用法,需要的朋友可以參考下2024-05-05
quicktemplate快速、功能強大、易于使用的Go模板引擎。比html/模板快20倍，本文我們就詳細的介紹一下quicktemplate的具體使用，感興趣的可以了解一下2021-07-07
讀取文件是所有編程語言中最常見的操作之一,下面這篇文章主要給大家介紹了關于GoLang讀取文件的10種方法,文中通過實例代碼介紹的非常詳細,需要的朋友可以參考下2022-06-06
這篇文章主要介紹了Go語言在Linux環(huán)境下輸出彩色字符的方法,本文給大家介紹的非常詳細，具有一定的參考借鑒價值，需要的朋友可以參考下2019-04-04
結構體類型可以用來保存不同類型的數據，也可以通過方法的形式來聲明它的行為。本文將介紹go語言中的結構體和方法，以及“繼承”的實現方法2021-09-09
這篇文章主要介紹了golang游戲等資源壓縮包創(chuàng)建和操作,本文通過示例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2022-08-08
今天小編就為大家分享一篇關于使用go來操作redis的方法示例，小編覺得內容挺不錯的，現在分享給大家，具有很好的參考價值，需要的朋友一起跟隨小編來看看吧2019-04-04