Kontrollerad avstängning
Stoppa workers på ett ordnat sätt
Kontrollerad avstängning är en gratis lektion i Go Academy på CoddyKit. Detta är lektion 4 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.
Varför kontrollerad nedstängning
Långlivade goroutines måste få veta när de ska avsluta. Kontrollerad nedstängning låter workers slutföra det pågående arbetet, frigöra resurser och avsluta utan läckor eller dataförlust.
- Inga läckta goroutines
- Inga halvfärdiga skrivningar
- Processen avslutas korrekt
Mönstret med done-kanal
Ett klassiskt tillvägagångssätt är en done-kanal. När den stängs skickas en stoppsignal till alla goroutines som lyssnar på den, eftersom en stängd kanal returnerar omedelbart vid läsning.
done := make(chan struct{})
// ... later
close(done)select för stoppsignaler
En worker använder select för att antingen bearbeta ett jobb eller upptäcka done-kanalen. När done stängs aktiveras det fallet och workern returnerar.
for {
select {
case <-done:
return
case j := <-jobs:
process(j)
}
}context.Context
Det idiomatiska moderna verktyget är context. context.WithCancel ger er en context och en cancel-funktion. När ni anropar cancel stängs contextets Done-kanal.
ctx, cancel := context.WithCancel(context.Background())
defer cancel()Lyssna på ctx.Done()
Workers använder select på ctx.Done(). När cancel anropas eller en tidsgräns passerar stängs kanalen och workern avslutas.
select {
case <-ctx.Done():
return ctx.Err()
case j := <-jobs:
process(j)
}Vänta på workers
Det räcker inte att signalera stopp; ni måste vänta tills workers faktiskt är klara. En sync.WaitGroup håller reda på dem, så att main kan blockeras tills räknaren når noll.
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
runWorker(ctx)
}()
// ... later
cancel()
wg.Wait()Tidsgränser med context
context.WithTimeout avbryter automatiskt efter en viss tidsperiod. Det begränsar hur länge nedstängningen kan pågå innan ni tvingar fram en avslutning.
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()En komplett kontrollerad nedstängning
Det här programmet kör två workers, avbryter contextet och väntar på att båda ska avslutas korrekt innan det skriver ut done.
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")
}Töm pågående arbete
Vid nedstängning vill ni ofta att workers ska slutföra det de redan har påbörjat. Läs återstående jobb i en avslutande loop, eller sluta ta emot nya jobb medan de pågående får slutföras.
Fånga operativsystemssignaler
I riktiga servrar kopplar signal.NotifyContext avbrytningen till SIGINT och SIGTERM. När ni trycker på Ctrl+C aktiveras samma kontrollerade väg som vid en manuell avbrytning.
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
defer stop()Glöm aldrig cancel()
Använd alltid defer cancel(), även när ni använder WithTimeout. Om cancel inte anropas läcker contextets interna goroutine och timer tills tidsgränsen löper ut.
Snabbtest
Testa era kunskaper om nedstängning.
Sammanfattning
Ni lärde er om kontrollerad nedstängning:
- Använd context.WithCancel eller en done-kanal för att signalera stopp
- Workers använder select på ctx.Done()
- WaitGroup säkerställer att alla workers faktiskt avslutas
- Koppla avbrytningen till operativsystemssignaler i riktiga servrar
- Använd alltid defer cancel()
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
Vanliga frågor
Är lektionen ”Kontrollerad avstängning” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Go Academy, inklusive ”Kontrollerad avstängning”, 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 ”Kontrollerad avstängning”?
Stoppa workers på ett ordnat sätt 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 4 av 4.
Hur lång tid tar lektionen ”Kontrollerad avstängning”?
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
- Worker pool-mönstret
- Fan-out och fan-in
- Pipeline-steg
- Kontrollerad avstängning