ਚੈਨਲਾਂ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀਆਂ ਹਨ?

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 ਬੰਦ ਕਰਨਾ ਅਤੇ ਰੇਂਜ ਕਰਨਾ

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

Eik 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 ਬੱਗ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਸਮਝਣਾ ਹੈ।

## 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 ਲਈ ਸੰਚਾਰ ਅਤੇ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ ਕਰਨ ਦਾ idiomatically ਤਰੀਕਾ ਹੈ — ਮੂਲ ਦਰਸ਼ਨ ਨੂੰ ਲਾਗੂ ਕਰਦੇ ਹੋਏ "don't communicate by sharing memory; share memory by communicating." ਉਹ ਤੁਹਾਨੂੰ ਸਪੱਸ਼ਟ locks ਤੋਂ ਬਿਨਾਂ concurrent goroutines ਵਿਚਕਾਰ ਸੁਰੱਖਿਤ ਤਰੀਕੇ ਨਾਲ ਡੇਟਾ ਪਾਸ ਕਰਨ, pipelines ਬਣਾਉਣ, ਕੰਮ ਵੰਡਣ, ਅਤੇ ਪੂਰਣਤਾ ਨੂੰ ਸੰਕੇਤ ਕਰਨ ਦਿੰਦੇ ਹਨ।

Send/receive ਓਪਰੇਸ਼ਨਾਂ, ਮਹੱਤਵਪੂਰਨ **unbuffered (synchronizing) ਬਨਾਮ buffered (decoupling)** ਪਾਰਤੋ, ਸਮਝਣਾ ਬੰਦ semantics (ਭੇਜਣ ਵਾਲਾ ਬੰਦ ਕਰਦਾ ਹੈ; range/comma-ok ਇਸਨੂੰ ਖੋਜਦੇ ਹਨ), ਅਤੇ ਆਮ pitfalls (**deadlocks** ਬਲਾਕ ਕੀਤੀ ਜਾ ਰਹੀ sends/receives ਤੋਂ, **panics** ਦੋ ਵਾਰ ਬੰਦ ਕਰਨ ਜਾਂ ਬੰਦ channel 'ਤੇ ਭੇਜਣ ਤੋਂ) ਸਹੀ concurrent Go ਲਿਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

Channels (goroutines ਦੇ ਨਾਲ) Go ਦੀ ਪਹਿਚਾਣ ਵਿਚ ਕੇਂਦਰੀ ਹਨ ਅਤੇ ਭਾਸ਼ਾ ਵਿਚ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਅਤੇ ਸਭ ਤੋਂ ਵੱਧ ਪ੍ਰੀਖਿਆ ਕੀਤੀ ਧਾਰਨਾਵਾਂ ਵਿਚੋਂ ਹਨ।