Kaip veikia kanalai?

Question

Accepted Answer

**Kanalas** yra tipizuotas vamzdis **ryšiui tarp goroutine** — viena goroutine siunčia reikšmes, kita jas gauna. Kanalai yra būdas, kaip Go goroutine saugiai perduoda duomenis ir sinchronizuojasi, įkūnydami šūkį "share memory by communicating".

## Kanalų kūrimas ir naudojimas

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

`<-` operatorius tiek siunčia (`ch <- v`), tiek gauna (`v := <-ch`).

## Nebuferinti vs subuferintai kanalai

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

**Nebuferintais** kanalais sinchronizuojama: siuntimas laukia priėmimo (ir atvirkščiai), todėl jie yra koordinavimo įrankis. **Buferinti** kanalai atskelia siuntėją ir gavėją iki buferio dydžio.

## Kanalų uždarymas ir 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
```

Kanalo uždarymas signalizuoja apie pabaigą; `range` per kanalą gauna, kol jis nėra uždartas. **Tik siuntėjas turėtų uždaryti** kanalą.

## Bendrų aklaivės ir panikos spąstai

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

Aklaivės (visi užblokuoti) ir su uždarymu susiję panikos yra bendri kanalų defektai, kuriuos reikia suprasti.

## Nukreiptieji kanalai (aiškiems API)

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

## Kodėl tai svarbu

Kanalai yra Go lygiagretumo modelio širdis ir idiomatinis būdas goroutine komunikuoti ir sinchronizuotis — įgyvendinant pagrindinę filosofiją "nekomunikuokite dalindamiesi atmintimi; dalinkitės atmintimi komunikuodami". Jie leidžia saugiai perduoti duomenis tarp lygiagretūs goroutine be aiškių užrakinimo, sukurti kanalizacijas, paskirstyti darbą ir signalizuoti apie pabaigą.

Supratimas apie siuntimo/priėmimo operacijas, svarbų skirtumą tarp **nebuferinto (sinchronizuojančio) ir bufferinto (atskiriančio)** kanalų, uždarymo semantiką (siuntėjas uždaro; range/comma-ok ją nustato) ir bendruosius spąstus (**aklaivės** iš užblokuotų siuntimų/priėmimų, **panikos** iš dvigubo uždarymo arba siuntimo į uždarytą kanalą) yra būtina norint rašyti teisingą lygiagretų Go.

Kanalai (kartu su goroutine) yra Go tapatybės centras ir viena iš svarbiausių ir dažniausiai testuojamų kalbos koncepcijų.