Jak działają kanały?

Question

Accepted Answer

**Kanał** to typowany kanał do **komunikacji między goroutines** — jedna goroutine wysyła wartości, a druga je odbiera. Kanały to sposób, w jaki goroutines Go bezpiecznie przekazują dane i synchronizują się, ucieleśniając motto "share memory by communicating".

## Tworzenie i używanie kanałów

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

Operator `<-` zarówno wysyła (`ch <- v`), jak i odbiera (`v := <-ch`).

## Kanały niebuforowane a buforowane

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

**Kanały niebuforowane** synchronizują: wysłanie czeka na odbiór (i vice versa), czyniąc je narzędziem koordynacji. **Kanały buforowane** rozdzielają nadawcę i odborcę do rozmiaru bufora.

## Zamykanie kanałów i iterowanie

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

Zamknięcie kanału sygnalizuje ukończenie; `range` nad kanałem odbiera do momentu jego zamknięcia. **Tylko nadawca powinien zamknąć** kanał.

## Powszechne pułapki deadlock i 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
```

Deadlocki (wszyscy zablokowani) i paniki związane z zamknięciem to powszechne błędy kanałów do zrozumienia.

## Kanały kierunkowe (dla jasnych API)

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

## Dlaczego to ważne

Kanały są sercem modelu współbieżności Go i idiomatycznym sposobem komunikacji i synchronizacji goroutines — wdrażającym podstawową filozofię "don't communicate by sharing memory; share memory by communicating". Pozwalają bezpiecznie przekazywać dane między współbieżnymi goroutines bez jawnych blokad, budować potoki, rozprowadzać pracę i sygnalizować ukończenie.

Zrozumienie operacji wysyłania/odbierania, kluczowego rozróżnienia **niebuforowane (synchronizujące) a buforowane (rozdzielające)**, semantyki zamykania (nadawca zamyka; range/comma-ok to wykrywa) i powszechnych pułapek (**deadlocki** z zablokowanych wysyłań/odbiorów, **paniki** z zamknięcia dwa razy lub wysłania na zamknięty kanał) jest niezbędne do pisania prawidłowego Go współbieżnego.

Kanały (z goroutines) są centralne dla tożsamości Go i wśród najbardziej ważnych i najczęściej testowanych koncepcji w języku.