自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

面試官：小松子來聊一聊內(nèi)存逃逸

作者：AsongGo
開發(fā) 后端
初次看到這個話題，我是懵逼的，怎么還有內(nèi)存逃逸，內(nèi)存逃逸到底是干什么的?接下來我們一起來看看什么是內(nèi)存逃逸。

[[414656]]

本文轉(zhuǎn)載自微信公眾號「Golang夢工廠」，作者AsongGo。轉(zhuǎn)載本文請聯(lián)系Golang夢工廠公眾號。

前言

哈嘍，大家好，我是asong。最近無聊看了一下Go語言的面試八股文，發(fā)現(xiàn)面試官都喜歡問內(nèi)存逃逸這個話題，這個激起了我的興趣，我對內(nèi)存逃逸的了解很淺，所以找了很多文章精讀了一下，在這里做一個總結(jié)，方便日后查閱、學(xué)習(xí)。

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

初次看到這個話題，我是懵逼的，怎么還有內(nèi)存逃逸，內(nèi)存逃逸到底是干什么的?接下來我們一起來看看什么是內(nèi)存逃逸。

我們都知道一般情況下程序存放在rom或者Flash中，運行時需要拷貝到內(nèi)存中執(zhí)行，內(nèi)存會分別存儲不同的信息，內(nèi)存空間包含兩個最重要的區(qū)域：堆區(qū)(Stack)和棧區(qū)(Heap)，對于我這種C語言出身的人，對堆內(nèi)存和棧內(nèi)存的了解還是挺深的。在C語言中，棧區(qū)域會專門存放函數(shù)的參數(shù)、局部變量等，棧的地址從內(nèi)存高地址往低地址增長，而堆內(nèi)存正好相反，堆地址從內(nèi)存低地址往高地址增長，但是如果我們想在堆區(qū)域分配內(nèi)存需要我們手動調(diào)用malloc函數(shù)去堆區(qū)域申請內(nèi)存分配，然后我使用完了還需要自己手動釋放，如果沒有釋放就會導(dǎo)致內(nèi)存泄漏。寫過C語言的朋友應(yīng)該都知道C語言函數(shù)是不能返回局部變量地址(特指存放于棧區(qū)的局部變量地址)，除非是局部靜態(tài)變量地址，字符串常量地址、動態(tài)分配地址。其原因是一般局部變量的作用域只在函數(shù)內(nèi)，其存儲位置在棧區(qū)中，當(dāng)程序調(diào)用完函數(shù)后，局部變量會隨此函數(shù)一起被釋放。其地址指向的內(nèi)容不明(原先的數(shù)值可能不變，也可能改變)。而局部靜態(tài)變量地址和字符串常量地址存放在數(shù)據(jù)區(qū)，動態(tài)分配地址存放在堆區(qū)，函數(shù)運行結(jié)束后只會釋放棧區(qū)的內(nèi)容，而不會改變數(shù)據(jù)區(qū)和堆區(qū)。

所以在C語言中我們想在一個函數(shù)中返回局部變量地址時，有三個正確的方式：返回靜態(tài)局部變量地址、返回字符串常量地址，返回動態(tài)分配在堆上的地址，因為他們都不在棧區(qū)，即使釋放函數(shù)，其內(nèi)容也不會受影響，我們以在返回堆上內(nèi)存地址為例看一段代碼：

  1. #include "stdio.h" 
  2. #include "stdlib.h" 
  3. //返回動態(tài)分配的地址  
  4. int* f1() 
  5. { 
  6.     int a = 9; 
  7.     int *pa = (int*) malloc(8); 
  8.     *pa = a; 
  9.     return pa; 
  10. } 
  11.  
  12. int main() 
  13. { 
  14.     int *pb; 
  15.     pb = f1(); 
  16.     printf("after : *pb = %d\tpb = %p\n",*pb, pb); 
  17.     free(pb); 
  18.     return 1; 
  19. } 

通過上面的例子我們知道在C語言中動態(tài)內(nèi)存的分配與釋放完全交與程序員的手中，這樣就會導(dǎo)致我們在寫程序時如履薄冰，好處是我們可以完全掌控內(nèi)存，缺點是我們一不小心就會導(dǎo)致內(nèi)存泄漏，所以很多現(xiàn)代語言都有GC機制，Go就是一門帶垃圾回收的語言，真正解放了我們程序員的雙手，我們不需要在像寫C語言那樣考慮是否能返回局部變量地址了，內(nèi)存管理交與給編譯器，編譯器會經(jīng)過逃逸分析把變量合理的分配到"正確"的地方。

說到這里，可以簡單總結(jié)一下什么是內(nèi)存逃逸了：

在一段程序中，每一個函數(shù)都會有自己的內(nèi)存區(qū)域存放自己的局部變量、返回地址等，這些內(nèi)存會由編譯器在棧中進行分配，每一個函數(shù)都會分配一個棧楨，在函數(shù)運行結(jié)束后進行銷毀，但是有些變量我們想在函數(shù)運行結(jié)束后仍然使用它，那么就需要把這個變量在堆上分配，這種從"棧"上逃逸到"堆"上的現(xiàn)象就成為內(nèi)存逃逸。

什么是逃逸分析

上面我們知道了什么是內(nèi)存逃逸，下面我們就來看一看什么是逃逸分析?

上文我們說到C語言使用malloc在堆上動態(tài)分配內(nèi)存后，還需要手動調(diào)用free釋放內(nèi)存，如果不釋放就會造成內(nèi)存泄漏的風(fēng)險。在Go語言中堆內(nèi)存的分配與釋放完全不需要我們?nèi)ス芰耍珿o語言引入了GC機制，GC機制會對位于堆上的對象進行自動管理，當(dāng)某個對象不可達時(即沒有其對象引用它時)，他將會被回收并被重用。雖然引入GC可以讓開發(fā)人員降低對內(nèi)存管理的心智負(fù)擔(dān)，但是GC也會給程序帶來性能損耗，當(dāng)堆內(nèi)存中有大量待掃描的堆內(nèi)存對象時，將會給GC帶來過大的壓力，雖然Go語言使用的是標(biāo)記清除算法，并且在此基礎(chǔ)上使用了三色標(biāo)記法和寫屏障技術(shù)，提高了效率，但是如果我們的程序仍在堆上分配了大量內(nèi)存，依賴會對GC造成不可忽視的壓力。因此為了減少GC造成的壓力，Go語言引入了逃逸分析，也就是想法設(shè)法盡量減少在堆上的內(nèi)存分配，可以在棧中分配的變量盡量留在棧中。

小結(jié)逃逸分析：

逃逸分析就是指程序在編譯階段根據(jù)代碼中的數(shù)據(jù)流，對代碼中哪些變量需要在棧中分配，哪些變量需要在堆上分配進行靜態(tài)分析的方法。堆和棧相比，堆適合不可預(yù)知大小的內(nèi)存分配。但是為此付出的代價是分配速度較慢，而且會形成內(nèi)存碎片。棧內(nèi)存分配則會非常快。棧分配內(nèi)存只需要兩個CPU指令：“PUSH”和“RELEASE”，分配和釋放;而堆分配內(nèi)存首先需要去找到一塊大小合適的內(nèi)存塊，之后要通過垃圾回收才能釋放。所以逃逸分析更做到更好內(nèi)存分配，提高程序的運行速度。

Go語言中的逃逸分析

Go語言的逃逸分析總共實現(xiàn)了兩個版本：

  • 1.13版本前是第一版
  • 1.13版本后是第二版

粗略看了一下逃逸分析的代碼，大概有1500+行(go1.15.7)。代碼我倒是沒仔細(xì)看，注釋我倒是仔細(xì)看了一遍，注釋寫的還是很詳細(xì)的，代碼路徑：src/cmd/compile/internal/gc/escape.go，大家可以自己看一遍注釋，其逃逸分析原理如下：

  • pointers to stack objects cannot be stored in the heap：指向棧對象的指針不能存儲在堆中
  • pointers to a stack object cannot outlive that object：指向棧對象的指針不能超過該對象的存活期，也就說指針不能在棧對象被銷毀后依舊存活。(例子：聲明的函數(shù)返回并銷毀了對象的棧幀，或者它在循環(huán)迭代中被重復(fù)用于邏輯上不同的變量)

我們大概知道它的分析準(zhǔn)則是什么就好了，具體逃逸分析是怎么做的，感興趣的同學(xué)可以根據(jù)源碼自行研究。

既然逃逸分析是在編譯階段進行的，那我們就可以通過go build -gcflags '-m -m -l'命令查看到逃逸分析的結(jié)果，我們之前在分析內(nèi)聯(lián)優(yōu)化時使用的-gcflags '-m -m'，能看到所有的編譯器優(yōu)化，這里使用-l禁用掉內(nèi)聯(lián)優(yōu)化，只關(guān)注逃逸優(yōu)化就好了。

現(xiàn)在我們也知道了逃逸分析，接下來我們就看幾個逃逸分析的例子。

幾個逃逸分析的例子

1. 函數(shù)返回局部指針變量

先看例子：

  1. #include "stdio.h" 
  2. #include "stdlib.h" 
  3. //返回動態(tài)分配的地址  
  4. int* f1() 
  5. { 
  6.     int a = 9; 
  7.     int *pa = (int*) malloc(8); 
  8.     *pa = a; 
  9.     return pa; 
  10. } 
  11.  
  12. int main() 
  13. { 
  14.     int *pb; 
  15.     pb = f1(); 
  16.     printf("after : *pb = %d\tpb = %p\n",*pb, pb); 
  17.     free(pb); 
  18.     return 1; 
  19. } 

查看逃逸分析結(jié)果：

  1. go build -gcflags="-m -m -l" ./test1.go 
  2. # command-line-arguments 
  3. ./test1.go:6:9: &res escapes to heap 
  4. ./test1.go:6:9:         from ~r2 (return) at ./test1.go:6:2 
  5. ./test1.go:4:2: moved to heap: res 

分析結(jié)果很明了，函數(shù)返回的局部變量是一個指針變量，當(dāng)函數(shù)Add執(zhí)行結(jié)束后，對應(yīng)的棧楨就會被銷毀，但是引用已經(jīng)返回到函數(shù)之外，如果我們在外部解引用地址，就會導(dǎo)致程序訪問非法內(nèi)存，就像上面的C語言的例子一樣，所以編譯器經(jīng)過逃逸分析后將其在堆上分配內(nèi)存。

2. interface類型逃逸

先看一個例子：

  1. func main()  { 
  2.  str := "asong太帥了吧" 
  3.  fmt.Printf("%v",str) 
  4. } 

查看逃逸分析結(jié)果：

  1. go build -gcflags="-m -m -l" ./test2.go  
  2. # command-line-arguments 
  3. ./test2.go:9:13: str escapes to heap 
  4. ./test2.go:9:13:        from ... argument (arg to ...) at ./test2.go:9:13 
  5. ./test2.go:9:13:        from *(... argument) (indirection) at ./test2.go:9:13 
  6. ./test2.go:9:13:        from ... argument (passed to call[argument content escapes]) at ./test2.go:9:13 
  7. ./test2.go:9:13: main ... argument does not escape 

str是main函數(shù)中的一個局部變量，傳遞給fmt.Println()函數(shù)后發(fā)生了逃逸，這是因為fmt.Println()函數(shù)的入?yún)⑹且粋€interface{}類型，如果函數(shù)參數(shù)為interface{}，那么在編譯期間就很難確定其參數(shù)的具體類型，也會發(fā)送逃逸。

觀察這個分析結(jié)果，我們可以看到?jīng)]有moved to heap: str，這也就是說明str變量并沒有在堆上進行分配，只是它存儲的值逃逸到堆上了，也就說任何被str引用的對象必須分配在堆上。如果我們把代碼改成這樣：

  1. func main()  { 
  2.  str := "asong太帥了吧" 
  3.  fmt.Printf("%p",&str) 
  4. } 

查看逃逸分析結(jié)果：

  1. go build -gcflags="-m -m -l" ./test2.go 
  2. # command-line-arguments 
  3. ./test2.go:9:18: &str escapes to heap 
  4. ./test2.go:9:18:        from ... argument (arg to ...) at ./test2.go:9:12 
  5. ./test2.go:9:18:        from *(... argument) (indirection) at ./test2.go:9:12 
  6. ./test2.go:9:18:        from ... argument (passed to call[argument content escapes]) at ./test2.go:9:12 
  7. ./test2.go:9:18: &str escapes to heap 
  8. ./test2.go:9:18:        from &str (interface-converted) at ./test2.go:9:18 
  9. ./test2.go:9:18:        from ... argument (arg to ...) at ./test2.go:9:12 
  10. ./test2.go:9:18:        from *(... argument) (indirection) at ./test2.go:9:12 
  11. ./test2.go:9:18:        from ... argument (passed to call[argument content escapes]) at ./test2.go:9:12 
  12. ./test2.go:8:2: moved to heap: str 
  13. ./test2.go:9:12: main ... argument does not escape 

這回str也逃逸到了堆上，在堆上進行內(nèi)存分配，這是因為我們訪問str的地址，因為入?yún)⑹莍nterface類型，所以變量str的地址以實參的形式傳入fmt.Printf后被裝箱到一個interface{}形參變量中，裝箱的形參變量的值要在堆上分配，但是還要存儲一個棧上的地址，也就是str的地址，堆上的對象不能存儲一個棧上的地址，所以str也逃逸到堆上，在堆上分配內(nèi)存。(這里注意一個知識點：Go語言的參數(shù)傳遞只有值傳遞)

3. 閉包產(chǎn)生的逃逸

  1. func Increase() func() int { 
  2.  n := 0 
  3.  return func() int { 
  4.   n++ 
  5.   return n 
  6.  } 
  7. } 
  8.  
  9. func main() { 
  10.  in := Increase() 
  11.  fmt.Println(in()) // 1 
  12. } 

查看逃逸分析結(jié)果：

  1. go build -gcflags="-m -m -l" ./test3.go 
  2. # command-line-arguments 
  3. ./test3.go:10:3: Increase.func1 capturing by ref: n (addr=true assign=true width=8) 
  4. ./test3.go:9:9: func literal escapes to heap 
  5. ./test3.go:9:9:         from ~r0 (assigned) at ./test3.go:7:17 
  6. ./test3.go:9:9: func literal escapes to heap 
  7. ./test3.go:9:9:         from &(func literal) (address-of) at ./test3.go:9:9 
  8. ./test3.go:9:9:         from ~r0 (assigned) at ./test3.go:7:17 
  9. ./test3.go:10:3: &n escapes to heap 
  10. ./test3.go:10:3:        from func literal (captured by a closure) at ./test3.go:9:9 
  11. ./test3.go:10:3:        from &(func literal) (address-of) at ./test3.go:9:9 
  12. ./test3.go:10:3:        from ~r0 (assigned) at ./test3.go:7:17 
  13. ./test3.go:8:2: moved to heap: n 
  14. ./test3.go:17:16: in() escapes to heap 
  15. ./test3.go:17:16:       from ... argument (arg to ...) at ./test3.go:17:13 
  16. ./test3.go:17:16:       from *(... argument) (indirection) at ./test3.go:17:13 
  17. ./test3.go:17:16:       from ... argument (passed to call[argument content escapes]) at ./test3.go:17:13 
  18. ./test3.go:17:13: main ... argument does not escape 

因為函數(shù)也是一個指針類型，所以匿名函數(shù)當(dāng)作返回值時也發(fā)生了逃逸，在匿名函數(shù)中使用外部變量n，這個變量n會一直存在直到in被銷毀，所以n變量逃逸到了堆上。

4. 變量大小不確定及棧空間不足引發(fā)逃逸

我們先使用ulimit -a查看操作系統(tǒng)的?？臻g：

  1. ulimit -a 
  2. -t: cpu time (seconds)              unlimited 
  3. -f: file size (blocks)              unlimited 
  4. -d: data seg size (kbytes)          unlimited 
  5. -s: stack size (kbytes)             8192 
  6. -c: core file size (blocks)         0 
  7. -v: address space (kbytes)          unlimited 
  8. -l: locked-in-memory size (kbytes)  unlimited 
  9. -u: processes                       2784 
  10. -n: file descriptors                256 

我的電腦的?？臻g大小是8192，所以根據(jù)這個我們寫一個測試用例：

  1. package main 
  2.  
  3. import ( 
  4.  "math/rand" 
  5. ) 
  6.  
  7. func LessThan8192()  { 
  8.  nums := make([]int, 100) // = 64KB 
  9.  for i := 0; i < len(nums); i++ { 
  10.   nums[i] = rand.Int() 
  11.  } 
  12. } 
  13.  
  14.  
  15. func MoreThan8192(){ 
  16.  nums := make([]int, 1000000) // = 64KB 
  17.  for i := 0; i < len(nums); i++ { 
  18.   nums[i] = rand.Int() 
  19.  } 
  20. } 
  21.  
  22.  
  23. func NonConstant() { 
  24.  number := 10 
  25.  s := make([]int, number) 
  26.  for i := 0; i < len(s); i++ { 
  27.   s[i] = i 
  28.  } 
  29. } 
  30.  
  31. func main() { 
  32.  NonConstant() 
  33.  MoreThan8192() 
  34.  LessThan8192() 
  35. } 

查看逃逸分析結(jié)果：

  1. go build -gcflags="-m -m -l" ./test4.go 
  2. # command-line-arguments 
  3. ./test4.go:8:14: LessThan8192 make([]int, 100) does not escape 
  4. ./test4.go:16:14: make([]int, 1000000) escapes to heap 
  5. ./test4.go:16:14:       from make([]int, 1000000) (non-constant size) at ./test4.go:16:14 
  6. ./test4.go:25:11: make([]int, number) escapes to heap 
  7. ./test4.go:25:11:       from make([]int, number) (non-constant size) at ./test4.go:25:11 

我們可以看到，當(dāng)?？臻g足夠時，不會發(fā)生逃逸，但是當(dāng)變量過大時，已經(jīng)完全超過?？臻g的大小時，將會發(fā)生逃逸到堆上分配內(nèi)存。

同樣當(dāng)我們初始化切片時，沒有直接指定大小，而是填入的變量，這種情況為了保證內(nèi)存的安全，編譯器也會觸發(fā)逃逸，在堆上進行分配內(nèi)存。

參考文章(建議大家閱讀一遍)

  • https://driverzhang.github.io/post/golang%E5%86%85%E5%AD%98%E5%88%86%E9%85%8D%E9%80%83%E9%80%B8%E5%88%86%E6%9E%90/
  • https://segmentfault.com/a/1190000039843497
  • https://tonybai.com/2021/05/24/understand-go-escape-analysis-by-example/
  • https://cloud.tencent.com/developer/article/1732263
  • https://geektutu.com/post/hpg-escape-analysis.html

總結(jié)

本文到這里結(jié)束了，這篇文章我們一起分析了什么是內(nèi)存逃逸以及Go語言中的逃逸分析，上面只列舉了幾個例子，因為發(fā)生的逃逸的情況是列舉不全的，我們只需要了解什么是逃逸分析，了解逃逸的策略就可以了，后面在實戰(zhàn)中可以根據(jù)具體代碼具體分析，寫出更優(yōu)質(zhì)的代碼。

最后對逃逸做一個總結(jié)： 

  • 逃逸分析在編譯階段確定哪些變量可以分配在棧中，哪些變量分配在堆上
  • 逃逸分析減輕了GC壓力，提高程序的運行速度
  • 棧上內(nèi)存使用完畢不需要GC處理，堆上內(nèi)存使用完畢會交給GC處理
  • 函數(shù)傳參時對于需要修改原對象值，或占用內(nèi)存比較大的結(jié)構(gòu)體，選擇傳指針。對于只讀的占用內(nèi)存較小的結(jié)構(gòu)體，直接傳值能夠獲得更好的性能
  • 根據(jù)代碼具體分析，盡量減少逃逸代碼，減輕GC壓力，提高性能

 

責(zé)任編輯：武曉燕 來源： Golang夢工廠
內(nèi)存Go語言
相關(guān)推薦

2020-06-28 09:30:37

Linux內(nèi)存操作系統(tǒng)

2021-04-20 08:40:11

內(nèi)存管理Lwip

2022-05-12 23:19:15

Redis內(nèi)存碎片處理

2019-03-21 11:04:22

安全標(biāo)準(zhǔn)信息

2023-03-06 21:23:23

Redis數(shù)據(jù)庫

2019-03-20 14:29:46

Linux虛擬內(nèi)存

2022-05-18 16:35:43

Redis內(nèi)存運維

2022-09-19 16:24:33

數(shù)據(jù)可視化Matplotlib工具

2022-10-19 15:20:58

pandas數(shù)據(jù)處理庫技巧

2022-10-21 07:59:17

CSS滾動文字特效

2023-02-09 08:48:47

Java虛擬機棧

2021-01-28 22:31:33

分組密碼算法

2023-09-22 17:36:37

2020-05-22 08:16:07

PONGPONXG-PON

2018-06-07 13:17:12

契約測試單元測試API測試

2023-03-03 12:37:50

JavaJVM內(nèi)存溢出

2022-08-08 08:25:21

Javajar 文件

2021-08-04 09:32:05

Typescript 技巧Partial

2018-11-29 09:13:47

CPU中斷控制器

2019-02-13 14:15:59

Linux版本Fedora
點贊
收藏

51CTO技術(shù)棧公眾號