Go Academy · Lezione

Fasi della pipeline

Collegare le fasi tramite canali

Fasi della pipeline è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 3 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 è una serie di fasi collegate da canali. Ogni fase riceve valori, esegue del lavoro e invia i risultati alla fase successiva. I dati fluiscono come su una catena di montaggio.

Ogni fase è una goroutine
Le fasi comunicano solo tramite canali
È componibile e facile da comprendere

Convenzione per la firma delle fasi

Per convenzione, ogni fase accetta uno o più canali di input di sola ricezione e restituisce un canale di output di sola ricezione. In questo modo è possibile concatenare le fasi.

func stage(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for v := range in {
            out <- v
        }
    }()
    return out
}

La fase sorgente

La prima fase produce i dati. Spesso accetta uno slice o argomenti variadici e li trasmette in streaming a un canale.

func numbers(vals ...int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for _, v := range vals {
            out <- v
        }
    }()
    return out
}

Una fase di trasformazione

Questa fase moltiplica ogni valore per dieci. Legge da in e scrive il valore trasformato in out.

func tenfold(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for v := range in {
            out <- v * 10
        }
    }()
    return out
}

Una fase di filtro

Un filtro inoltra solo i valori che soddisfano una condizione. In questo caso vengono mantenuti i numeri pari e scartati gli altri.

func evens(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for v := range in {
            if v%2 == 0 {
                out <- v
            }
        }
    }()
    return out
}

Concatenare le fasi

Componga le fasi passando l'output di una fase come input della successiva. La catena si legge quasi come una frase.

pipe := tenfold(evens(numbers(1, 2, 3, 4)))
for v := range pipe {
    fmt.Println(v)
}

defer close(out)

Utilizzare defer close(out) garantisce che il canale di output venga chiuso quando la goroutine della fase termina, anche se in seguito vengono aggiunti ritorni anticipati. In questo modo il segnale di fine dello stream viene propagato a valle.

Una pipeline completa

Prima la sorgente, poi il filtro e infine la trasformazione. Esegua il programma per vedere solo il decuplo degli input pari.

package main

import "fmt"

func numbers(vals ...int) <-chan int {
    out := make(chan int)
    go func() { defer close(out); for _, v := range vals { out <- v } }()
    return out
}

func evens(in <-chan int) <-chan int {
    out := make(chan int)
    go func() { defer close(out); for v := range in { if v%2 == 0 { out <- v } } }()
    return out
}

func tenfold(in <-chan int) <-chan int {
    out := make(chan int)
    go func() { defer close(out); for v := range in { out <- v * 10 } }()
    return out
}

func main() {
    for v := range tenfold(evens(numbers(1, 2, 3, 4, 5, 6))) {
        fmt.Println(v)
    }
}

Streaming, non elaborazione in batch

I valori attraversano la pipeline uno alla volta, man mano che vengono prodotti. La fase di trasformazione può iniziare a lavorare sul primo elemento prima che la sorgente abbia emesso l'ultimo. Ciò mantiene ridotti l'uso della memoria e la latenza.

Le pipeline sono lazy

Una fase non esegue alcun lavoro finché qualcuno non legge dal suo output. Se il consumer interrompe il range, le fasi a monte si bloccano durante l'invio. Questa backpressure naturale evita calcoli superflui.

Aggiungere la concorrenza

Per velocizzare una fase lenta, ne esegua il fan-out creando più istanze che leggono dallo stesso input, quindi riunisca i relativi output. La firma della fase rimane invariata: cambia solo il collegamento tra le fasi.

Verifica rapida

Verifichi la Sua conoscenza delle pipeline.

Riepilogo

Ha imparato a usare le fasi delle pipeline:

Ogni fase: input di sola ricezione e output di sola ricezione
defer close(out) propaga la fine dello stream
Concatenare le fasi annidando le chiamate
Le pipeline eseguono lo streaming in modo lazy con backpressure

Domande Frequenti

La lezione «Fasi della pipeline» è gratuita?

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

Collegare le fasi tramite canali 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 3 di 4.

Quanto tempo richiede la lezione «Fasi della pipeline»?

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

← Torna a Go Academy