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 की पहचान के लिए केंद्रीय हैं और भाषा में सबसे महत्वपूर्ण और अक्सर परीक्षित अवधारणाओं में से एक हैं।