Kako rade channels?

Question

Kako rade channels?

Accepted Answer

**Channel** je tipiziran kanal za **komunikaciju između goroutina** — jedna goroutina šalje vrijednosti, druga ih prima. Channels su način na koji Go goroutine sigurno prosljeđuju podatke i sinhroniziraju se, воплощавајући moto "dijeli memoriju komunikacijom."

## Stvaranje i korištenje channels

```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 `<-` i šalje (`ch <- v`) i prima (`v := <-ch`).

## Unbuffered vs buffered channels

```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** channels sinhroniziraju: slanje čeka primitak (i obrnuto), čineći ih alatom za koordinaciju. **Buffered** channels odvajaju pošiljaoca i primatelja do veličine memorijskog bafera.

## Zatvaranje channels i obilaženje s range

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

Zatvaranje kanala signalizira završetak; `range` preko kanala prima dok se ne zatvori. **Samo pošiljaoc bi trebao** zatvoriti kanal.

## Česti deadlock i panic 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
```

Deadlocks (svi blokirani) i panics vezani uz zatvaranje česti su channel problemi za razumijevanje.

## Usmjereni channels (za jasne API-je)

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

## Zašto je to važno

Channels su srce Go-ovog modela konkurentnosti i idiomatski način za goroutine da komuniciraju i sinhroniziraju se — primjenjujući temeljnu filozofiju "nemojte komunicirati dijeljenjem memorije; dijelite memoriju komunikacijom." Omogućuju vam sigurno prosljeđivanje podataka između konkurentnih goroutina bez eksplicitnih brava, izgradnju cjevovoda, distribuciju rada i signaliziranje završetka.

Razumijevanje operacija slanja/primitka, ključne razlike **unbuffered (sinhroniziranje) vs buffered (odvajanje)**, semantiku zatvaranja (pošiljaoc zatvara; range/comma-ok je detektiraju), i česte probleme (**deadlocks** iz blokiranih slanja/primanja, **panics** iz dvostrukog zatvaranja ili slanja na zatvoreni kanal) bitno je za pisanje ispravne konkurentne Go koda.

Channels (s goroutinama) su centralni za Go identitet i među najvažnijim i najčešće testiranim konceptima u jeziku.