Go Academy · Aula

Estágios do pipeline

Encadeie estágios de canais

Estágios do pipeline é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

O que é um fluxo de processamento

Um fluxo de processamento é uma série de stages conectadas por canais. Cada stage recebe valores, executa um trabalho e envia os resultados para a próxima stage. Os dados fluem como em uma linha de montagem.

Cada stage é uma gorrotina
As stages se comunicam somente por canais
São combináveis e fáceis de analisar

Convenção de assinatura de stage

Por convenção, cada stage recebe um ou mais canais de entrada somente para leitura e retorna um canal de saída somente para leitura. Isso permite encadear stages.

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

A stage de origem

A primeira stage produz dados. Ela geralmente recebe uma fatia ou argumentos variádicos e os envia em fluxo para um canal.

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

Uma stage de transformação

Esta stage multiplica cada valor por dez. Ela lê de in e escreve o valor transformado em 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
}

Uma stage de filtragem

Um filtro encaminha somente os valores que atendem a uma condição. Aqui, mantemos os números pares e descartamos o restante.

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
}

Encadeando stages

Componha stages passando uma saída como a entrada seguinte. O encadeamento se lê quase como uma frase.

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

defer close(out)

Usar defer close(out) garante que o canal de saída seja fechado quando a gorrotina da stage retornar, mesmo que você adicione retornos antecipados mais tarde. Isso propaga o sinal de fim do fluxo para as stages seguintes.

Um fluxo de processamento completo

Origem, depois filtragem, depois transformação. Execute-o para ver apenas o décuplo das entradas pares.

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)
    }
}

Transmissão contínua, não processamento em lotes

Os valores fluem pelo fluxo de processamento um por vez, à medida que são produzidos. A stage de transformação pode começar a trabalhar no primeiro item antes que a origem tenha emitido o último. Isso mantém a memória baixa e a latência pequena.

Os fluxos de processamento são preguiçosos

Uma stage não faz nenhum trabalho até que algo leia sua saída. Se o consumidor parar de percorrer o canal, as stages anteriores ficarão bloqueadas ao enviar valores. Essa contrapressão natural evita computação desperdiçada.

Adicionando concorrência

Para acelerar uma stage lenta, distribua o trabalho entre várias instâncias que leiam da mesma entrada e agregue as saídas. A assinatura da stage permanece a mesma; somente as conexões mudam.

Verificação rápida

Avalie seu conhecimento sobre fluxos de processamento.

Recapitulação

Você aprendeu sobre stages de fluxos de processamento:

Cada stage: recebe uma entrada somente para leitura e retorna uma saída somente para leitura
defer close(out) propaga o fim do fluxo
Encadeie stages aninhando chamadas
Os fluxos de processamento transmitem dados de forma preguiçosa, com contrapressão

Perguntas Frequentes

A aula “Estágios do pipeline” é grátis?

Sim — o texto completo de “Estágios do pipeline” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Estágios do pipeline”?

Encadeie estágios de canais Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Estágios do pipeline”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy