0Pricing
Go Academy · Aula

Padrões de pipeline e estágios

Componha pipelines concorrentes com vários estágios

Padrões de pipeline e estágios é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 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 concorrente é uma série de stages conectados por canais. Cada stage recebe valores do estágio anterior, transforma-os e envia os resultados para o estágio seguinte, permitindo que os stages sejam executados simultaneamente.

Fluxo simples de três etapas

Gerar → transformar → consumir:

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
}

Padrão de stage

Cada stage é uma função que recebe um canal de entrada e retorna um canal de saída. Os stages podem ser compostos facilmente e paralelizados de forma independente.

Distribuição dentro de um fluxo

Divida um stage em N gorrotinas para paralelizar trabalho limitado pela 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...)
}

Cancelamento com contexto

Passe um contexto para cada stage. Quando ele for cancelado, os stages deixarão de ler e fecharão seus canais de saída, esvaziando todo o fluxo.

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
}

Contrapressão

Use canais com buffer entre os stages para desacoplar a velocidade do produtor e do consumidor. Sem buffer, um stage lento interrompe todo o fluxo.

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

Propagação de erros

Envolva os valores em uma estrutura de resultado para propagar erros pelo fluxo sem causar um panic:

type item struct { val int; err error }

Padrão de canal Done

Use um canal Done como alternativa ao contexto em fluxos mais simples. Feche Done para sinalizar que todos os stages devem parar.

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

Garantias de ordenação

Um fluxo simples preserva a ordem se cada stage for sequencial. Stages paralelizados não preservam a ordem — use um campo de índice para reordenar os resultados mais adiante, se necessário.

Fluxo com WaitGroup

O último stage não precisa fechar um canal — basta iterar sobre ele. Use WaitGroup na combinação das entradas para fechar o canal mesclado depois que todas as gorrotinas produtoras terminarem.

Uso no mundo real

Aplicações comuns de fluxos: processamento de dados ETL, redimensionamento de imagens, análise de registros, sistemas de compilação e manipuladores de requisições em fluxo contínuo.

Verificação rápida

Como propagar o cancelamento por um fluxo de várias etapas?

Recapitulação: padrão de fluxo

Pontos principais:

  • Stage: func(in <-chan T) <-chan U — componha stages para criar fluxos
  • Cancelamento por meio de contexto; contrapressão por meio de canais com buffer
  • Distribuição dentro de um stage para obter paralelismo
  • Envolva os valores em uma estrutura de resultado para propagar erros

Perguntas Frequentes

A aula “Padrões de pipeline e estágios” é grátis?

Sim — o texto completo de “Padrões de pipeline e estágios” é 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 “Padrões de pipeline e estágios”?

Componha pipelines concorrentes com vários estágios 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 1 de 4.

Quanto tempo leva a aula “Padrões de pipeline e estágios”?

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

  1. Padrões de pipeline e estágios
  2. errgroup para tratamento concorrente de errors
  3. Padrão de semáforo
  4. Detecção de vazamentos e cancelamento
← Voltar para Go Academy