Arresto graduale
Arrestare i worker correttamente
Arresto graduale è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.
Perché un arresto controllato
Alle goroutine di lunga durata bisogna indicare quando fermarsi. Un arresto controllato consente ai worker di terminare il lavoro corrente, rilasciare le risorse e uscire senza perdite di risorse né dati.
- Nessuna goroutine rimane attiva inutilmente
- Nessuna scrittura lasciata a metà
- Uscita pulita del processo
Il pattern del canale done
Un approccio classico consiste nell'utilizzare un canale done. Chiuderlo trasmette un segnale di arresto a tutte le goroutine in ascolto, perché la ricezione da un canale chiuso restituisce immediatamente.
done := make(chan struct{})
// ... later
close(done)select per i segnali di arresto
Un worker utilizza select per elaborare un job oppure rilevare il canale done. Quando done viene chiuso, il relativo case viene eseguito e il worker termina.
for {
select {
case <-done:
return
case j := <-jobs:
process(j)
}
}context.Context
Lo strumento moderno idiomatico è context. context.WithCancel fornisce un context e una funzione di annullamento. Chiamare cancel chiude il canale Done del context.
ctx, cancel := context.WithCancel(context.Background())
defer cancel()Ascoltare su ctx.Done()
I worker eseguono il select su ctx.Done(). Quando viene chiamato cancel o scade una deadline, il canale viene chiuso e il worker termina.
select {
case <-ctx.Done():
return ctx.Err()
case j := <-jobs:
process(j)
}Attendere i worker
Segnalare l'arresto non è sufficiente: bisogna attendere che i worker terminino davvero. Un sync.WaitGroup li tiene sotto controllo, consentendo a main di bloccarsi finché il conteggio non raggiunge zero.
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
runWorker(ctx)
}()
// ... later
cancel()
wg.Wait()Timeout con context
context.WithTimeout annulla automaticamente il context dopo un determinato intervallo. In questo modo si limita il tempo che l'arresto può richiedere prima di dover forzare l'uscita.
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()Un arresto controllato completo
Questo programma esegue due worker, annulla il context e attende che entrambi terminino correttamente prima di stampare 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")
}Completare il lavoro in corso
Durante l'arresto, spesso è opportuno consentire ai worker di terminare ciò che hanno già iniziato. Legga i job rimanenti in un ciclo finale oppure smetta di accettare nuovi job, lasciando completare quelli correnti.
Rilevare i segnali del sistema operativo
Nei server reali, signal.NotifyContext collega l'annullamento ai segnali SIGINT e SIGTERM. Premendo Ctrl+C si attiva quindi lo stesso percorso di arresto controllato di un annullamento manuale.
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
defer stop()Non dimentichi mai cancel()
Utilizzi sempre defer cancel(), anche quando usa WithTimeout. Se non chiama cancel, la goroutine interna del context e il relativo timer rimangono attivi fino alla scadenza della deadline.
Verifica rapida
Verifichi la Sua conoscenza dell'arresto controllato.
Riepilogo
Ha imparato a eseguire un arresto controllato:
- Utilizzare context.WithCancel o un canale done per segnalare l'arresto
- I worker eseguono il select su ctx.Done()
- WaitGroup garantisce che tutti i worker terminino davvero
- Collegare l'annullamento ai segnali del sistema operativo nei server reali
- Utilizzare sempre defer cancel()
Impara Go con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 51
- Lezioni
- 203
Domande Frequenti
La lezione «Arresto graduale» è gratuita?
Sì — il testo completo di «Arresto graduale» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.
Cosa imparerò in «Arresto graduale»?
Arrestare i worker correttamente Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Go Academy?
Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Arresto graduale»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Go Academy?
Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Pattern del worker pool
- Fan-out e fan-in
- Fasi della pipeline
- Arresto graduale