GoLang melampaui asas : Analisis melarikan diri

Mari fahami cara Golang mengendalikan pembolehubah dan apakah Analisis Escape ini. Golang mempunyai 2 jenis jenis data peruntukan memori yang digunakan dalam persekitaran masa jalan yang dipanggil stack dan heap.

Timbunan lebih pantas untuk melakukan operasi semasa (masuk dan keluar). Pembolehubah di dalam fungsi yang diakses di dalamnya pergi ke timbunan ini. Cth:

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
}

Beginilah cara tindanan berfungsi dalam GoLang. Seterusnya ialah timbunan. Ia adalah memori dinamik iaitu saiznya boleh dilaraskan berdasarkan keperluan. Berikut ialah contoh mudah peruntukan timbunan.

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
}

Di sini memandangkan fungsi mengembalikan penunjuk kepada num, masa jalan Go mengesan bahawa num akan diakses di luar skop fungsi. Akibatnya, ia memperuntukkan num pada timbunan dan bukannya timbunan.

Timbunan digunakan untuk menyimpan pembolehubah yang berada di luar skop fungsi atau goroutine. Kadangkala apabila terdapat nilai pembolehubah yang sangat besar, ia disimpan dalam timbunan.

Selepas memahami kedua-dua perkara ini, tiba masanya untuk beralih ke analisis melarikan diri. Tidak ada cara untuk mengetahui pembolehubah mana yang akan diperuntukkan kepada timbunan hanya dengan membaca kod Go. Kita boleh memahami perkara ini dengan 'Escape Analysis'. Dengan melarikan diri, kami maksudkan sama ada pembolehubah itu terlepas daripada skop fungsi yang menentukan sama ada ia akan disimpan pada timbunan atau timbunan.

Jalankan arahan binaan kod go seperti ini

go build -gcflags '-m -l'

-m - Benderakan untuk menunjukkan analisis melarikan diri.
-l - Lumpuhkan sebaris untuk memastikan jejak tindanan tepat.

Ambil kod ini:

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()
}

Hasilnya adalah seperti ini:

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

Jadi, mengapa kita melakukan semua ini? Analisis ini boleh terbukti berguna apabila anda menyahpepijat untuk isu prestasi. Pembolehubah lebih baik disimpan dalam timbunan dan bukannya dalam timbunan. Anda boleh mencari tempat pembolehubah melarikan diri ke timbunan dan memfaktorkan semula kod untuk kecekapan yang lebih baik.

Semoga anda belajar sesuatu yang baharu hari ini.
Saya sedang membina LiveAPI yang merupakan alat untuk penjanaan dokumen API cubalah itu.

Terima kasih kerana membaca.

Atas ialah kandungan terperinci GoLang melampaui asas : Analisis melarikan diri. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!