Jak fungují kanály?

Question

Jak fungují kanály?

Accepted Answer

**Kanál** je typizovaný kanál pro **komunikaci mezi goroutines** — jeden goroutine posílá hodnoty, druhý je přijímá. Kanály jsou způsob, jak Go goroutines bezpečně předávají data a synchronizují se, ztělesňující motto "sdílej paměť komunikací."

## Vytváření a používání kanálů

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

Operátor `<-` odesílá (`ch <- v`) i přijímá (`v := <-ch`).

## Unbuffered vs buffered kanály

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

**Unbuffered** kanály synchronizují: odesílání čeká na příjem (a naopak), což z nich dělá nástroj pro koordinaci. **Buffered** kanály oddělují odesílatele a příjemce až do velikosti vyrovnávací paměti.

## Zavírání kanálů a iterace

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

Zavření kanálu signalizuje dokončení; iterace `range` přes kanál přijímá, dokud není zavřen. **Pouze odesílatel by měl zavřít** kanál.

## Běžné deadlocky a paničky

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

Deadlocky (všichni blokováni) a paniky související se zavíráním jsou běžné chyby kanálů, kterým je třeba porozumět.

## Směrové kanály (pro jasná API)

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

## Proč je to důležité

Kanály jsou jádrem Goova modelu souběhu a idiomatickým způsobem, jak se goroutines komunikují a synchronizují — implementují základní filozofii "nekomunikuj sdílením paměti; sdílej paměť komunikací." Umožňují vám bezpečně předávat data mezi souběžnými goroutines bez explicitních zámků, vytvářet pipelines, distribuovat práci a signalizovat dokončení.

Porozumění operacím odesílání/příjmu, kritickému rozlišení **unbuffered (synchronizující) vs buffered (oddělující)**, sémantice zavírání (odesílatel zavírá; range/comma-ok to detekuje) a běžným chybám (**deadlocky** z blokovaných odesílání/příjmů, **paniky** ze zavření dvakrát nebo odesílání na zavřený kanál) je nezbytné pro psaní správného souběžného Gou.

Kanály (spolu s goroutines) jsou centrální pro identitu Go a patří mezi nejdůležitější a nejčastěji testované koncepty v jazyce.