Go Academy · Lektion

Stack kontra heap och escape-analys

Hur Go avgör var minne ska allokeras

Lektion 1 av 413 steg

Stack kontra heap och escape-analys är en gratis lektion i Go Academy på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Go Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Go Academy innehåller totalt 4 lektioner.

Stackallokering

Lokala variabler som inte lämnar funktionen allokeras på goroutinens stack. Stackallokering är snabb (endast en pekarökning) och kostar inget att samla in (stackramen tas bort när funktionen returnerar).

Heapallokering

Variabler som lämnar funktionen och hamnar på heapen allokeras med Go-allokatorn och spåras av skräpsamlaren. Heapallokering är långsammare och ökar belastningen på GC.

Vad orsakar escape?

Vanliga orsaker till escape är att ta adressen till en lokal variabel och returnera den, lagra en lokal variabel i ett interface eller skicka den via en kanal. Kompilatorns escape-analys avgör detta.

func newUser() *User { // *User escapes to heap
    return &User{Name: "Alice"}
}

go build -gcflags=-m

Skriv ut besluten från escape-analysen:

go build -gcflags="-m" .
// main.go:10:15: &User literal escapes to heap
// main.go:5:14: s does not escape

Goroutinestackar

Varje goroutine startar med en liten stack (2 KiB i Go 1.14 och senare) som växer dynamiskt efter behov. Stackar är separata från heapen och samlas in när goroutinen avslutas.

Undvika allokeringar

Skicka värden (inte pekare) för små structar. Använd stackallokerade arrayer i stället för slices när storleken är känd. Returnera värden i stället för pekare för att hålla dem på stacken.

Boxning i interface

När ett konkret värde tilldelas till ett interface lämnar värdet funktionen och hamnar på heapen (boxning). För frekvent körda kodvägar bör ni ta emot konkreta typer eller använda generics i stället för interface.

sync.Pool

Återanvänd heapallokerade objekt med sync.Pool för att minska belastningen på GC som orsakas av frekventa allokeringar av kortlivade objekt (buffertar, begärandekontexter).

var pool = sync.Pool{New: func() any { return make([]byte, 1024) }}
buf := pool.Get().([]byte)
defer pool.Put(buf[:0])

Profilera allokeringar

Använd go test -benchmem och heapprofilering med -alloc_space för att hitta funktionerna som allokerar mest minne.

slice kontra array

En liten array [N]T kan ligga kvar på stacken. En slice-header (24 byte) allokeras på stacken, men dess underliggande array kan lämna funktionen. Förallokering med make undviker upprepade omallokeringar.

Stränginternering

Strängliteraler allokeras inte på heapen (de finns i det skrivskyddade datasegmentet). Omvandling från []byte till string allokerar minne. Cacha strängar som används ofta för att undvika upprepade omvandlingar.

Snabbkontroll

Vad får en lokal variabel att lämna stacken och hamna på heapen?

Besvara frågan i den interaktiva lektionen

Sammanfattning: stack kontra heap

Viktiga punkter:

Stack: snabb och kostnadsfri GC; heap: långsammare och spåras av GC
go build -gcflags="-m" visar escape-besluten
Interface-boxning, att ta adressen till en lokal variabel och kanalsändningar orsakar escape
sync.Pool för objekt som allokeras och kastas ofta

Gratis att börja

Lär dig Go med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 51
Lektioner: 203

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Stack kontra heap och escape-analys” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Go Academy, inklusive ”Stack kontra heap och escape-analys”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Go Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Stack kontra heap och escape-analys”?

Hur Go avgör var minne ska allokeras Ni övar på Go Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Go Academy?

Du behöver inga förkunskaper. Utbildningen i Go Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Stack kontra heap och escape-analys”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Go Academy-lektionen?

Ja. Varje Go Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Stack kontra heap och escape-analys
Gos minnesmodell och happens-before
Interna detaljer i garbage collectorn
Minska allokeringar: sync.Pool och arenor

← Tillbaka till Go Academy