Lekken detecteren en annuleren
Ervoor zorgen dat goroutines eindigen en lekken voorkomen
Lekken detecteren en annuleren is een gratis Go Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Go Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Go Academy bevat in totaal 4 lessen.
Wat is een goroutinelek?
Een goroutinelek ontstaat wanneer een goroutine wordt gestart maar nooit wordt beëindigd. Gelekte goroutines stapelen zich na verloop van tijd op en verbruiken stackgeheugen en CPU totdat het proces wordt beëindigd.
Veelvoorkomend lek: geblokkeerde kanaalontvangst
Een goroutine die wacht op een kanaalontvangst die nooit een waarde krijgt, blijft voor altijd geblokkeerd:
go func() {
v := <-ch // leaks if no sender and ch is never closed
use(v)
}()Veelvoorkomend lek: geen beëindigingssignaal
Een goroutine in een for-lus zonder stopvoorwaarde of beëindigingskanaal draait voor altijd:
go func() {
for {
work()
// no exit condition — leaks
}
}()Lekken detecteren met goleak
go.uber.org/goleak controleert of er aan het einde van een test geen goroutines zijn gelekt:
func TestMyFunc(t *testing.T) {
defer goleak.VerifyNone(t)
myFunc() // should not leak goroutines
}Context als oplossing
De idiomatische manier om langlopende goroutines te stoppen is een context. Geef ctx door aan de goroutine en selecteer op ctx.Done().
go func(ctx context.Context) {
for {
select {
case work := <-workCh:
process(work)
case <-ctx.Done():
return // clean exit
}
}
}(ctx)Patroon met een beëindigingskanaal
Gebruik voor eenvoudigere gevallen zonder context een speciaal beëindigingskanaal. Sluit het om aan alle goroutines die ervan lezen uit te zenden dat ze moeten stoppen.
done := make(chan struct{})
go func() {
select {
case v := <-data: use(v)
case <-done: return
}
}()
close(done) // stops goroutineDetecteren met runtime
Print het aantal goroutines om groei tijdens runtime te detecteren:
fmt.Println("goroutines:", runtime.NumGoroutine())Goroutines van een HTTP-server
net/http beheert automatisch goroutines per verzoek en ruimt ze op wanneer het verzoek is voltooid. Maar afhandelingsfuncties die goroutines starten zonder ze op te ruimen, kunnen nog steeds lekken veroorzaken.
Op lekken testen
Voer je testsuite uit met goleak als een TestMain of met defer per test. Elke goroutine die na de testcode niet is beëindigd, veroorzaakt een mislukte test.
func TestMain(m *testing.M) {
goleak.VerifyTestMain(m)
}Lekken door Time.After
time.After in een select binnen een lus maakt bij elke iteratie een nieuwe timer aan die pas door de garbagecollector kan worden opgeruimd wanneer hij afgaat. Vervang dit door time.NewTimer en Reset.
Lek door een goroutine die een fout retourneert
Als een goroutine een resultaat op een kanaal moet sturen maar door een fout vroegtijdig terugkeert zonder iets te sturen, blijft de ontvangende goroutine voor altijd geblokkeerd. Stuur altijd een waarde of sluit het kanaal op alle mogelijke paden.
Korte controle
Wat is in Go de meest idiomatische manier om een langlopende goroutine te stoppen?
Samenvatting: lekdetectie en annulering
Belangrijkste punten:
- Goroutinelekken stapelen zich op; houd ze in de gaten met runtime.NumGoroutine()
- goleak detecteert goroutinelekken automatisch in tests
- Geef goroutines altijd een manier om te stoppen: een context, beëindigingskanaal of gesloten invoer
- time.After lekt timers in lussen; gebruik NewTimer+Reset
Leer Go met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 51
- Lessen
- 203
Veelgestelde vragen
Is de les “Lekken detecteren en annuleren” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Go Academy, waaronder “Lekken detecteren en annuleren”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Go Academy bevat in totaal 4 lessen.
Wat leer ik in “Lekken detecteren en annuleren”?
Ervoor zorgen dat goroutines eindigen en lekken voorkomen Je oefent met Go Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Go Academy te beginnen?
Ervaring vooraf is niet nodig. Go Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.
Hoe lang duurt de les “Lekken detecteren en annuleren”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Go Academy?
Ja. Elke les over Go Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Pipeline- en stagepatronen
- errgroup voor gelijktijdige foutafhandeling
- Semaf patroon
- Lekken detecteren en annuleren