Channels કેવી રીતે કામ કરે છે?

Question

Accepted Answer

**Channel** એ **goroutines વચ્ચે સંચાર** માટે ટાઇપ કરેલ નળી છે — એક goroutine મૂલ્યો મોકલે છે, બીજો તેમને પ્રાપ્ત કરે છે। Channels એ Go goroutines માટે ડેટા સુરક્ષિત રીતે પાસ કરવા અને સિંક્રોનાઇজ કરવાનો રસ્તો છે, આડપ્રતીક "મેમોરીને સંચાર દ્વારા શેર કરો" ને મૂર્તિમાન કરે છે.

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

`<-` ઓપરેટર બંને મોકલે છે (`ch <- v`) અને પ્રાપ્ત કરે છે (`v := <-ch`).

## Unbuffered વર્સ 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 સિંક્રોનાઇজ કરે છે: એક મોકલવું એક રિસીવ માટે રાહ જુએ છે (અને તેનાથી વિપરીત), તેમને સંકલન સાધન બનાવે છે. **Buffered** channels પ્રેષક અને પ્રાપ્તકર્તાને બફર સાઇજ સુધી અલગ કરે છે.

## Channels બંધ કરવું અને ranging

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

Channel બંધ કરવું પૂર્ણતાને સંકેત આપે છે; channel પર `range` તે બંધ ન થાય ત્યાં સુધી પ્રાપ્ત કરે છે. **માત્ર પ્રેષક જ** channel બંધ કરવો જોઈએ.

## સામાન્ય deadlock અને panic મુશ્કેલીઓ

```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 (બધા અટકેલા) અને બંધ સંબંધિત panics સમજવાયોગ્ય channel બગ્સ છે.

## દિશાત્મક channels (સ્પષ્ટ APIs માટે)

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

## તે શા માટે મહત્વપૂર્ણ છે

Channels Go ના સમવર્તી મોડેલનું હૃદય છે અને goroutines માટે સંચાર અને સિંક્રોનાઇજ કરવાનો રૂઢિગત તરીકો છે — મૂળ સિદ્ધાંત "મેમોરી શેર કરીને સંચાર કરશો નહીં; સંચાર દ્વારા મેમોરી શેર કરો" અમલમાં આણે છે. તેઓ તમને એક્સપ્લિસિટ લૉક વિના સમવર્તી goroutines વચ્ચે ડેટા સુરક્ષિત રીતે પાસ કરવા દે છે, પાઇપલાઇન બનાવો, કામ વહેંચો અને પૂર્ણતાને સંકેત આપો.

પ્રેષણ/રિસીવ કામગીરી, નિર્ણાયક **unbuffered (સમવર્તી) વર્સ buffered (અલગ કરવું)** તફાવત, બંધ કરવાનું અર્થશાસ્ત્ર (પ્રેષક બંધ કરે છે; range/comma-ok તેને શોધે છે), અને સામાન્ય મુશ્કેલીઓ (**deadlocks** અટકેલા મોકલવું/રિસીવથી, **panics** બે વાર બંધ કરવા અથવા બંધ channel પર મોકલવાથી) સમજવું યોગ્ય સમવર્તી Go લખવા માટે આવશ્યક છે.

Channels (goroutines સાથે) Go ની ઓળખનું કેન્દ્રબિંદુ છે અને ભાષામાં સૌથી મહત્વપૂર્ણ અને વારંવાર પરીક્ષણ કરવામાં આવતા ખ્યાલોમાં છે.