Go Academy · Aula

Padrões fan-in e fan-out

Mescle vários canais e distribua o trabalho

Aula 3 de 413 etapas

Padrões fan-in e fan-out é 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 é distribuição?

A distribuição divide o trabalho de um canal entre várias gorrotinas, permitindo o processamento paralelo. Cada trabalhador recebe dados do mesmo canal de entrada.

Exemplo de distribuição

Inicie N trabalhadores, todos lendo de um canal de tarefas compartilhado:

func fanOut(jobs <-chan Job, n int) {
    for i := 0; i < n; i++ {
        go func() {
            for job := range jobs {
                process(job)
            }
        }()
    }
}

O que é convergência?

A convergência combina vários canais em um só, permitindo que um único consumidor leia os resultados de muitos produtores.

Convergência com gorrotinas

Inicie uma gorrotina para cada canal de entrada; cada gorrotina encaminha valores para um canal de saída compartilhado.

func fanIn(cs ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    for _, c := range cs {
        wg.Add(1)
        go func(ch <-chan int) {
            defer wg.Done()
            for v := range ch { out <- v }
        }(c)
    }
    go func() { wg.Wait(); close(out) }()
    return out
}

Convergência com seleção

Para um número fixo de canais de entrada, um laço de seleção é mais simples do que usar uma gorrotina por canal.

func merge(a, b <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for a != nil || b != nil {
            select {
            case v, ok := <-a: if !ok { a = nil } else { out <- v }
            case v, ok := <-b: if !ok { b = nil } else { out <- v }
            }
        }
    }()
    return out
}

Etapa do fluxo

Combine distribuição e convergência para criar uma etapa do fluxo: um canal de entrada, N trabalhadores paralelos e um canal de saída combinado.

func parallelStage(in <-chan Work, n int) <-chan Result {
    outs := make([]<-chan Result, n)
    for i := 0; i < n; i++ {
        outs[i] = worker(in)
    }
    return fanIn(outs...)
}

Fechando canais corretamente

O remetente fecha o canal; o receptor detecta o fechamento pela forma de recebimento com dois valores ou usando um laço de iteração. Nunca feche pelo lado do receptor.

for v := range in { // exits when in is closed
    process(v)
}

Coordenação com WaitGroup

Use sync.WaitGroup para saber quando todos os trabalhadores da distribuição terminaram e, então, fechar o canal de saída para que os consumidores seguintes possam terminar.

Contrapressão

Use canais com buffer entre as etapas do fluxo para absorver rajadas. Dimensione o buffer com base na diferença de latência esperada entre o produtor e o consumidor.

out := make(chan Result, 100) // buffer absorbs bursts

Propagação de erros

Coloque os resultados em uma estrutura que contenha tanto o valor quanto um erro, para que os erros percorram o fluxo junto com os dados sem causar uma interrupção por pânico.

type Result struct {
    Value int
    Err   error
}

Cancelamento de contexto

Passe um contexto pelas etapas do fluxo e verifique ctx.Done() em cada etapa para que todo o fluxo pare quando for cancelado.

case <-ctx.Done():
    return ctx.Err()

Verificação rápida

Em um padrão de convergência, o que fecha o canal de saída combinado?

Responda na aula interativa

Recapitulação: convergência e distribuição

Pontos principais:

distribuição: vários trabalhadores leem de um canal
convergência: uma gorrotina por origem combina tudo em um canal de saída
WaitGroup coordena o fechamento do canal combinado
use um contexto para o cancelamento e canais com buffer para a contrapressão

Grátis para começar

Aprenda Go com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 51
Aulas: 203

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Padrões fan-in e fan-out” é grátis?

Sim — o texto completo de “Padrões fan-in e fan-out” é 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 fan-in e fan-out”?

Mescle vários canais e distribua o trabalho 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 “Padrões fan-in e fan-out”?

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