Channels کیسے کام کرتے ہیں؟

Question

Accepted Answer

ایک **channel** goroutines کے درمیان **مواصلات** کے لیے ایک typed conduit ہے — ایک goroutine values بھیجتا ہے، دوسرا انہیں وصول کرتا ہے۔ 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 ہم آہنگی کرتے ہیں: ایک send، receive کا انتظار کرتا ہے (اور بالعکس)، انہیں ایک ہم آہنگی کا آلہ بناتے ہوئے۔ **Buffered** channels sender اور receiver کو buffer کی سائز تک الگ کرتے ہیں۔

## 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` اسے بند ہونے تک وصول کرتا ہے۔ **صرف sender کو** ایک 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 (سب بند) اور closing سے متعلقہ 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 کے لیے مواصلات اور ہم آہنگی کا اصل طریقہ ہیں — بنیادی فلسفہ نافذ کرتے ہوئے "میموری کو بانٹ کر بات نہ کریں؛ میموری کو بانٹ کر بات کریں۔" وہ آپ کو concurrent goroutines کے درمیان محفوظ طریقے سے ڈیٹا منتقل کرنے دیتے ہیں بغیر واضح locks کے، pipelines بناتے ہیں، کام تقسیم کرتے ہیں، اور مکمل ہونے کا اشارہ دیتے ہیں۔

Send/receive operations، اہم **unbuffered (synchronizing) بمقابلہ buffered (decoupling)** فرق، closing semantics (sender بند کرتا ہے؛ range/comma-ok اسے detect کرتے ہیں)، اور عام خطرات (**deadlocks** blocked sends/receives سے، **panics** دو بار بند کرنے سے یا بند channel پر بھیجنے سے) کو سمجھنا صحیح concurrent Go لکھنے کے لیے ضروری ہے۔

Channels (goroutines کے ساتھ) Go کی شناخت کے مرکز میں ہیں اور زبان میں سب سے اہم اور بار بار ٹیسٹ ہونے والے concepts میں سے ہیں۔