一、我們說內(nèi)存逃逸時在說什么
- 問耻警，內(nèi)存逃逸是干什么的
- 答隔嫡，內(nèi)存逃逸分析是編譯器在編譯優(yōu)化時，用來決定變量應該分配在堆上還是棧上的工具
- 問甘穿，為什么要區(qū)分堆和棧腮恩？不都是內(nèi)存嗎？
- 答温兼，這篇也許可以解答你的疑惑秸滴，簡單來說，棧內(nèi)存是用來存儲函數(shù)出入?yún)⒑途植孔兞康哪寂校@些變量隨著函數(shù)的創(chuàng)建而創(chuàng)建缸榛、返回而消亡，棧內(nèi)存的分配是線性的兰伤，這種分配方式有極高的效率内颗。在其他語言，例如c敦腔，變量分配在哪里是由開發(fā)人員決定的均澳，例如局部變量分配在棧上，調(diào)用malloc方法分配的內(nèi)存在堆上符衔。棧內(nèi)存的分配與釋放由編譯器決定找前，堆內(nèi)存的分配與釋放則完全由開發(fā)人員決定。
- 問判族，那為什么go不能仿照c語言躺盛，讓開發(fā)人員管理堆內(nèi)存？
- 答形帮，go是一款簡單槽惫、高效的現(xiàn)代開發(fā)語言周叮，怎么還會讓開發(fā)人員自己管理內(nèi)存，太落伍了
- 所以當go要自己做內(nèi)存管理的時候界斜，內(nèi)存的分配和釋放就交給了go運行時
- 變量到底要分配到棧還是堆上仿耽，變成了go語言需要處理的事情。一方面棧內(nèi)存分配效率極高各薇，另一方面堆內(nèi)存gc又影響效率项贺。所以盡可能讓變量分配在棧上。
- ok峭判，暫時信你？小！那么內(nèi)存逃逸分析就是為了盡量讓變量找到正確的家林螃？（棧上或者堆上）
- 聰明啥箭！都學會搶答了
- 開發(fā)人員自己決定變量分配到哪兒，要么將本不用分配到堆上的變量分配到了堆上（低效Ｖ涡）急侥，要么將需要分配到堆上的變量分配在了棧上（野指針！）
- go的內(nèi)存逃逸分析同樣也面臨上面兩個問題侮邀，它盡量將變量分配的位置安排得明明白白的
- 問坏怪，既然go已經(jīng)在編譯時做了內(nèi)存逃逸分析，我們作為開發(fā)人員還關心這個干什么绊茧？
- 為了炫技铝宵！O(∩_∩)O哈哈~
- 了解了內(nèi)存逃逸分析的原理后，我們就能夠理解什么樣的變量會被分配在棧上华畏、什么樣的變量會被分配在堆上鹏秋。
- 當你的程序?qū)π阅芊浅Ｃ舾校憔涂梢允褂脙?nèi)存逃逸工具的分析亡笑，查看哪些變量逃逸到了堆上侣夷，哪些沒有逃逸。然后調(diào)整代碼仑乌，再次提高你得程序性能
- 問百拓，我的程序就是增刪改查，不需要性能
- 門在那邊 →
- 問晰甚，怎么進行內(nèi)存逃逸分析衙传？
- 答，go在編譯時會進行內(nèi)存逃逸分析厕九，同樣也給開發(fā)人員開放了內(nèi)存逃逸信息
- 在編譯時增加-m標志蓖捶，如
go build -gcflags="-m"，就會輸出內(nèi)存逃逸信息 - 下面我們會對幾種常見的內(nèi)存逃逸情況進行測試和分析
二扁远、幾種常見的內(nèi)存逃逸情況
原生類型的逃逸分析
1. 變量分配在棧上的情況
當原生類型被取地址且地址被賦值給了一個指針變量俊鱼，當這個指針變量只是在函數(shù)內(nèi)部使用刻像，則這個原生類型會被分配在棧上（即使是通過new方法分配的）
2. 變量逃逸到堆上的情況
如果這個指針變量被以某種形式作為了函數(shù)返回值（例如，指針變量是struct中的變量亭引，struct是函數(shù)返回值），則這個原生類型被分配在堆上（原因很簡單皮获，如果分配在棧上焙蚓，函數(shù)返回后棧中的數(shù)據(jù)失效，這個指針指向的地址就是無效的）
上代碼
main.go
package main
type (
Foo struct {
A int
B string
}
FooHasPointer struct {
A *int
B string
}
)
// 返回了指向了a的指針洒宝，a逃逸到堆上
func escapeValue() *int {
var a int // moved to heap: a
a = 1
return &a
}
// 即使newa是指針類型购公，但是它只在本函數(shù)內(nèi)起作用（沒有被作為返回值，相當于一個局部變量）雁歌，分配到棧上
func noescapeNew() {
newa := new(int) // noescapeNew new(int) does not escape
*newa = 1
}
// 指向i的指針被存儲到foo結(jié)構(gòu)體中返回了宏浩，i逃逸到堆上
func escapePointer() FooHasPointer {
var foo FooHasPointer
i := 10 //moved to heap: i
foo.A = &i
foo.B = "a"
return foo
}
// 沒有指針，都分配到棧上
func noescapeValue() Foo {
var foo Foo
i := 10
foo.A = i
foo.B = "a"
return foo
}
func main() {
}
執(zhí)行編譯靠瞎，并且附加-m內(nèi)存逃逸分析標志和-l（L的小寫）禁止內(nèi)聯(lián)標志
go build -gcflags "-m -l" main.go
結(jié)果如下：
.\main.go:17:6: moved to heap: a
.\main.go:24:13: noescapeNew new(int) does not escape
.\main.go:31:2: moved to heap: i
slice類型的逃逸分析
與原生類型的逃逸分析相似比庄，當返回指向slice的指針時，slice逃逸乏盐；當返回slice時佳窑，只有slice中的數(shù)據(jù)逃逸
slice的逃逸分為slice本身（即SliceHeader）的逃逸分析，和slice中的元素（即SliceHeader中Data指向的地址）的逃逸分析
1. SliceHeader分配在棧上父能、Data分配在堆上
當SliceHeader分配在棧上神凑，Data既可以分配在棧上也可以分配在堆上
- 當Data的空間不足、需要動態(tài)擴容時何吝，Data會被分配在堆上
- 當初始化slice時溉委，Data所占空間達到64K時，SliceHeader和Data都會被分配在堆上（注意這里的64K邊界是在自己的windows和linux機上測試到的爱榕，沒有找go源碼的出處瓣喊，有可能不準確，理解為Data比較大時會直接分配在堆上比較好黔酥。另外除了slice型宝，其他的數(shù)據(jù)類型如果初始化大小超過某個閾值時，應該也會直接分配在堆上）
2. 當SliceHeader分配在堆上絮爷，SliceHeader和Data都分配在堆上
上代碼
package main
import (
"reflect"
"strconv"
"unsafe"
)
// sl為局部變量趴酣，SliceHeader沒有逃逸，Data由于動態(tài)擴容分配在了堆上
func noEscapeSliceWithDataInHeap() {
var sl []byte
println("addr of local(no escape, data in heap) slice = ", &sl)
printSliceHeader(&sl)
for i := 0; i < 10; i++ {
println("append " + strconv.Itoa(i))
sl = append(sl, byte(i))
printSliceHeader(&sl)
}
}
// sl為局部變量坑夯，SliceHeader沒有逃逸桃犬，Data不需要動態(tài)擴容，分配在棧上
func noEscapeSliceWithDataInStack() {
sl := make([]byte, 0, 10) // noEscapeSliceWithDataInStack make([]byte, 0, 10) does not escape
println("addr of local(no escape, data in stack) slice = ", &sl)
printSliceHeader(&sl)
for i := 0; i < 10; i++ {
println("append " + strconv.Itoa(i))
sl = append(sl, byte(i))
printSliceHeader(&sl)
}
}
// Data過大蚂踊，SliceHeader和Data直接分配在堆上
func escapeLargeSlice() {
sl := make([]byte, 0, 1024*64) //make([]byte, 0, 1024 * 64) escapes to heap
println("addr of local(escape, data in heap) slice = ", &sl)
printSliceHeader(&sl)
for i := 0; i < 10; i++ {
println("append " + strconv.Itoa(i))
sl = append(sl, byte(i))
printSliceHeader(&sl)
}
}
// Data沒有達到64k，沒有逃逸
func noescapeSmallSlice() {
sl := make([]byte, 0, 1024*63+1023) // noescapeSmallSlice make([]byte, 0, 1024 * 63 + 1023) does not escape
println("addr of local(no escape, data in stack) slice = ", &sl)
printSliceHeader(&sl)
for i := 0; i < 10; i++ {
println("append " + strconv.Itoa(i))
sl = append(sl, byte(i))
printSliceHeader(&sl)
}
}
// 返回了sl的指針指巡，SliceHeader和Data都逃逸了
func escapeSliceWithDataInHeap() *[]byte {
sl := make([]byte, 0, 10) //moved to heap: sl // make([]byte, 0, 5) escapes to heap
println("addr of local(slice and data in heap) slice = ", &sl)
printSliceHeader(&sl)
for i := 0; i < 10; i++ {
println("append " + strconv.Itoa(i))
sl = append(sl, byte(i))
printSliceHeader(&sl)
}
return &sl
}
// sl作為返回值，SliceHeader沒有逃逸隶垮，Data逃逸
func sliceInStackWithDataInHeap() []byte {
sl := make([]byte, 0, 10) //make([]byte, 0, 5) escapes to heap
println("addr of local(slice in stack and data in heap) slice = ", &sl)
printSliceHeader(&sl)
for i := 0; i < 10; i++ {
println("append " + strconv.Itoa(i))
sl = append(sl, byte(i))
printSliceHeader(&sl)
}
return sl
}
func printSliceHeader(p *[]byte) {
ph := (*reflect.SliceHeader)(unsafe.Pointer(p))
println("slice data = ", unsafe.Pointer(ph.Data))
}
func main() {
noEscapeSliceWithDataInHeap()
noEscapeSliceWithDataInStack()
escapeLargeSlice()
noescapeSmallSlice()
escapeSliceWithDataInHeap()
sliceInStackWithDataInHeap()
}
執(zhí)行編譯藻雪，并且附加-m內(nèi)存逃逸分析標志和-l禁止內(nèi)聯(lián)標志
go build -gcflags "-m -l" main.go
結(jié)果如下：
.\main.go:83:23: printSliceHeader p does not escape
.\main.go:15:21: noEscapeSliceWithDataInHeap "append " + strconv.Itoa(i) does not escape
.\main.go:23:12: noEscapeSliceWithDataInStack make([]byte, 0, 10) does not escape
.\main.go:27:21: noEscapeSliceWithDataInStack "append " + strconv.Itoa(i) does not escape
.\main.go:35:12: make([]byte, 0, 1024 * 64) escapes to heap
.\main.go:39:21: escapeLargeSlice "append " + strconv.Itoa(i) does not escape
.\main.go:47:12: noescapeSmallSlice make([]byte, 0, 1024 * 63 + 1023) does not escape
.\main.go:51:21: noescapeSmallSlice "append " + strconv.Itoa(i) does not escape
.\main.go:59:2: moved to heap: sl
.\main.go:59:12: make([]byte, 0, 10) escapes to heap
.\main.go:63:21: escapeSliceWithDataInHeap "append " + strconv.Itoa(i) does not escape
.\main.go:72:12: make([]byte, 0, 10) escapes to heap
.\main.go:76:21: sliceInStackWithDataInHeap "append " + strconv.Itoa(i) does not escape
map類型的逃逸分析
1. 不作為函數(shù)返回值時，分配在棧上
2. 作為函數(shù)返回值且返回的不是指針時狸吞，map的元素分配在堆上勉耀，map本身分配在棧上
3. 作為函數(shù)返回值且返回的是指針時，map的元素分配在堆上蹋偏，map本身也分配在堆上
上代碼
package main
func noEscapeMap() {
sm := make(map[int]int) //noEscapeMap make(map[int]int) does not escape
sm[1] = 1
}
func escapeMap() map[int]int {
sm := make(map[int]int) // make(map[int]int) escapes to heap
sm[1] = 1
return sm
}
func escapeMapPointer() *map[int]int {
sm := make(map[int]int) // moved to heap: sm // make(map[int]int) escapes to heap
sm[1] = 1
return &sm
}
func main() {
noEscapeMap()
escapeMap()
}
執(zhí)行編譯便斥，并且附加-m內(nèi)存逃逸分析標志和-l禁止內(nèi)聯(lián)標志
go build -gcflags "-m -l" main.go
結(jié)果如下：
.\main.go:4:12: noEscapeMap make(map[int]int) does not escape
.\main.go:9:12: make(map[int]int) escapes to heap
.\main.go:15:2: moved to heap: sm
.\main.go:15:12: make(map[int]int) escapes to heap
三、后話
最后祭出go逃逸分析要遵循的兩個不變性：
- 指向棧對象的指針不能存在于堆中
- 指向棧對象的指針不能在棧對象回收后存活
經(jīng)過上面的分析和測試威始，這兩條不變性也就很好理解了枢纠，懂得都懂!
友情提示
內(nèi)存逃逸go在編譯的時候就已經(jīng)為我們優(yōu)化好了，學習它是為了將性能提高至極致以及熟悉一些稍底層的知識黎棠。普通的代碼不需要在逃不逃逸上杠晋渺。
