Kako delujejo kanali?

Question

Accepted Answer

**Kanal** je tipiziran kanal za **komunikacijo med goroutine-i** — ena goroutine pošilja vrednosti, druga jih sprejema. Kanali so način, kako Go goroutine-i varno prenašajo podatke in sinhronizirajo, kar uteleša moto »deli spomin z komunikacijo«.

## Ustvarjanje in uporaba kanalov

```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 `<-` tako pošilja (`ch <- v`) kot sprejema (`v := <-ch`).

## Nebufferirani vs. bufferirani kanali

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

**Nebufferirani** kanali sinhronizirajo: pošiljanje čaka na sprejem (in obratno), kar jih naredi koordinacijski instrument. **Bufferirani** kanali ločijo pošiljalca in prejemnika do velikosti medpomnilnika.

## Zapiranje kanalov in iteracija

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

Zapiranje kanala signalizira dokončanje; `range` nad kanalom sprejema dokler ni zaprt. **Samo pošiljalec bi moral zapreti** kanal.

## Pogosti serijski in panika problemi

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

Serijskost (vsi blokirani) in panika problemi, povezani z zapiranjem, so pogosti napake pri kanalih, ki jih je treba razumeti.

## Usmerjeni kanali (za jasne API-je)

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

## Zakaj je to važno

Kanali so srce Go-ovega modela konkurenčnosti in idiomatski način, kako goroutine-i komunicirajo in sinhronizirajo — izvajajo jedro filozofije »ne komuniciraj z delitvijo spomin; deli spomin z komunikacijo«. Omogočajo varno prenašanje podatkov med konkurenčnimi goroutine-i brez eksplicitnih zakljenjev, gradnjo cevovodov, distribucijo dela in signalizacijo dokončanja.

Razumevanje operacij pošiljanja/sprejema, ključne **razlike med nebufferirani (sinhronizirajo) in bufferirani (ločijo)** kanali, semantike zapiranja (pošiljalec zapre; `range`/vejica-ok jo zaznata) in pogostih problemov (**serijskost** iz blokiranih pošiljanj/sprejetkov, **paniki** iz dvojnega zapiranja ali pošiljanja na zaprt kanal) je ključna za pisanje pravilne konkurenčne Go kode.

Kanali (z goroutine-i) so osrednji za Go-ovo identiteto in med najbolj važnimi ter pogosto testirani pojmi v jeziku.