சேனல்கள் எவ்வாறு செயல்படுகின்றன?

Question

Accepted Answer

**சேனல்** என்பது **கோரআউட்டின்களுக்கு இடையிலான संचार** கற்றை ஒரு வகைப்பட்ட வாயகம் — ஒரு கோரআউட்டின் மதிப்புகளை அனுப்புகிறது, மற்றொன்று அவற்றை பெறுகிறது. சேனல்கள் Go கோரআউட்டின்கள் பாதுகாப்பாக தரவை கடந்து செல்ல மற்றும் ஒரு மணை செய்ய பயன்படுகின்றன, "நினைவை பகிர்வதன் மூலம் தொடர்புக் கொள்ளுங்கள்" என்ற மந்திரத்தை உள்ளடக்குகின்றன.

## சேனல்களை உருவாக்குதல் மற்றும் பயன்படுத்துதல்

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

## பாফர் இல்லாத சேனல்கள் எதிராக பாফர் செய்யப்பட்ட சேனல்கள்

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

**பாபர் இல்லாத** சேனல்கள் ஒரு மணை செய்கின்றன: ஒரு அனுப்பலை ஒரு பெறுவதற்க மேற்கொள்ளப்படுகிறது (மற்றும் நேர்மாறாக), அவற்றை ஒரு ஒருங்கிணைப்பு கருவி செய்கிறது. **பாபர் செய்யப்பட்ட** சேனல்கள் அனுப்புபவர் மற்றும் பெறுபவரை பாபர் அளவு வரை பிரிக்கின்றன.

## சேனல்களை மூடுதல் மற்றும் வரம்பு

```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` அது மூடப்படும் வரை பெறுகிறது. **அனுப்புபவர் மட்டுமே** சேனலை மூட வேண்டும்.

## பொதுவான 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
```

Deadlock (அனைவரும் தடுக்கப்பட்டுள்ளனர்) மற்றும் மூட்டல் தொடர்பான panics சேனல் பிழைகளை புரிந்துகொள்ள பொதுவாக உள்ளன.

## திசை சேனல்கள் (தெளிவான API களுக்கு)

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

## இது ஏன் முக்கியம்

சேனல்கள் Go இன் concurrency மாதிரியின் இதயம் மற்றும் கோரআउட்டின்கள் தொடர்பு கொள்ள மற்றும் ஒரு மணை செய்ய idiomatic வழி — core தத்துவம் செயல்படுத்தல் "நினைவை பகிர்வதன் மூலம் தொடர்பு கொள்ளாதே; நினைவை பகிர்வதன் மூலம் தொடர்பு கொள்ளுங்கள்." அவை explicit locks இல்லாமல் concurrent கோரআउட்டின்களுக்கு இடையில் பாதுகாப்பாக தரவை கடந்து செல்ல உங்களை அனுமதி, pipelines கட்ட, வேலை விநியோகம், மற்றும் முடிவு சமிக்ஞை செய்ய.

அனுப்ப / பெறுவதற்கான செயல்பாடுகளை, முக்கியமான **பாபர் இல்லாத (ஒரு மணை செய்கிறது) எதிராக பாபர் செய்யப்பட்ட (பிரிக்கிறது)** வேறுபாட்டை, மூட்டல் மொழிநூல் (அனுப்புபவர் மூடுகிறது; range/comma-ok கண்டறிய), மற்றும் பொதுவான பிழைகள் (முனைய அனுப்பலை / பெறுவதற்கான தடுக்கப்பட்டுள்ள கள் மூலம் **deadlock**, இரண்டு முறை மூடுவதாலான **panics** அல்லது மூடப்பட்ட சேனலுக்கு அனுப்புவது) புரிந்துகொள்ள சரியான concurrent Go எழுத உத்தியோகம் செய்தல்.

சேனல்கள் (கோரআउட்டின்களுடன்) Go இன் அடையாளம் மற்றும் மொழி மிக முக்கிய மற்றும் அடிக்கடி-சோதிக்கப்பட்ட கருத்து மணைக்கு மைய உள்ளன.