చానెల్‌లు ఎలా పని చేస్తాయి?

Question

Accepted Answer

A **channel** is a typed conduit for **communication between goroutines** — one goroutine sends values, another receives them. Channels are how Go goroutines safely pass data and synchronize, embodying the motto "share memory by communicating."

## చానెల్‌లను సృష్టించడం మరియు ఉపయోగించడం

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

The `<-` operator both sends (`ch <- v`) and receives (`v := <-ch`).

## Unbuffered vs buffered చానెల్‌లు

```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** చానెల్‌లు సమన్వయం చేస్తాయి: ఒక send ఒక receive కోసం ఎదురుచూస్తుంది (మరియు విలోమంగా), వాటిని సమన్వయ సాధనంగా చేస్తుంది. **Buffered** చానెల్‌లు sender మరియు receiver ను buffer size వరకు వేరుచేస్తాయి.

## చానెల్‌లను మూసివేయడం మరియు 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
```

చానెల్‌ను మూసివేయడం పూర్తిని సూచిస్తుంది; చానెల్‌పై `range` అది మూసివేయబడ్డ వరకు స్వీకరిస్తుంది. **కేవలం sender చానెల్‌ను మూసివేయాలి**.

## సాధారణ 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 (అందరూ నిరోధించబడినవారు) మరియు close-సంబంధిత panics సాధారణ చానెల్‌ బగ్‌లు అర్థం చేసుకోవడానికి.

## దిశాత్మక చానెల్‌లు (స్పష్ట APIs కోసం)

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

## ఇది ఎందుకు ముఖ్యమైనది

చానెల్‌లు Go యొక్క సమకాలీకరణ మోడల్ యొక్క హృదయం మరియు goroutines సంభాషణ మరియు సమన్వయం కోసం పూర్వపక్ష మార్గం — ప్రధాన తత్వశాస్త్రం "memory ను పంచుకోవడით సంభాషణ చేయవద్దు; memory ను సంభాషణ చేయడం ద్వారా పంచుకోండి." అవి స్పష్ట లాక్‌లు లేకుండా సమకాలీన goroutines మధ్య డేటాను సురక్షితంగా పాస్ చేయడానికి, pipelines నిర్మించడానికి, పని పంపిణీ చేయడానికి, మరియు సమాప్తిని సూచించడానికి మిమ్మల్ని అనుమతిస్తాయి.

Send/receive operations, క్రూసియల్ **unbuffered (synchronizing) vs buffered (decoupling)** వ్యత్యాసం, closing semantics (sender closes; range/comma-ok detect it) ను అర్థం చేసుకోవడం, మరియు సాధారణ ఆపద్‌లు (**deadlocks** నిరోధించిన sends/receives నుండి, **panics** రెండుసార్లు closing నుండి లేదా closed చానెల్‌పై sending నుండి) సరైన concurrent Go ను వ్రాయడానికి ఆవశ్యకం.

చానెల్‌లు (goroutines తో) Go యొక్క గుర్తింపుకు కేంద్రీయమైనవి మరియు భాషలో అత్యంత ముఖ్యమైన మరియు తరచుగా-పరీక్ష చేయబడిన భావనలలో ఒకటి.