Channels कसरी काम गर्छन्?

Question

Accepted Answer

एक **channel** एक टाइप गरिएको conduit हो जसले **goroutines बीचको संचार** को लागि सेवा गर्छ — एक goroutine मानहरु पठाउँछ, अर्को उनीहरु प्राप्त गर्छ। Channels हो Go goroutines को डेटा सुरक्षित रूपमा पास गर्न र सिंक्रोनाइज गर्न को तरिका, "share memory by communicating" को आदर्श वाक्य को मूर्तिमान।

## 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 प्रेषक र प्राप्तकर्ता को buffer साइज सम्म अलग गर्छन्।

## Channels बन्द गर्न र range गर्न

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

```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 (सबै ब्लक गरिएको) र close सम्बन्धित panics सामान्य channel bugs हुन् समझ को लागि।

## Directional channels (स्पष्ट APIs को लागि)

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

## किन यो महत्वपूर्ण छ

Channels Go को concurrency मोडेल को हृदय हो र goroutines को संचार र सिंक्रोनाइज गर्न को idiomatic तरिका हो — मुख्य दर्शन को कार्यान्वयन "don't communicate by sharing memory; share memory by communicating"। तिनीहरु आपलाई डेटा सुरक्षित रूपमा concurrent goroutines बीचमा पास गर्न अनुमति दिन्छन् स्पष्ट locks बिना, pipelines निर्माण गर्न, काम वितरण गर्न, र पूर्णता संकेत गर्न।

सेन्ड/रिसिभ अपरेशनहरु समझ, महत्वपूर्ण **unbuffered (synchronizing) बनाम buffered (decoupling)** भेद, बन्द semantics (प्रेषक बन्द गर्छ; range/comma-ok यो पत्ता लगाउँछ), र सामान्य pitfalls (**deadlocks** ब्लक गरिएको sends/receives बाट, **panics** दुइ पटक बन्द गर्न वा एक बन्द channel मा पठाउनु) सही concurrent Go लेख्न आवश्यक छ।

Channels (goroutines सह) Go को पहिचान को केन्द्रीय र सबैभन्दा महत्वपूर्ण र बारम्बार-परीक्षित अवधारणाहरु भाषा मा छन्।