Como os canais funcionam?

Question

Accepted Answer

Um **channel** é um conduto tipado para **comunicação entre goroutines** — uma goroutine envia valores, outra os recebe. Canais são como as goroutines do Go passam dados com segurança e sincronizam, incorporando o lema "share memory by communicating".

## Criando e usando canais

```go
ch := make(chan int)     // an unbuffered channel of ints

go func() {
    ch <- 42             // SEND a value into the channel (arrow points INTO ch)
}()

value := <-ch            // RECEIVE a value from the channel (arrow points OUT)
fmt.Println(value)       // 42
```

O operador `<-` tanto envia (`ch <- v`) quanto recebe (`v := <-ch`).

## Canais sem buffer vs com buffer

```go
// UNBUFFERED — send blocks until a receiver is ready (synchronization point)
ch := make(chan int)
// sending blocks until another goroutine receives → they "rendezvous"

// BUFFERED — holds up to N values; send blocks only when the buffer is FULL
buf := make(chan int, 3)
buf <- 1; buf <- 2; buf <- 3   // these don't block (buffer has room)
buf <- 4                        // blocks now — buffer is full
```

Canais **sem buffer** sincronizam: um envio aguarda um recebimento (e vice-versa), tornando-os uma ferramenta de coordenação. Canais **com buffer** desacoplam remetente e receptor até o tamanho do buffer.

## Fechando canais e iteração

```go
ch := make(chan int)
go func() {
    for i := 0; i < 3; i++ { ch <- i }
    close(ch)               // signal "no more values" (only the SENDER closes)
}()

for v := range ch {         // receives until the channel is CLOSED
    fmt.Println(v)
}

// the comma-ok form detects a closed channel
v, ok := <-ch               // ok = false if the channel is closed and drained
```

Fechar um channel sinaliza conclusão; `range` em um channel recebe até que seja fechado. **Apenas o remetente deve fechar** um channel.

## Deadlocks comuns e armadilhas de panic

```go
// ❌ deadlock — sending on an unbuffered channel with no receiver
ch := make(chan int)
ch <- 1                     // 💥 fatal error: all goroutines asleep - deadlock!

// ❌ panic — operations on/after close
close(ch); close(ch)        // 💥 panic: close of closed channel
close(ch); ch <- 1          // 💥 panic: send on closed channel
v := <-closedCh             // ✅ OK — receiving from a closed channel returns the zero value
```

Deadlocks (todos bloqueados) e panics relacionados a fechamento são bugs comuns de channel para entender.

## Canais direcionais (para APIs claros)

```go
func producer(out chan<- int) { out <- 1 }   // send-only
func consumer(in <-chan int)  { <-in }         // receive-only
```

## Por que isso importa

Canais são o coração do modelo de concorrência do Go e a forma idiomática para goroutines se comunicarem e sincronizarem — implementando a filosofia central "don't communicate by sharing memory; share memory by communicating". Eles permitem passar dados com segurança entre goroutines concorrentes sem locks explícitos, construir pipelines, distribuir trabalho e sinalizar conclusão.

Compreender as operações de envio/recebimento, a distinção crucial **sem buffer (sincronizando) vs com buffer (desacoplando)**, semântica de fechamento (remetente fecha; range/comma-ok detecta), e as armadilhas comuns (**deadlocks** de envios/recebimentos bloqueados, **panics** de fechar duas vezes ou enviar em um channel fechado) é essencial para escrever Go concorrente correto.

Canais (com goroutines) são centrais à identidade do Go e entre os conceitos mais importantes e frequentemente testados da linguagem.