¿Cómo funcionan los canales?

Question

Accepted Answer

Un **canal** es un conducto tipado para la **comunicación entre goroutines** — una goroutine envía valores, otra los recibe. Los canales son la forma en que las goroutines de Go pasan datos de manera segura y se sincronizan, embodiendo el lema "compartir memoria comunicándose."

## Creación y uso de canales

```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
```

El operador `<-` tanto envía (`ch <- v`) como recibe (`v := <-ch`).

## Canales no almacenados en búfer vs almacenados

```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
```

Los canales **no almacenados en búfer** sincronizan: un envío espera a una recepción (y viceversa), lo que los convierte en una herramienta de coordinación. Los canales **almacenados en búfer** desacoplan el remitente y el receptor hasta el tamaño del búfer.

## Cierre de canales e iteración

```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
```

Cerrar un canal señaliza la finalización; `range` sobre un canal recibe hasta que se cierra. **Solo el remitente debe cerrar** un canal.

## Errores comunes de bloqueo mutuo y pánico

```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
```

Los bloqueos mutuos (todos bloqueados) y los pánicos relacionados con el cierre son errores de canal comunes que se deben entender.

## Canales direccionales (para API claras)

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

## Por qué es importante

Los canales son el corazón del modelo de concurrencia de Go y la forma idiomática en que las goroutines se comunican y sincronizan — implementando la filosofía central "no comuniques compartiendo memoria; comparte memoria comunicándote." Te permiten pasar datos de forma segura entre goroutines concurrentes sin cerraduras explícitas, construir pipelines, distribuir trabajo y señalar finalización.

Comprender las operaciones de envío/recepción, la distinción crítica **no almacenado en búfer (sincronización) vs almacenado en búfer (desacoplamiento)**, la semántica de cierre (el remitente cierra; range/comma-ok la detecta), y los errores comunes (**bloqueos mutuos** de envíos/recepciones bloqueados, **pánicos** por cerrar dos veces o enviar en un canal cerrado) es esencial para escribir Go concurrente correcto.

Los canales (con goroutines) son centrales para la identidad de Go y entre los conceptos más importantes y frecuentemente probados en el lenguaje.