Si funksionojnë kanalat?

Question

Accepted Answer

Një **kanal** është një kanalë i tipizuar për **komunikim ndërmjet goroutine-sh** — një goroutine dërgon vlera, një tjetër i merr. Kanalat janë mënyra se si goroutine-t në Go kalojnë të dhënat me siguri dhe sinkronizohen, përtyparin moto "ndajnë memorien duke komunikuar."

## Përpunimi dhe përdorimi i kanaleve

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

Operatori `<-` edhe dërgon (`ch <- v`) edhe merr (`v := <-ch`).

## Kanalat e pabufuara kundrejt atyre të bufuara

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

**Kanalat e pabufuara** sinkronizojnë: një dërgim pret një marrje (dhe anasjelltas), duke i bërë ato një mjet koordinimi. **Kanalat e bufuara** ndajnë dërguesin dhe marrësin deri në madhësinë e bufferit.

## Mbyllja e kanaleve dhe 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
```

Mbyllja e një kanali sinjalizon përfundimin; `range` mbi një kanal merr derisa të mbyllet. **Vetëm dërguesi duhet të mbyllë** një kanal.

## Deadlock të përbashkët dhe paniku 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
```

Deadlock-et (të gjithë të bllokuar) dhe paniku me radhë të mbylljes janë bug-e të zakonshëm të kanaleve për të kuptuar.

## Kanalat drejtuese (për API-t të qarta)

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

## Pse është e rëndësishme

Kanalat janë zemra e modelit të konkurencës të Go dhe mënyra idiomatike për goroutine-t të komunikojnë dhe sinkronizojnë — duke zbatuar filosofinë thelbësore "mos komunikoni duke ndarë memorien; ndajnë memorien duke komunikuar." Ato ju lejojnë të kaloni të dhënat me siguri ndërmjet goroutine-sh konkurrente pa kyçje eksplicite, ndërtoni tubacione, shpërndajnë punën dhe sinjalizoni përfundimin.

Përngjyra i operacioneve send/receive, dallimi vendimtar **i pabufar (sinkronizim) kundrejt atyre të bufuara (decoupling)**, semantika e mbylljes (dërguesi mbyll; range/comma-ok e zbulojnë), dhe pitfall-et e zakonshëm (**deadlock-et** nga dërgime/marrje të bllokuara, **paniku** nga mbyllja dy herë ose dërgim në një kanal të mbyllur) është thelbësor për të shkruar konkurencë të saktë në Go.

Kanalat (me goroutine-t) janë qendrore për identitetin e Go dhe ndër konceptet më të rëndësishme dhe më të testushme në gjuhë.