Cum funcționează canalele?

Question

Accepted Answer

Un **channel** este un conduit tipizat pentru **comunicare între goroutines** — o goroutine trimite valori, alta le primește. Canalele sunt modul în care goroutines-urile Go trimit date în siguranță și se sincronizează, încarnând deviza "share memory by communicating".

## Crearea și utilizarea canalelor

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

Operatorul `<-` atât trimite (`ch <- v`), cât și primește (`v := <-ch`).

## Canale nememoriate vs memorate

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

Canalele **nememoriate** sincronizează: o trimitere așteaptă o primire (și invers), făcând-le un instrument de coordonare. Canalele **memorate** decuplează expeditorul și receptorul până la dimensiunea buffer-ului.

## Închiderea canalelor și iterație

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

Închiderea unui canal semnalizează finalizare; `range` pe un canal primește până când este închis. **Doar expeditorul ar trebui să închidă** un canal.

## Comune deadlock-uri și capcane 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-urile (toți blocați) și panic-urile legate de închidere sunt erori obișnuite ale canalelor de înțeles.

## Canale direcționale (pentru API-uri clare)

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

## De ce este important

Canalele sunt inima modelului de concurență al Go și modul idiomativ pentru ca goroutines să comunice și să se sincronizeze — implementând filosofia de bază "don't communicate by sharing memory; share memory by communicating". Vă permit să transmiteți date în siguranță între goroutines concurente fără blocări expliciți, să construiți conductele, să distribuiți munca și să semnalizați finalizarea.

Înțelegerea operațiilor de trimitere/primire, distincția crucială **nememoriate (sincronizare) vs memorate (decuplare)**, semantica închiderii (expeditorul închide; range/comma-ok o detectează) și capcane obișnuite (**deadlock-uri** din trimiteri/primiri blocate, **panic-uri** din închidere de două ori sau trimitere pe un canal închis) este esențial pentru scrierea Go concurent corect.

Canalele (cu goroutines) sunt centrale pentru identitatea Go și printre conceptele cele mai importante și frecvent testate din limbaj.