什么是內(nèi)存逃逸分析

內(nèi)存逃逸分析是go的編譯器在編譯期間，根據(jù)變量的類型和作用域，確定變量是堆上還是棧上

簡(jiǎn)單說(shuō)就是編譯器在編譯期間，對(duì)代碼進(jìn)行分析，確定變量分配內(nèi)存的位置。如果變量需要分配在堆上，則稱作內(nèi)存逃逸了。

為什么需要逃逸分析

因?yàn)間o語(yǔ)言是自動(dòng)自動(dòng)內(nèi)存管理的，也就是有GC的。開(kāi)發(fā)者在寫(xiě)代碼的時(shí)候不需要關(guān)心考慮內(nèi)存釋放的問(wèn)題，這樣編譯器和go運(yùn)行時(shí)（runtime）就需要準(zhǔn)確分配和管理內(nèi)存，所以編譯器在編譯期間要確定變量是放在堆空間和?？臻g。

如果變量放錯(cuò)了位置會(huì)怎樣

我們知道，棧空間和生命周期是和函數(shù)生命周期相關(guān)的，如果一個(gè)函數(shù)的局部變量離開(kāi)了函數(shù)的范圍，比如函數(shù)結(jié)束時(shí)，局部變量就會(huì)失效。所以要把這樣的變量放到堆空間上。

既然如此，那把所有在變量都放在堆上不就行了，這樣一來(lái)，是沒(méi)啥問(wèn)題了，但是堆內(nèi)存的使用成本比占內(nèi)存要高好多。使用堆內(nèi)存，要向操作系統(tǒng)申請(qǐng)和歸還，而占內(nèi)存是程序運(yùn)行時(shí)就確定好了，如何使用完全由程序自己確定。在棧上分配和回收內(nèi)存成本很低，只需要 2 個(gè) CPU 指令：PUSH 和 POP，push 將數(shù)據(jù)放到到?？臻g完成分配，pop 則是釋放空間。

比如 C++ 經(jīng)典錯(cuò)誤，return 一個(gè) 函數(shù)內(nèi)部變量的指針

#include<iostream>

int* one(){
    int i = 10;
    return &i;
}

int main(){
    std::cout << *one();
}

這段代碼在編譯的時(shí)候會(huì)如下警告:

one.cpp: 在函數(shù)‘int* one()’中:
one.cpp:4:6: 警告：返回了局部變量的‘i’的地址 [-Wreturn-local-addr]
  int i = 10;
      ^

雖然程序的運(yùn)行結(jié)果大多數(shù)時(shí)候都和我們預(yù)期的一樣，但是這樣的代碼還是有風(fēng)險(xiǎn)的。

這樣的代碼在go里就完全沒(méi)有問(wèn)題了，因?yàn)間o的編譯器會(huì)根據(jù)變量的作用范圍確定變量是放在棧上和堆上。

內(nèi)存逃逸場(chǎng)景

go的編譯器提供了逃逸分析的工具，只需要在編譯的時(shí)候加上 -gcflags=-m 就可以看到逃逸分析的結(jié)果了

常見(jiàn)的有4種場(chǎng)景下會(huì)出現(xiàn)內(nèi)存逃逸

return 局部變量的指針

package main

func main() {

}

func One() *int {
   i := 10
   return &i
}

執(zhí)行 go build -gcflags=-m main.go

# command-line-arguments
.\main.go:3:6: can inline main
.\main.go:7:6: can inline One
.\main.go:8:2: moved to heap: i

可以看到變量 i 已經(jīng)被分配到堆上了

interface{} 動(dòng)態(tài)類型

當(dāng)函數(shù)傳遞的變量類型是 interface{} 類型的時(shí)候，因?yàn)榫幾g器無(wú)法推斷運(yùn)行時(shí)變量的實(shí)際類型，所以也會(huì)發(fā)生逃逸

package main

import "fmt"

func main() {
   i := 10
   fmt.Println(i)
}

執(zhí)行 go build -gcflags=-m .\main.go

.\main.go:11:13: inlining call to fmt.Println
.\main.go:11:13: i escapes to heap
.\main.go:11:13: []interface {} literal does not escape
<autogenerated>:1: .this does not escape
<autogenerated>:1: .this does not escape

可看到，i 也被分配到棧上了

?？臻g不足

因?yàn)闂５目臻g是有限的，所以在分配大塊內(nèi)存時(shí)，會(huì)考慮?？臻g內(nèi)否存下，如果?？臻g存不下，會(huì)分配到堆上。

package main

func main() {
   Make10()
   Make100()
   Make10000()
   MakeN(5)
}

func Make10() {
   arr10 := make([]int, 10)
   _ = arr10
}

func Make100() {
   arr100 := make([]int, 100)
   _ = arr100
}

func Make10000() {
   arr10000 := make([]int, 10000)
   _ = arr10000
}

func MakeN(n int) {
   arrN := make([]int, n)
   _ = arrN
}

執(zhí)行 go build -gcflags=-m main.go

# command-line-arguments
.\main.go:10:6: can inline Make10
.\main.go:15:6: can inline Make100
.\main.go:20:6: can inline Make10000
.\main.go:25:6: can inline MakeN
.\main.go:3:6: can inline main
.\main.go:4:8: inlining call to Make10
.\main.go:5:9: inlining call to Make100
.\main.go:6:11: inlining call to Make10000
.\main.go:7:7: inlining call to MakeN
.\main.go:4:8: make([]int, 10) does not escape
.\main.go:5:9: make([]int, 100) does not escape
.\main.go:6:11: make([]int, 10000) escapes to heap
.\main.go:7:7: make([]int, n) escapes to heap
.\main.go:11:15: make([]int, 10) does not escape
.\main.go:16:16: make([]int, 100) does not escape
.\main.go:21:18: make([]int, 10000) escapes to heap
.\main.go:26:14: make([]int, n) escapes to heap

可以看到當(dāng)需要分配長(zhǎng)度為10，100的int類型的slice時(shí)，不需要逃逸到堆上，在棧上就可以，如果slice長(zhǎng)度達(dá)到1000時(shí)，就需要分配到堆上了。

還有一種情況，當(dāng)在編譯期間長(zhǎng)度不確定時(shí)，也需要分配到堆上。

閉包

package main

func main() {
   One()
}

func One() func() {
   n := 10
   return func() {
      n++
   }
}

在函數(shù)One中return了一個(gè)匿名函數(shù)，形成了一個(gè)閉包，看一下逃逸分析

# command-line-arguments
.\main.go:3:6: can inline main
.\main.go:9:9: can inline One.func1
.\main.go:8:2: moved to heap: n
.\main.go:9:9: func literal escapes to heap

可以看到 變量 n 也分配到堆上了

還有一種情況，new 出來(lái)的變量不一定分配到堆上

package main

func main() {
   i := new(int)
   _ = i
}

像java C++等語(yǔ)言，new 出來(lái)的變量正常都會(huì)分配到堆上，但是在go里，new出來(lái)的變量不一定分配到堆上，至于分配到哪里，還是看編譯器的逃逸分析來(lái)確定

編譯一下看看 go build -gcflags=-m main.go

# command-line-arguments
.\main.go:3:6: can inline main
.\main.go:4:10: new(int) does not escape

可以看到 new出來(lái)的變量，并沒(méi)有逃逸，還是在棧上。

常見(jiàn)的內(nèi)存逃逸場(chǎng)景差不多就是這些了，再說(shuō)一下內(nèi)存逃逸帶來(lái)的影響吧

性能

那肯定就是性能問(wèn)題了，因?yàn)椴僮鳁？臻g比堆空間要快多了，而且使用堆空間還會(huì)有GC問(wèn)題，頻繁的創(chuàng)建和釋放堆空間，會(huì)增加GC的壓力

一個(gè)簡(jiǎn)單的例子測(cè)試一下，一般來(lái)說(shuō)，函數(shù)返回結(jié)構(gòu)體的指針比直接返回結(jié)構(gòu)體性能要好

package main

import "testing"

type MyStruct struct {
   A int
}

func BenchmarkOne(b *testing.B) {
   for i := 0; i < b.N; i++ {
      One()
   }
}

//go:noinline
func One() MyStruct {
   return MyStruct{
      A: 10,
   }
}

func BenchmarkTwo(b *testing.B) {
   for i := 0; i < b.N; i++ {
      Two()
   }
}

//go:noinline
func Two() *MyStruct {
   return &MyStruct{
      A: 10,
   }
}

注意 被調(diào)用的函數(shù)一定要加上 //go:noinline 來(lái)禁止編譯器內(nèi)聯(lián)優(yōu)化

然后執(zhí)行

go test -bench . -benchmem

goos: windows
goarch: amd64
pkg: escape
BenchmarkOne-6          951519297                1.26 ns/op            0 B/op          0 allocs/op
BenchmarkTwo-6          74933496                15.4 ns/op             8 B/op          1 allocs/op
PASS
ok      escape  2.698s

可以明顯看到 函數(shù) One返回結(jié)構(gòu)體 比 函數(shù)Two 返回 結(jié)構(gòu)體指針 的性能更好，而且還不會(huì)有內(nèi)存分配，不會(huì)增加GC壓力

拋開(kāi)結(jié)構(gòu)體的大小談性能都是耍流氓，如果結(jié)構(gòu)體比較復(fù)雜了還是指針性能更高，還有一些場(chǎng)景必須使用指針，所以實(shí)際工作中還是要分場(chǎng)景合理使用

最后

常見(jiàn)的go 逃逸分析差不多就是這些了，雖然go會(huì)自動(dòng)管理內(nèi)存，減小了寫(xiě)代碼的負(fù)擔(dān)，但是想要寫(xiě)出高效可靠的代碼還是有一些細(xì)節(jié)有注意的。

以上就是淺析Golang中的內(nèi)存逃逸的詳細(xì)內(nèi)容，更多關(guān)于Golang內(nèi)存逃逸的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

最新評(píng)論