Go Academy · leksjon

Lekkasjedeteksjon og kansellering

Sikre at goroutiner avsluttes, og hindre lekkasjer

Leksjon 4 av 413 trinn

Lekkasjedeteksjon og kansellering er en gratis leksjon i Go Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Go Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Go Academy inneholder totalt 4 leksjoner.

Hva er en goroutine-lekkasje?

En goroutine-lekkasje oppstår når en goroutine starter, men aldri avsluttes. Lekkasjer av goroutiner akkumuleres over tid og bruker stakkminne og CPU helt til prosessen avsluttes.

Vanlig lekkasje: blokkert mottak fra kanal

En goroutine som venter på å motta fra en kanal, men aldri får en verdi, blir blokkert for alltid:

go func() {
    v := <-ch // leaks if no sender and ch is never closed
    use(v)
}()

Vanlig lekkasje: manglende done-signal

En goroutine i en for-løkke uten en avslutningsbetingelse eller done-kanal kjører for alltid:

go func() {
    for {
        work()
        // no exit condition — leaks
    }
}()

Oppdage lekkasjer med goleak

go.uber.org/goleak verifiserer at ingen goroutiner har lekket ved slutten av en test:

func TestMyFunc(t *testing.T) {
    defer goleak.VerifyNone(t)
    myFunc() // should not leak goroutines
}

Context som løsning

Den idiomatiske måten å stoppe goroutiner som kjører lenge, er å bruke context. Send ctx til goroutinen og bruk select på ctx.Done().

go func(ctx context.Context) {
    for {
        select {
        case work := <-workCh:
            process(work)
        case <-ctx.Done():
            return // clean exit
        }
    }
}(ctx)

Mønster med done-kanal

For enklere tilfeller uten context kan De bruke en dedikert done-kanal. Lukk den for å kringkaste et stoppsignal til alle goroutiner som leser fra den.

done := make(chan struct{})
go func() {
    select {
    case v := <-data: use(v)
    case <-done: return
    }
}()
close(done) // stops goroutine

Oppdage med runtime

Skriv ut antallet goroutiner for å oppdage vekst under kjøring:

fmt.Println("goroutines:", runtime.NumGoroutine())

Goroutiner i HTTP-servere

net/http håndterer automatisk goroutiner per forespørsel og rydder dem opp når forespørselen er ferdig. Handlere som starter goroutiner uten å rydde dem opp, kan likevel føre til lekkasjer.

Teste for lekkasjer

Kjør testpakken med goleak som en TestMain eller med defer per test. En goroutine som ikke er avsluttet etter testkroppen, fører til at testen mislykkes.

func TestMain(m *testing.M) {
    goleak.VerifyTestMain(m)
}

Time.After-lekkasjer

time.After i en select inne i en løkke oppretter en ny timer ved hver iterasjon. Timeren kan ikke samles inn av GC før den utløses. Erstatt den med time.NewTimer og Reset.

Lekkasje når en goroutine returnerer en feil

Hvis en goroutine skal sende et resultat på en kanal, men returnerer tidlig på grunn av en feil uten å sende noe, blir mottakergoroutinen blokkert for alltid. Send alltid noe eller lukk kanalen i alle stier.

Hurtigsjekk

Hva er den mest idiomatiske måten å stoppe en goroutine som kjører lenge, på i Go?

Besvar den i den interaktive leksjonen

Oppsummering: Oppdaging av lekkasjer og kansellering

Viktige punkter:

Goroutine-lekkasjer akkumuleres; overvåk dem med runtime.NumGoroutine()
goleak oppdager automatisk goroutine-lekkasjer i tester
Gi alltid goroutiner en vei ut: context, done-kanal eller en lukket inndatakilde
time.After i løkker lekker timere; bruk NewTimer+Reset

Gratis å komme i gang

Lær deg Go med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 51
Leksjoner: 203

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Lekkasjedeteksjon og kansellering» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Go Academy, inkludert «Lekkasjedeteksjon og kansellering», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Go Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Lekkasjedeteksjon og kansellering»?

Sikre at goroutiner avsluttes, og hindre lekkasjer Du øver på Go Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Go Academy?

Ingen tidligere erfaring er nødvendig. Go Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Lekkasjedeteksjon og kansellering»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Go Academy-leksjonen?

Ja. Alle Go Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Go Academy