​Golang-Interviewfrage: Kurz über Erinnerungsflucht sprechen?

Das Folgende ist eine Einführung in Golang-Interviewfragen aus der GolangTutorial-Kolumne: Kurz über Erinnerungsflucht sprechen? , ich hoffe, es wird Freunden in Not helfen!

Frage

Wissen Sie von Golangs Memory Escape? Unter welchen Umständen kommt es zu einem Memory Escape?

Wie antworte ich?Golang-Programmvariablen enthalten eine Reihe von Verifizierungsdaten, um zu beweisen, ob der gesamte Lebenszyklus zur Laufzeit vollständig bekannt ist. Wenn die Variable diese Prüfungen besteht, kann sie auf dem Stack zugewiesen werden. Andernfalls heißt es escape und muss auf dem Heap zugewiesen werden.

Typische Situationengolang程序变量会携带有一组校验数据，用来证明它的整个生命周期是否在运行时完全可知。如果变量通过了这些校验，它就可以在栈上分配。否则就说它 逃逸 了，必须在堆上分配。

能引起变量逃逸到堆上的典型情况：

• 在方法内把局部变量指针返回 局部变量原本应该在栈中分配，在栈中回收。但是由于返回时被外部引用，因此其生命周期大于栈，则溢出。
• 发送指针或带有指针的值到 channel 中。 在编译时，是没有办法知道哪个 goroutine 会在 channel 上接收数据。所以编译器没法知道变量什么时候才会被释放。
• 在一个切片上存储指针或带指针的值。 一个典型的例子就是 []*string 。这会导致切片的内容逃逸。尽管其后面的数组可能是在栈上分配的，但其引用的值一定是在堆上。
• slice 的背后数组被重新分配了，因为 append 时可能会超出其容量( cap )。 slice 初始化的地方在编译时是可以知道的，它最开始会在栈上分配。如果切片背后的存储要基于运行时的数据进行扩充，就会在堆上分配。
• 在 interface 类型上调用方法。 在 interface 类型上调用方法都是动态调度的 —— 方法的真正实现只能在运行时知道。想像一个 io.Reader 类型的变量 r , 调用 r.Read(b) 会使得 r 的值和切片b 的背后存储都逃逸掉，所以会在堆上分配。

举例

• 通过一个例子加深理解，接下来尝试下怎么通过 go build -gcflags=-m 查看逃逸的情况。

package main
import "fmt"
type A struct {
    s string
}
// 这是上面提到的 "在方法内把局部变量指针返回" 的情况
func foo(s string) *A {
    a := new(A) 
    a.s = s
    return a //返回局部变量a,在C语言中妥妥野指针，但在go则ok，但a会逃逸到堆
}
func main() {
    a := foo("hello")
    b := a.s + " world"
    c := b + "!"
    fmt.Println(c)
}

执行go build -gcflags=-m main.go

go build -gcflags=-m main.go
# command-line-arguments
./main.go:7:6: can inline foo
./main.go:13:10: inlining call to foo
./main.go:16:13: inlining call to fmt.Println
/var/folders/45/qx9lfw2s2zzgvhzg3mtzkwzc0000gn/T/go-build409982591/b001/_gomod_.go:6:6: can inline init.0
./main.go:7:10: leaking param: s
./main.go:8:10: new(A) escapes to heap
./main.go:16:13: io.Writer(os.Stdout) escapes to heap
./main.go:16:13: c escapes to heap
./main.go:15:9: b + "!" escapes to heap
./main.go:13:10: main new(A) does not escape
./main.go:14:11: main a.s + " world" does not escape
./main.go:16:13: main []interface {} literal does not escape
<autogenerated>:1: os.(*File).close .this does not escape

• ./main.go:8:10: new(A) escapes to heap 说明 new(A) 逃逸了,符合上述提到的常见情况中的第一种。
• ./main.go:14:11: main a.s + " world" does not escape 说明 b 变量没有逃逸，因为它只在方法内存在，会在方法结束时被回收。
• ./main.go:15:9: b + "!" escapes to heap 说明 c 变量逃逸，通过fmt.Println(a ...interface{}), die dazu führen können, dass Variablen auf den Heap entkommen:
• Den lokalen Variablenzeiger in einer Methode zurückgeben Lokale Variablen sollten ursprünglich auf dem Stapel zugewiesen und auf dem Stapel wiederverwendet werden. Da es jedoch bei der Rückgabe extern referenziert wird, ist sein Lebenszyklus länger als der des Stapels und es kommt zu einem Überlauf.
Senden Sie einen Zeiger oder einen Wert mit einem Zeiger an einen Kanal.
Zur Kompilierungszeit gibt es keine Möglichkeit zu wissen, welche Goroutine Daten auf dem Kanal empfängt. Der Compiler kann also nicht wissen, wann die Variable freigegeben wird.

🎜🎜 Zeiger oder Werte mit Zeigern auf einem Slice speichern. 🎜 Ein typisches Beispiel ist []*string. Dies führt dazu, dass der Inhalt des Slice entweicht. Obwohl das Array dahinter auf dem Stapel zugeordnet sein kann, muss sich der Wert, auf den es verweist, auf dem Heap befinden. Das Array hinter 🎜🎜🎜slice wird neu zugewiesen, da seine Kapazität (Obergrenze) beim Anhängen möglicherweise überschritten wird. 🎜 Der Ort, an dem das Slice initialisiert wird, kann zur Kompilierungszeit bekannt sein und wird zunächst auf dem Stapel zugewiesen. Wenn der Speicher hinter dem Slice basierend auf Laufzeitdaten erweitert werden soll, wird er auf dem Heap zugewiesen. 🎜🎜🎜Methoden für Schnittstellentypen aufrufen. 🎜 Methodenaufrufe für Schnittstellentypen werden dynamisch geplant – die wahre Implementierung der Methode kann erst zur Laufzeit bekannt sein. Stellen Sie sich eine Variable r vom Typ io.Reader vor. Der Aufruf von r.Read(b) führt dazu, dass der Wert von r und der Speicher hinter Slice b entkommen, sodass sie auf dem Heap zugewiesen werden. 🎜🎜🎜Beispiel🎜

🎜 Lassen Sie uns unser Verständnis anhand eines Beispiels vertiefen. Versuchen Sie als nächstes, die Escape-Situation durch go build -gcflags=-m zu überprüfen. 🎜🎜rrreee🎜Execute go build -gcflags=-m main.go🎜rrreee
🎜./main.go:8:10: new(A) escapes to heap code> code> erklärt, dass <code>new(A) entkommen ist, was mit der ersten der oben genannten häufigen Situationen übereinstimmt. 🎜🎜./main.go:14:11: main a.s + „ world“ wird nicht maskiert Beschreibung b Variable wird nicht maskiert, da sie nur innerhalb der Methode existiert. Es wird am Ende der Methode recycelt. 🎜🎜./main.go:15:9: b + „!“ Escapes zum Heap Beschreibung c Variable Escapes durch fmt.Println(a .. . interface{})Die gedruckten Variablen werden alle maskiert. Interessierte Freunde können nachsehen, warum. 🎜🎜Der obige Vorgang wird eigentlich „Fluchtanalyse“ genannt. 🎜Im nächsten Artikel werde ich mit Ihnen darüber sprechen, wie Sie mit einer schwierigeren Methode verhindern können, dass Variablen maskiert werden. Es ist praktisch für alle, vor dem Interviewer anzugeben🎜. 🎜🎜🎜

Das obige ist der detaillierte Inhalt von​Golang-Interviewfrage: Kurz über Erinnerungsflucht sprechen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!