Kanallar nasıl çalışır?

Question

Accepted Answer

Bir **kanal**, **goroutine'ler arasında iletişim** için yazılı bir iletişim yoludur — bir goroutine değerler gönderir, diğeri onları alır. Kanallar, Go goroutine'lerinin verileri güvenli bir şekilde geçmesi ve senkronize olmasının yoludur ve "hafızayı iletişim yoluyla paylaş" mottosu ile hayata geçirilir.

## Kanallar oluşturma ve kullanma

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

`<-` operatörü hem gönderme (`ch <- v`) hem de alma (`v := <-ch`) işlemlerini yapar.

## Tamponlanmamış ve tamponlanmış kanallar

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

**Tamponlanmamış** kanallar senkronizasyon sağlar: bir gönderme bir alma işlemini bekler (ve tersi de geçerlidir), bu da onları koordinasyon aracı haline getirir. **Tamponlanmış** kanallar gönderici ve alıcıyı tampon boyutu kadar ayırır.

## Kanalları kapatma ve döngü oluşturma

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

Bir kanalı kapatmak tamamlanmayı sinyal verir; bir kanalın üzerinde `range` döngüsü kapatılana kadar alır. **Yalnızca gönderici** bir kanalı kapatmalıdır.

## Sık karşılaşılan kilitlenme ve panic tuzakları

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

Kilitlenmeler (herkese engellenmiş) ve kapatılma ile ilgili panikler, anlaşılması gereken yaygın kanal hatalarıdır.

## Yönlü kanallar (net API'ler için)

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

## Neden önemli

Kanallar Go'nun eşzamanlılık modelinin kalbidir ve goroutine'lerin iletişim kurması ve senkronize olmasının idiyomatik yoludur — "hafızayı paylaşarak iletişim kurma; hafızayı iletişim yoluyla paylaş" ana felsefesini uygular. Açık kilitler olmadan eşzamanlı goroutine'ler arasında verileri güvenli bir şekilde geçmenize, boru hatları oluşturmanıza, işleri dağıtmanıza ve tamamlanmayı sinyal vermenize olanak tanır.

Gönderme/alma işlemlerini, **tamponlanmamış (senkronize edici) ile tamponlanmış (ayırıcı)** ayrımını, kapatma semantiğini (gönderici kapatır; `range`/virgül-ok bunu algılar) ve sık karşılaşılan tuzakları (**bloke edilen gönderme/almalardan kaynaklanan kilitlenmeler**, iki kez kapatmaktan veya kapalı bir kanala göndermekten kaynaklanan **panikler**) anlamak, doğru eşzamanlı Go kodu yazması için gereklidir.

Kanallar (goroutine'lerle birlikte) Go'nun kimliğinin merkezinde yer almakta ve dilde en önemli ve sıkça test edilen konseptler arasında yer almaktadır.