Go Academy · Ders

Tamponsuz Kanallar

Q: “Tamponsuz Kanallar” dersi ücretsiz mi?

Evet — “Tamponsuz Kanallar” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Go Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Go Academy kursu toplamda 4 dersten oluşur.

Q: “Tamponsuz Kanallar” dersinde ne öğreneceğim?

Goroutine'ler arasında eşzamanlı aktarım Go Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Q: Go Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Go Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

Q: “Tamponsuz Kanallar” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Q: Bu Go Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Go Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Goroutine'ler arasında eşzamanlı aktarım

Tamponsuz Kanallar, CoddyKit'te ücretsiz bir Go Academy dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Go Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Go Academy kursu toplamda 4 dersten oluşur.

Kanal Nedir?

Bir kanal, goroutine'ler arasında iletişim kurmak için kullanılan türü belirlenmiş bir taşıyıcıdır. Kanallar, Go'nun şu ilkesini izler: Paylaşılan belleği kullanarak iletişim kurmayın; iletişim kurarak belleği paylaşın.

package main
import "fmt"

func main() {
    ch := make(chan int)   // unbuffered int channel

    go func() {
        ch <- 42  // send: blocks until someone receives
    }()

    v := <-ch  // receive: blocks until someone sends
    fmt.Println(v) // 42
}

Arabelleklenmemiş Kanal Anlam Bilgisi

Arabelleklenmemiş bir kanalın kapasitesi yoktur. Bir gönderim, alıcı hazır olana kadar engellenir; alma işlemi de gönderici gönderim yapana kadar engellenir. Bu, garantili bir eşzamanlı aktarım sağlar:

package main
import "fmt"

func double(in <-chan int, out chan<- int) {
    for v := range in {
        out <- v * 2
    }
    close(out)
}

func main() {
    in := make(chan int)
    out := make(chan int)
    go double(in, out)
    go func() { in <- 3; in <- 5; close(in) }()
    for v := range out { fmt.Println(v) }
    // 6
    // 10
}

Eşzamanlama Aracı Olarak Kanal

Arabelleklenmemiş kanallar goroutine'leri eşzamanlar — işi tamamlandığında sinyal vermek için kullanın:

package main
import "fmt"

func compute(result chan<- int) {
    sum := 0
    for i := 1; i <= 100; i++ { sum += i }
    result <- sum
}

func main() {
    ch := make(chan int)
    go compute(ch)
    fmt.Println("Result:", <-ch) // blocks until compute sends
}

Kanalı Kapatma

Gönderici, başka değer gönderilmeyeceğini bildirmek için kanalı close(ch) ile kapatır. Alıcılar kapanmayı iki değerli biçim aracılığıyla algılar:

package main
import "fmt"

func generate(ch chan<- int, max int) {
    for i := 0; i < max; i++ {
        ch <- i
    }
    close(ch)  // signal done
}

func main() {
    ch := make(chan int)
    go generate(ch, 5)

    for v := range ch {  // range detects close automatically
        fmt.Println(v)
    }
    fmt.Println("channel closed")
}

İki Değerli Alma

İki değerli alma işlemi olan v, ok := <-ch, kanalın hâlâ açık olup olmadığını bildirir:

package main
import "fmt"

func main() {
    ch := make(chan string, 1)
    ch <- "hello"
    close(ch)

    v1, ok1 := <-ch
    fmt.Println(v1, ok1)  // hello true

    v2, ok2 := <-ch
    fmt.Println(v2, ok2)  // "" false — channel closed
}

Kapalı Kanala Gönderim Panik Oluşturur

Kapalı bir kanala gönderim yapmak paniğe neden olur. Bir kanalı yalnızca gönderici kapatmalıdır — alıcı asla kapatmamalıdır:

package main
import "fmt"

func main() {
    ch := make(chan int)
    close(ch)

    // Receiving from closed channel returns zero value
    v, ok := <-ch
    fmt.Println(v, ok)  // 0 false

    // Sending to closed channel panics:
    defer func() { recover() }()
    ch <- 1  // panic: send on closed channel
}

Yönlü Kanallar

Açıklık ve güvenlik için işlev imzalarında kanalları yalnızca gönderme (chan<- T) veya yalnızca alma (<-chan T) yönüyle sınırlandırın:

package main
import "fmt"

func producer(out chan<- int) {  // send-only
    for i := 0; i < 3; i++ { out <- i }
    close(out)
}

func consumer(in <-chan int) {   // receive-only
    for v := range in { fmt.Println(v) }
}

func main() {
    ch := make(chan int)
    go producer(ch)
    consumer(ch)
}

Goroutine ve Kanal Arasında Ping Pong

Kanallar aracılığıyla bir mesajı karşılıklı olarak aktaran iki goroutine — klasik bir eşzamanlama örneği:

package main
import "fmt"

func ping(ping, pong chan struct{}) {
    for i := 0; i < 3; i++ {
        <-ping
        fmt.Println("ping")
        pong <- struct{}{}
    }
}

func main() {
    ping := make(chan struct{})
    pong := make(chan struct{})
    go func() { for { <-pong; fmt.Println("pong"); ping <- struct{}{} } }()
    go func() { for i := 0; i < 3; i++ { ping <- struct{}{}; <-pong } }()
    // Simplified version:
    fmt.Println("channels enable structured communication")
}

nil Kanallar Sonsuza Dek Engeller

nil bir kanaldan alma veya bu kanala gönderme işlemi sonsuza dek engellenir. Bu, select ifadelerinde bazen kasıtlı olarak kullanılır:

package main
import "fmt"

func main() {
    var ch chan int  // nil channel
    fmt.Println(ch == nil) // true

    // select with nil channel — that case is never selected
    active := make(chan int, 1)
    active <- 42
    select {
    case v := <-ch:      // never selected (nil)
        fmt.Println(v)
    case v := <-active:  // selected
        fmt.Println("got:", v)
    }
}

Arabelleklenmemiş Kanallar Ne Zaman Kullanılmalı

Arabelleklenmemiş kanalları şu durumlarda kullanın:

Garantili eşzamanlı aktarım gerektiğinde
Gönderici devam etmeden önce goroutine'in alımı onaylaması gerektiğinde
Semafor veya geri basınç uygularken
Her aşamanın aynı anda bir öğe işlemesi gereken işlem hatlarında

Kısa Kontrol

Alıcının hazır olmadığı arabelleklenmemiş bir kanala gönderim yaptığınızda ne olur?

Özet: Arabelleklenmemiş Kanallar

Özet:

make(chan T) ile oluşturulur — kapasite sıfırdır
Gönderim, alıcı hazır olana kadar; alma işlemi, gönderici gönderim yapana kadar engellenir
Bir kanalı yalnızca gönderici kapatmalıdır
range ch, kanal kapanana kadar yineleme yapar
İki değerli alma: v, ok := <-ch
Açıklık için yönlü türleri kullanın: chan<- ve <-chan

Sıkça Sorulan Sorular