Modèles de pipeline et d’étapes
Composer des pipelines concurrents à plusieurs étapes
Modèles de pipeline et d’étapes est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.
Qu'est-ce qu'une chaîne de traitement ?
Une chaîne de traitement concurrente est une série d'étapes reliées par des canaux. Chaque étape reçoit des valeurs de l'étape précédente, les transforme et envoie les résultats à l'étape suivante, ce qui permet aux étapes de s'exécuter en parallèle.
Chaîne de traitement simple en trois étapes
Génération → transformation → consommation :
func generate(nums ...int) <-chan int {
out := make(chan int)
go func() { defer close(out); for _, n := range nums { out <- n } }()
return out
}
func square(in <-chan int) <-chan int {
out := make(chan int)
go func() { defer close(out); for n := range in { out <- n*n } }()
return out
}
for v := range square(generate(2, 3, 4)) {
fmt.Println(v) // 4, 9, 16
}Modèle stage
Chaque stage est une fonction qui reçoit un canal d'entrée et renvoie un canal de sortie. Les stages se composent facilement et peuvent être parallélisés indépendamment.
Répartition en éventail au sein d'une chaîne de traitement
Dupliquez une étape en N goroutines pour paralléliser les opérations gourmandes en CPU :
func parallelSquare(in <-chan int, n int) <-chan int {
outs := make([]<-chan int, n)
for i := 0; i < n; i++ {
outs[i] = square(in) // all read from same in
}
return merge(outs...)
}Annulation avec un contexte
Transmettez un contexte à chaque stage. Lorsqu'il est annulé, les stages cessent de lire et ferment leurs canaux de sortie, ce qui vide toute la chaîne de traitement.
func stage(ctx context.Context, in <-chan int) <-chan int {
out := make(chan int)
go func() {
defer close(out)
for {
select {
case v, ok := <-in:
if !ok { return }
select {
case out <- process(v):
case <-ctx.Done(): return
}
case <-ctx.Done(): return
}
}
}()
return out
}Rétropression
Utilisez des canaux avec tampon entre les étapes pour découpler la vitesse du producteur et celle du consommateur. Sans tampon, une étape lente bloque toute la chaîne de traitement.
out := make(chan Result, 50) // buffer 50 resultsPropagation des erreurs
Enveloppez les valeurs dans une structure de résultat pour propager les erreurs dans la chaîne de traitement sans provoquer de panique :
type item struct { val int; err error }Modèle du canal Done
Utilisez un canal Done comme solution de remplacement du contexte pour les chaînes de traitement plus simples. Fermez Done pour signaler à tous les stages de s'arrêter.
done := make(chan struct{})
defer close(done)Garanties d'ordre
Une chaîne de traitement simple conserve l'ordre si chaque étape est séquentielle. Les étapes parallélisées ne conservent pas l'ordre — utilisez un champ d'index pour réordonner les résultats en aval si nécessaire.
Chaîne de traitement avec WaitGroup
La dernière étape n'a pas besoin de fermer un canal : parcourez-le simplement avec range. Utilisez WaitGroup dans la fusion des canaux pour fermer le canal regroupé une fois toutes les goroutines productrices terminées.
Utilisations concrètes
Applications courantes des chaînes de traitement : traitement de données ETL, redimensionnement d'images, analyse des journaux, systèmes de compilation et gestionnaires de requêtes en flux.
Vérification rapide
Comment propagez-vous l'annulation dans une chaîne de traitement à plusieurs étapes ?
Récapitulatif : modèle de chaîne de traitement
Points clés :
- Stage : func(in <-chan T) <-chan U — à composer pour créer des chaînes de traitement
- Annulation via le contexte ; rétropression via des canaux avec tampon
- Répartition en éventail au sein d'une étape pour le parallélisme
- Enveloppez les valeurs dans une structure de résultat pour propager les erreurs
Apprends Go avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 51
- Leçons
- 203
Questions Fréquemment Posées
La leçon « Modèles de pipeline et d’étapes » est-elle gratuite ?
Oui — le texte complet de « Modèles de pipeline et d’étapes » 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 « Modèles de pipeline et d’étapes » ?
Composer des pipelines concurrents à plusieurs étapes 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 1 sur 4.
Combien de temps prend la leçon « Modèles de pipeline et d’étapes » ?
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.
Toutes les leçons de ce cours
- Modèles de pipeline et d’étapes
- errgroup pour la gestion concurrente des erreurs
- Modèle du sémaphore
- Détection des fuites et annulation