Canais: Bufferizados, Não Bufferizados e Regras de Fechamento

Canais transportam valores e sincronização entre goroutines.

Escolher entre capacidade bufferizada e não bufferizada e seguir as regras de propriedade de fechamento previne deadlocks e panics em pipelines de produção.

Resumo

Um canal não bufferizado sincroniza os parceiros: o remetente bloqueia até que o receptor esteja pronto.

Um canal bufferizado armazena até cap valores sem um receptor esperando.

Fechar um canal transmite "não mais envios" para os receptores; apenas remetentes devem fechar.

range em um canal drena até o fechamento; o recebimento de dois valores v, ok := <-ch detecta o fechamento explicitamente.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

package main
 
import "fmt"
 
func main() {
    ch := make(chan int, 2) // bufferizado
    ch <- 1
    ch <- 2
    close(ch)
 
    for v := range ch {
        fmt.Println(v)
    }
 
    v, ok := <-ch
    fmt.Println(v, ok) // 0 false após drenar o canal fechado
}

Quando usar isso:

• Não bufferizado: passagem de controle, confirmação, pressão de retorno estrita entre estágios.
• Bufferizado: suavizar picos quando produtor e consumidor rodam em velocidades diferentes.
• Fechar: produtor terminou; consumidores devem sair dos loops range.
• Nunca feche do lado do receptor em pipelines compartilhados.

Exemplo de Trabalho

package main
 
import (
    "fmt"
    "sync"
)
 
func producer(out chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := 1; i <= 5; i++ {
        out <- i
    }
    close(out) // remetente fecha
}
 
func consumer(in <-chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for v := range in {
        fmt.Println("got", v)
    }
}
 
func main() {
    ch := make(chan int) // não bufferizado - passagem de controle síncrona
    var wg sync.WaitGroup
    wg.Add(2)
    go producer(ch, &wg)
    go consumer(ch, &wg)
    wg.Wait()
}

O que isso demonstra:

• Tipos direcionais chan<- e <-chan documentam o uso apenas para envio/recebimento.
• O remetente fecha após o último envio para que o range no consumidor termine.
• O canal não bufferizado acopla o tempo do produtor e do consumidor.
• WaitGroup espera que ambos os lados terminem.

Análise Profunda

Como Funciona

• O envio no canal copia o valor para o buffer do canal ou o entrega diretamente (não bufferizado).
• O recebimento copia para fora e libera um slot do buffer ou desbloqueia um remetente.
• close(ch) define a flag de fechado; envios futuros causam panic, recebimentos retornam o valor zero com ok == false.
• Enviar em um canal fechado causa panic; receber de um canal fechado é seguro (retorna o valor zero).
• len(ch) e cap(ch) reportam os elementos enfileirados e a capacidade.

Bufferizado vs. Não Bufferizado

Regras de Fechamento

Notas Go

// Fan-in: uma goroutine fecha após todos os remetentes terminarem
func fanIn(inputs ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    wg.Add(len(inputs))
    for _, in := range inputs {
        go func(c <-chan int) {
            defer wg.Done()
            for v := range c {
                out <- v
            }
        }(in)
    }
    go func() {
        wg.Wait()
        close(out)
    }()
    return out
}

Armadilhas

• Envio em canal fechado - Panic. Correção: apenas o remetente fecha; use sync.Once para proteger o fechamento.
• Vazamento: receptor foi embora, remetente bloqueia - Envio não bufferizado espera para sempre. Correção: context cancel, select com timeout, ou buffer.
• Range sem fechamento - Consumidor bloqueia para sempre. Correção: o remetente deve fechar ou cancelar upstream.
• Fechando canal voltado para o consumidor enquanto envia - Race condition com envios em andamento. Correção: feche apenas após todos os envios serem concluídos (geralmente WaitGroup e depois fechar).
• Buffer enorme mascarando sobrecarga - Memória cresce, latência oculta. Correção: dimensionar para o SLA; descarregar carga quando cheio.

49454e4f4d5f434e4f5904434556494d43451e1f1c56181a181c1a1d

Alternativas

FAQs

Relacionados

• Fundamentos de Concorrência - primeiros exemplos de canais
• Instrução select e Casos Padrão - multiplexação de recebimentos
• Concorrência em Go: Goroutines e Canais Primeiro - visão geral de CSP
• sync.Mutex, RWMutex e WaitGroup - alternativa de estado compartilhado
• Boas Práticas em Fundamentos de Concorrência - hábitos com canais

Versões de Stack: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, go fix modernizers - verifique o patch na compilação), chi (última - verifique na compilação), gin (última - verifique na compilação), echo (última - verifique na compilação), google.golang.org/grpc (última - verifique na compilação), sigs.k8s.io/controller-runtime (última - verifique na compilação), kubebuilder (última - verifique na compilação), tinygo (última - verifique os alvos de placa na compilação), wazero (última - verifique na compilação) e golangci-lint (última - verifique o conjunto de linters na compilação).