Hogyan működnek a channelok?

Question

Accepted Answer

A **channel** egy típusos csatorna a **goroutine-ok közötti kommunikációhoz** — az egyik goroutine értékeket küld, a másik fogadja azokat. A channelok az a módszer, ahogyan a Go goroutine-ok biztonságosan átadják az adatokat és szinkronizálnak, megvalósítva az "emlékezetet oszd meg kommunikációval" mondást.

## Channelok létrehozása és használata

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

A `<-` operátor mind küld (`ch <- v`), mind fogad (`v := <-ch`).

## Pufferelt és nem pufferelt channelok

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

A **nem pufferelt** channelok szinkronizálnak: egy küldés egy fogadásra vár (és fordítva), összehozó eszközzé téve őket. A **pufferelt** channelok leválasztják a küldőt és a vevőt a puffer méretéig.

## Channelok lezárása és range-ezés

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

Egy channel lezárása jelzi a befejezést; a channel felett `range` -ezéssel az addig fogad, amíg nem zárult le. **Csak a küldőnek kellene** lezárnia a channelt.

## Gyakori deadlock és panic buktatók

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

A deadlock-ok (mindenki blokkolva) és a záráshoz kapcsolódó panic-ek a gyakori channel-buktatók, amelyeket meg kell érteni.

## Irányított channelok (világos API-khez)

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

## Miért számít

A channelok a Go párhuzamossági modelljének szíve és az idiomatikus módja annak, hogy a goroutine-ok kommunikálják és szinkronizálják egymást — megvalósítva az alapvető filozófiát: "ne kommunikálj az emlékezet megosztásával; oszd meg az emlékezetet kommunikációval." Lehetővé teszik, hogy biztonságosan átadd az adatokat az egyidejű goroutine-ok között explicit zárolás nélkül, csatornákat építs, eloszthasd a munkát, és jelezd a befejezést.

A küldési/fogadási műveletek megértése, az **nem pufferelt (szinkronizáló) kontra pufferelt (leválasztó)** kritikus megkülönböztetése, a zárási szemantika (a küldő zár; range/comma-ok felismeri), valamint az általános buktatók (**deadlock-ok** a blokkolt küldésekből/fogadásokból, **panic-ek** a kétszeri zárásból vagy a zárt csatornára küldésből) elengedhetetlen a helyes egyidejű Go kódírásához.

A channelok (a goroutine-okkal) a Go identitásának központjában vannak, és a nyelv legfontosabb és leggyakrabban tesztelt fogalmai közé tartoznak.