Internos de Canal: Bufferizado vs Não Bufferizado

Canais são filas tipadas com semântica de bloqueio coordenadas pelo runtime. Um canal não bufferizado força um encontro entre remetente e receptor; um canal bufferizado armazena valores em um anel fixo até que a capacidade seja preenchida. close altera as regras de envio/recebimento e é o sinal idiomático de broadcast.

Resumo

Uma variável de canal é um descritor para uma estrutura hchan que contém um buffer, filas de goroutines para envio/recebimento e sincronização baseada em locks. Entender os limites de bloqueio previne deadlocks, vazamentos e uso indevido de close.

Receita

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

ch := make(chan int)      // não bufferizado - sincronização na entrega
buf := make(chan int, 8)  // bufferizado - até 8 envios sem receptor
 
buf <- 1
v := <-buf
 
close(buf)
v, ok := <-buf // ok false após o buffer ser drenado

Quando usar isso:

• Sinalização entre goroutines com garantias de happens-before
• Pools de workers com backlog limitado (bufferizado)
• Estágios de pipeline entregando a propriedade de ponteiros
• Broadcast de desligamento após close (receptores saem de loops)

Exemplo de Trabalho

package main
 
import (
	"fmt"
	"sync"
)
 
func main() {
	ch := make(chan int, 2)
	var wg sync.WaitGroup
 
	wg.Add(1)
	go func() {
		defer wg.Done()
		ch <- 1
		ch <- 2
		close(ch)
	}()
 
	for v := range ch {
		fmt.Println(v)
	}
	wg.Wait()
}

O que isso demonstra:

• Canal bufferizado aceita dois envios sem um receptor esperando
• close permite que range drene os valores restantes e então saia
• Apenas o remetente deve chamar close na maioria dos designs

Análise Profunda

Como Funciona

• Estrutura hchan: Anel de buffer, qcount, filas de espera de envio/recebimento (listas ligadas sudog), lock e informações do tipo do elemento.
• Envio não bufferizado: Bloqueia até que um receptor execute o recebimento; os valores são copiados diretamente de goroutine para goroutine (entrega).
• Envio bufferizado: Copia para o buffer se houver espaço; bloqueia quando o buffer está cheio até que um recebimento libere um slot.
• Recebimento: Bloqueia quando vazio (a menos que fechado); em um canal fechado e vazio retorna o valor zero e ok == false.

Regras de Bloqueio

Semântica de close

• close(ch): Não mais envios; receptores recebem os valores bufferizados restantes; envios futuros recebem o valor zero com ok == false.
• Múltiplos receptores: Todos os receptores bloqueados acordam; um ganha cada valor.
• select com default: Operações não bloqueantes usam o caso default quando o canal não está pronto.

Notas de Go

// Propriedade: o remetente fecha quando termina de produzir
go func() {
	defer close(out)
	for item := range work {
		out <- process(item)
	}
}()
 
// Não feche do lado do receptor, a menos que o protocolo diga o contrário
// Range sai quando o canal é fechado e drenado

Armadilhas

• Fechar pelo receptor - Fechar da goroutine errada causa corrida com os envios. Correção: documente que o produtor fecha; use sync.Once apenas quando o padrão for claro.
• Envio em canal fechado - Causa pânico imediatamente. Correção: proteja com select + ctx.Done() ou pare de enviar antes de fechar.
• Fechar duas vezes - Causa pânico. Correção: uma única goroutine proprietária fecha; outras sinalizam via contexto.
• Tamanho do buffer 0 vs não bufferizado - make(chan T, 0) é não bufferizado; ainda diferente de esquecer a intenção de capacidade. Correção: omita a capacidade para sincronização; defina um buffer explícito para throughput.
• Goroutine vazada bloqueada em envio - Sem receptor e sem caminho de cancelamento. Correção: combine com cancelamento de context e select.
• Usar o comprimento do canal para sincronização - len(ch) é um snapshot, não um contrato de profundidade de fila. Correção: rastreie contagens explicitamente se o protocolo exigir.

Alternativas

FAQs

Relacionados

• Fundamentos de Concorrência - goroutines e select
• Evitando Vazamentos de Goroutine - padrões de desligamento
• Fundamentos de Tipos de Dados - introdução à criação de canais
• Modelo de Memória do Go - happens-before com canais
• Pacote Context - cancelamento junto com pipelines de canais

Links Relacionados Externos

• Especificação da Linguagem Go - A referência formal da linguagem.
• Go by Example - Exemplos de código práticos anotados.
• Blog Go (Oficial) - Anúncios oficiais, análises profundas e notas de lançamento.
• Concurrency in Go - Katherine Cox-Buday.
• Concurrency in Go (O'Reilly) - Mesmo livro na O'Reilly.

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 versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação).