Geleidelijk afsluiten
Stop workers netjes
Geleidelijk afsluiten 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.
Waarom netjes afsluiten
Langlopende goroutines moeten te horen krijgen wanneer ze moeten stoppen. Netjes afsluiten zorgt ervoor dat workers hun huidige werk afmaken, bronnen vrijgeven en stoppen zonder lekken of gegevensverlies.
- Geen lekkende goroutines
- Geen half afgemaakte schrijfbewerkingen
- Het proces wordt netjes beëindigd
Het patroon met het done-kanaal
Een klassieke aanpak is een done-kanaal. Als je het sluit, wordt een stopsignaal naar alle goroutines gestuurd die erop luisteren, omdat een gesloten kanaal bij ontvangen onmiddellijk terugkeert.
done := make(chan struct{})
// ... later
close(done)select voor stopsignalen
Een worker gebruikt select om een taak te verwerken of het done-kanaal op te merken. Wanneer done wordt gesloten, wordt die case uitgevoerd en keert de worker terug.
for {
select {
case <-done:
return
case j := <-jobs:
process(j)
}
}context.Context
Het idiomatische moderne hulpmiddel is context. context.WithCancel geeft je een context en een annuleerfunctie. Als je cancel aanroept, wordt het Done-kanaal van de context gesloten.
ctx, cancel := context.WithCancel(context.Background())
defer cancel()Luisteren naar ctx.Done()
Workers voeren een select uit op ctx.Done(). Wanneer cancel wordt aangeroepen of een deadline verstrijkt, wordt het kanaal gesloten en stopt de worker.
select {
case <-ctx.Done():
return ctx.Err()
case j := <-jobs:
process(j)
}Op workers wachten
Alleen een stopsignaal sturen is niet genoeg; je moet wachten totdat workers daadwerkelijk klaar zijn. Een sync.WaitGroup houdt ze bij, zodat main kan blokkeren totdat de teller nul bereikt.
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
runWorker(ctx)
}()
// ... later
cancel()
wg.Wait()Time-outs met context
context.WithTimeout annuleert automatisch na een bepaalde duur. Zo begrens je hoe lang het afsluiten kan duren voordat je het proces geforceerd beëindigt.
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()Een volledige nette afsluiting
Dit programma voert twee workers uit, annuleert de context en wacht totdat beide netjes zijn gestopt voordat het done afdrukt.
package main
import (
"context"
"fmt"
"sync"
"time"
)
func worker(ctx context.Context, id int, wg *sync.WaitGroup) {
defer wg.Done()
for {
select {
case <-ctx.Done():
fmt.Printf("worker %d stopping\n", id)
return
case <-time.After(50 * time.Millisecond):
}
}
}
func main() {
ctx, cancel := context.WithCancel(context.Background())
var wg sync.WaitGroup
for i := 1; i <= 2; i++ {
wg.Add(1)
go worker(ctx, i, &wg)
}
time.Sleep(120 * time.Millisecond)
cancel()
wg.Wait()
fmt.Println("all workers stopped")
}Lopend werk afronden
Bij het afsluiten wil je vaak dat workers afmaken waar ze al aan zijn begonnen. Lees resterende taken in een laatste lus of stop met het aannemen van nieuwe taken terwijl de huidige taken mogen worden afgerond.
OS-signalen opvangen
Op echte servers koppelt signal.NotifyContext annulering aan SIGINT en SIGTERM. Als je op Ctrl+C drukt, wordt dezelfde nette afsluitroute gestart als bij een handmatige annulering.
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
defer stop()Vergeet cancel() nooit
Gebruik altijd defer cancel(), ook wanneer je WithTimeout gebruikt. Als je cancel niet aanroept, lekken de interne goroutine en timer van de context totdat de deadline verstrijkt.
Korte toets
Toets je kennis van netjes afsluiten.
Samenvatting
Je hebt geleerd hoe je netjes afsluit:
- Gebruik context.WithCancel of een done-kanaal om het stoppen te signaleren
- Workers voeren een select uit op ctx.Done()
- WaitGroup zorgt ervoor dat alle workers daadwerkelijk stoppen
- Koppel annulering aan OS-signalen voor echte servers
- Gebruik altijd defer cancel()
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 “Geleidelijk afsluiten” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Go Academy, waaronder “Geleidelijk afsluiten”, 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 “Geleidelijk afsluiten”?
Stop workers netjes 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 “Geleidelijk afsluiten”?
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
- Worker-poolpatroon
- Fan-out en fan-in
- Pijplijnfasen
- Geleidelijk afsluiten