Arrêt progressif
Arrêter proprement les travailleurs
Arrêt progressif est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.
Pourquoi un arrêt progressif
Il faut indiquer aux routines Go de longue durée quand s'arrêter. Un arrêt progressif permet aux agents de terminer leur travail en cours, de libérer les ressources et de quitter le programme sans fuite ni perte de données.
- Aucune fuite de routine Go
- Aucune écriture partiellement terminée
- Sortie propre du processus
Le motif du canal done
Une approche classique consiste à utiliser un canal done. Le fermer diffuse un signal d'arrêt à toutes les routines Go qui l'écoutent, car la réception sur un canal fermé renvoie immédiatement.
done := make(chan struct{})
// ... later
close(done)select pour les signaux d'arrêt
Un agent utilise select pour traiter une tâche ou détecter le canal done. Lorsque done est fermé, le cas correspondant est sélectionné et l'agent se termine.
for {
select {
case <-done:
return
case j := <-jobs:
process(j)
}
}context.Context
L'outil moderne recommandé est context. context.WithCancel vous fournit un contexte et une fonction d'annulation. Appeler cancel ferme le canal Done du contexte.
ctx, cancel := context.WithCancel(context.Background())
defer cancel()Écouter sur ctx.Done()
Les agents sélectionnent sur ctx.Done(). Lorsque cancel est appelé ou qu'une échéance est dépassée, le canal se ferme et l'agent se termine.
select {
case <-ctx.Done():
return ctx.Err()
case j := <-jobs:
process(j)
}Attendre les agents
Signaler l'arrêt ne suffit pas : vous devez attendre que les agents aient réellement terminé. Un sync.WaitGroup les suit afin que main puisse rester bloqué jusqu'à ce que le compteur atteigne zéro.
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
runWorker(ctx)
}()
// ... later
cancel()
wg.Wait()Délais d'expiration avec context
context.WithTimeout annule automatiquement le contexte après une durée donnée. Cela limite la durée maximale de l'arrêt avant de forcer la sortie.
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()Un arrêt progressif complet
Ce programme exécute deux agents, annule le contexte et attend qu'ils se terminent proprement avant d'afficher 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")
}Achever le travail en cours
Lors d'un arrêt, vous souhaitez souvent que les agents terminent ce qu'ils ont déjà commencé. Lisez les tâches restantes dans une dernière boucle, ou cessez d'accepter de nouvelles tâches tout en laissant les tâches en cours se terminer.
Intercepter les signaux du système
Dans les serveurs réels, signal.NotifyContext relie l'annulation aux signaux SIGINT et SIGTERM. Appuyer sur Ctrl+C déclenche alors le même processus d'arrêt progressif qu'une annulation manuelle.
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
defer stop()N'oubliez jamais cancel()
Utilisez toujours defer cancel(), même avec WithTimeout. Si vous n'appelez pas cancel, la routine Go interne et le temporisateur du contexte restent en mémoire jusqu'à l'expiration de l'échéance.
Vérification rapide
Vérifiez vos connaissances sur l'arrêt.
Récapitulatif
Vous avez appris l'arrêt progressif :
- Utiliser context.WithCancel ou un canal done pour signaler l'arrêt
- Les agents sélectionnent sur ctx.Done()
- WaitGroup garantit que tous les agents se terminent réellement
- Relier l'annulation aux signaux OS pour les serveurs réels
- Toujours utiliser defer cancel()
Questions Fréquemment Posées
La leçon « Arrêt progressif » est-elle gratuite ?
Oui — le texte complet de « Arrêt progressif » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Arrêt progressif » ?
Arrêter proprement les travailleurs Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Go Academy ?
Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Arrêt progressif » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?
Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.