GoLang über die Grundlagen hinaus: Escape-Analyse

Lassen Sie uns verstehen, wie Golang mit Variablen umgeht und was diese Escape-Analyse ist. Golang verfügt über zwei Arten von Speicherzuweisungsdatentypen, die in der Go-Laufzeitumgebung verwendet werden: Stack und Heap.

Der Stapel ist schneller für die Ausführung von Operationen (ein- und ausgehend). Variablen innerhalb einer Funktion, auf die darin zugegriffen wird, werden in diesen Stapel verschoben. Beispiel:

package main

import "fmt"

func stackExample() int {
    a := 10        // Variable `a` is allocated on the stack
    b := 20        // Variable `b` is allocated on the stack
    result := a + b // `result` is also allocated on the stack
    return result   // All stack variables are popped off when the function exits
}

func main() {
    result := stackExample() // Function call happens, variables are pushed to the stack
    fmt.Println(result)      // Print the result
}

So funktioniert der Stack in GoLang. Als nächstes kommt ein Haufen. Es handelt sich um einen dynamischen Speicher, das heißt, seine Größe kann je nach Bedarf angepasst werden. Hier ist ein einfaches Beispiel für die Heap-Zuweisung.

package main

import "fmt"

func heapExample() *int {
    num := 42           // Variable `num` is created inside the function
    return &num         // Returning the address of `num`, which escapes the function
}

func main() {
    ptr := heapExample() // The value pointed to by `ptr` is allocated on the heap
    fmt.Println(*ptr)    // Accessing the heap-allocated variable through the pointer
}

Da die Funktion hier einen Zeiger auf „num“ zurückgibt, erkennt die Go-Laufzeit, dass auf „num“ außerhalb des Funktionsbereichs zugegriffen wird. Infolgedessen wird die Anzahl auf dem Heap statt auf dem Stack zugewiesen.

Ein Heap wird zum Speichern von Variablen verwendet, die außerhalb des Gültigkeitsbereichs einer Funktion oder einer Goroutine liegen. Wenn der Wert einer Variablen manchmal sehr groß ist, wird sie in einem Heap gespeichert.

Nachdem Sie diese beiden verstanden haben, ist es an der Zeit, sich mit der Fluchtanalyse zu befassen. Es gibt keine Möglichkeit, einfach durch Lesen des Go-Codes zu wissen, welche Variablen dem Heap zugewiesen werden. Wir können dies mit einer „Escape-Analyse“ verstehen. Mit Escape meinen wir, ob die Variable den Gültigkeitsbereich einer Funktion verlässt und bestimmt, ob sie auf einem Heap oder Stack gespeichert wird.

Führen Sie den Build-Befehl des Go-Codes wie folgt aus

go build -gcflags '-m -l'

-m – Flag zum Anzeigen der Escape-Analyse.
-l – Inlining deaktivieren, um Stack-Traces korrekt zu halten.

Nehmen Sie diesen Code:

package main

func escapeExample() *int {
    x := 42
    return &x // x escapes because its address is returned
}

func noEscapeExample() int {
    y := 100
    return y // y does not escape
}

func main() {
    _ = escapeExample()
    _ = noEscapeExample()
}

Die Ergebnisse sehen in etwa so aus:

./main.go:4:10: &x escapes to heap
./main.go:12:13: main escapes to heap

Warum machen wir das alles? Diese Analyse kann sich beim Debuggen von Leistungsproblemen als nützlich erweisen. Variablen werden besser in einem Stapel gespeichert als in einem Heap. Sie können herausfinden, wo Variablen in den Heap entkommen, und den Code für eine bessere Effizienz umgestalten.

Ich hoffe, Sie haben heute etwas Neues gelernt.
Ich baue derzeit LiveAPI, ein Tool zur API-Dokumentgenerierung, probieren Sie es aus.

Danke fürs Lesen.

Das obige ist der detaillierte Inhalt vonGoLang über die Grundlagen hinaus: Escape-Analyse. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!