Conas a oibríonn channels?

Question

Accepted Answer

Is **channel** ann ná ducht tipíochtaithe do **chomunaint idir goroutines** — seolann goroutine amháin luachanna, faigheann ceann eile iad. Is iad na channels an bealach sábháilte do goroutines Go sonraí a roinnt agus a chomhshioncronú, ag forghníomhú an mhóta "cuimhne a roinnt trí choimirce a dhéanamh."

## Channels a chruthú agus a úsáid

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

Déanann an t-oibreoir `<-` iomadúil ar an dá rud: seolann sé (`ch <- v`) agus glacann sé (`v := <-ch`).

## Channels gan buffering vs le buffering

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

Déanann channels **gan buffering** sincronúchán: fanann seoladh ar fhrithhéad (agus a mhalairt), ina ndéantar uirlisí comhordaithe iad. Dhéanann channels **le buffering** an seoltóir agus an ghlacadóir a dhealú go dtí méid an buffer.

## Channels a dhúnadh agus range a chur i bhfeidhm

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

Siomraíonn dúnadh channel go bhfuil deireadh ann; faigheann `range` thar channel go dtí go ndúntar é. **Ní ba chóir ach don tseoltóir** channel a dhúnadh.

## Deadlock agus panic potholes coitianta

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

Is gnách go mbíonn deadlocks (gach duine gafa) agus panics a bhaineann le dúnadh ina measc na bugs channel coitianta le tuigbheáil.

## Channels treo-dhírithe (do APIs geal)

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

## Cén fáth a bhfuil tábhacht ann

Is iad na channels croílár mhúnla comhthreomhaireachta Go agus an bealach idiomatach do goroutines a choimirt agus a chomhshioncronú — ag cur an phrionsabail bhunúsaigh i bhfeidhm "ná déan teagmháil trí chuimhne a roinnt; roinn cuimhne trí chumarsáid a dhéanamh." Tugann siad deis duit sonraí a roinnt go sábháilte idir goroutines comhthreomhara gan ghlas follasach, píobláin a thógáil, obair a dháileadh, agus críoch a shignáil.

A thuiscint na n-oibríochtaí seoil/fáil, an ní ríthábhachtach **gan buffering (sioncróineach) vs le buffering (dí-chuplailte)** idirdhealú, séimeantaic dhúnta (an seoltóir a dhúnann; range/comma-ok a bhraithim), agus na pothole coitianta (**deadlocks** ó sheoladh/fáil gafa, **panics** ó dhúnadh faoi dhó nó seoladh ar channel dúnta) tá sé ríthábhachtach le haghaidh Go comhthreomhara ceart a scríobh.

Is iad na channels (le goroutines) lár bhunúsacht Go agus i measc na coincheap is tábhachtaí agus is tástála is minice sa teanga.