0Pricing
Go Academy · Lezione

Modelli pipeline e stage

Comporre pipeline concorrenti a più fasi

Modelli pipeline e stage è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 1 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.

Che cos'è una pipeline?

Una pipeline concorrente è una serie di fasi collegate da canali. Ogni fase riceve valori dalla fase precedente, li trasforma e invia i risultati alla fase successiva, consentendo alle fasi di essere eseguite in concorrenza.

Pipeline semplice a tre fasi

Genera → trasforma → consuma:

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
}

Schema delle fasi

Ogni fase è una funzione che accetta un canale di input e restituisce un canale di output. Le fasi si compongono facilmente e possono essere parallelizzate in modo indipendente.

Fan-out all'interno di una pipeline

Divida una fase in N goroutine per parallelizzare il lavoro vincolato alla 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...)
}

Cancellazione con context

Passi un context a ogni fase. Quando viene cancellato, le fasi smettono di leggere e chiudono i propri canali di output, svuotando l'intera pipeline.

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
}

Back-pressure

Usi canali con buffer tra le fasi per disaccoppiare la velocità del produttore da quella del consumatore. Senza buffering, una fase lenta blocca l'intera pipeline.

out := make(chan Result, 50) // buffer 50 results

Propagazione degli errori

Avvolga i valori in una struct risultato per propagare gli errori attraverso la pipeline senza causare panic:

type item struct { val int; err error }

Schema del canale done

Usi un canale done come alternativa a context per le pipeline più semplici. Chiuda done per segnalare a tutte le fasi di arrestarsi.

done := make(chan struct{})
defer close(done)

Garanzie sull'ordine

Una pipeline semplice conserva l'ordine se ogni fase è sequenziale. Le fasi parallelizzate non conservano l'ordine: usi un campo indice per riordinare i risultati nella fase successiva, se necessario.

Pipeline con WaitGroup

L'ultima fase non deve chiudere un canale: è sufficiente iterarvi con range. Usi WaitGroup nel fan-in per chiudere il canale unificato dopo che tutte le goroutine produttrici hanno terminato.

Utilizzi nel mondo reale

Applicazioni comuni delle pipeline: elaborazione dati ETL, ridimensionamento delle immagini, analisi dei log, sistemi di build e gestori di richieste in streaming.

Verifica rapida

Come si propaga la cancellazione attraverso una pipeline composta da più fasi?

Riepilogo: schema delle pipeline

Punti chiave:

  • Fase: func(in <-chan T) <-chan U — da comporre nelle pipeline
  • Cancellazione tramite context; back-pressure tramite canali con buffer
  • Fan-out all'interno di una fase per il parallelismo
  • Avvolgere i valori in una struct risultato per la propagazione degli errori

Domande Frequenti

La lezione «Modelli pipeline e stage» è gratuita?

Sì — il testo completo di «Modelli pipeline e stage» è 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 «Modelli pipeline e stage»?

Comporre pipeline concorrenti a più fasi 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 1 di 4.

Quanto tempo richiede la lezione «Modelli pipeline e stage»?

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

  1. Modelli pipeline e stage
  2. errgroup per la gestione concorrente degli errori
  3. Modello del semaforo
  4. Rilevamento delle perdite e annullamento
← Torna a Go Academy