Come funzionano i channel?

Question

Accepted Answer

Un **channel** è un condotto tipizzato per la **comunicazione tra goroutine** — una goroutine invia valori, un'altra li riceve. I channel sono il modo in cui le goroutine di Go passano dati in sicurezza e si sincronizzano, incarnando il motto "share memory by communicating".

## Creare e utilizzare i channel

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

L'operatore `<-` sia invia (`ch <- v`) che riceve (`v := <-ch`).

## Channel senza buffer vs con 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
```

I channel **senza buffer** sincronizzano: un invio attende una ricezione (e viceversa), rendendoli uno strumento di coordinamento. I channel **con buffer** disaccopiano mittente e ricevitore fino alla dimensione del buffer.

## Chiudere i channel e iterare

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

Chiudere un channel segnala il completamento; `range` su un channel riceve finché non viene chiuso. **Solo il mittente dovrebbe chiudere** un channel.

## Errori comuni di deadlock e 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
```

I deadlock (tutti bloccati) e i panic correlati alla chiusura sono bug comuni dei channel da comprendere.

## Channel direzionali (per API chiare)

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

## Perché è importante

I channel sono il cuore del modello di concorrenza di Go e il modo idiomatico per le goroutine di comunicare e sincronizzarsi — implementando la filosofia centrale "don't communicate by sharing memory; share memory by communicating". Ti permettono di passare dati in sicurezza tra goroutine concorrenti senza lock espliciti, costruire pipeline, distribuire il lavoro e segnalare il completamento.

Comprendere le operazioni di invio/ricezione, la cruciale distinzione tra channel **senza buffer (sincronizzanti) vs con buffer (disaccoppianti)**, la semantica di chiusura (il mittente chiude; range/comma-ok la rilevano) e gli errori comuni (**deadlock** da invii/ricezioni bloccati, **panic** dalla doppia chiusura o dall'invio su un channel chiuso) è essenziale per scrivere Go concorrente corretto.

I channel (insieme alle goroutine) sono centrali nell'identità di Go e tra i concetti più importanti e frequentemente testati del linguaggio.