Go Academy · Ders

Pipeline ve Aşama Örüntüleri

Q: “Pipeline ve Aşama Örüntüleri” dersi ücretsiz mi?

Evet — “Pipeline ve Aşama Örüntüleri” 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: “Pipeline ve Aşama Örüntüleri” dersinde ne öğreneceğim?

Çok aşamalı eşzamanlı pipeline'lar oluşturma 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 1. dersidir.

Q: “Pipeline ve Aşama Örüntüleri” 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.

Çok aşamalı eşzamanlı pipeline'lar oluşturma

Pipeline ve Aşama Örüntüleri, CoddyKit'te ücretsiz bir Go Academy dersidir. Bu, 4 dersinin 1. 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.

İşlem hattı nedir?

Eşzamanlı bir işlem hattı, kanallarla birbirine bağlanan bir dizi aşamadır. Her aşama, yukarı akıştan değerleri alır, dönüştürür ve sonuçları aşağı akışa gönderir; böylece aşamalar eşzamanlı çalışabilir.

Basit üç aşamalı işlem hattı

Üret → dönüştür → tüket:

func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() { defer close(out); for _, n := range nums { out <- n } }()
    return out
}
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() { defer close(out); for n := range in { out <- n*n } }()
    return out
}

for v := range square(generate(2, 3, 4)) {
    fmt.Println(v) // 4, 9, 16
}

Aşama deseni

Her aşama, bir girdi kanalı alan ve bir çıktı kanalı döndüren bir işlevdir. Aşamalar sorunsuz biçimde birleştirilebilir ve birbirlerinden bağımsız olarak paralelleştirilebilir.

İşlem hattında fan-out

CPU'ya bağlı çalışmayı paralelleştirmek için bir aşamayı N goroutine'e çatallayın:

func parallelSquare(in <-chan int, n int) <-chan int {
    outs := make([]<-chan int, n)
    for i := 0; i < n; i++ {
        outs[i] = square(in) // all read from same in
    }
    return merge(outs...)
}

Bağlamla iptal

Her aşamaya bir bağlam geçirin. Bağlam iptal edildiğinde aşamalar okumayı durdurur ve çıktı kanallarını kapatır; böylece tüm işlem hattı boşaltılır.

func stage(ctx context.Context, in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for {
            select {
            case v, ok := <-in:
                if !ok { return }
                select {
                case out <- process(v):
                case <-ctx.Done(): return
                }
            case <-ctx.Done(): return
            }
        }
    }()
    return out
}

Geri basınç

Üretici ve tüketicinin hızlarını birbirinden ayırmak için aşamalar arasında arabelleğe alınmış kanallar kullanın. Arabelleğe alma olmadan yavaş bir aşama, tüm işlem hattını duraklatır.

out := make(chan Result, 50) // buffer 50 results

Hata yayılımı

Panik oluşturmak yerine hataları işlem hattı boyunca yaymak için değerleri bir sonuç yapısının içine sarın:

type item struct { val int; err error }

Done kanalı deseni

Daha basit işlem hatlarında bağlama alternatif olarak bir Done kanalı kullanın. Tüm aşamalara durmaları gerektiğini bildirmek için Done kanalını kapatın.

done := make(chan struct{})
defer close(done)

Sıralama garantileri

Her aşama ardışık çalışıyorsa basit bir işlem hattı sırayı korur. Paralelleştirilmiş aşamalar sırayı korumaz — gerekirse sonuçları aşağı akışta yeniden sıralamak için bir dizin alanı kullanın.

WaitGroup ile işlem hattı

Son aşamanın bir kanalı kapatması gerekmez — yalnızca kanal üzerinde range kullanın. Tüm üretici goroutine'ler tamamlandıktan sonra birleştirilmiş kanalı kapatmak için fan-in işleminde WaitGroup kullanın.

Gerçek dünya kullanımları

Yaygın işlem hattı uygulamaları: ETL veri işleme, görüntü yeniden boyutlandırma, günlük ayrıştırma, derleme sistemleri ve akış hâlindeki istek işleyicileridir.

Kısa kontrol

Çok aşamalı bir işlem hattında iptali nasıl yayarsınız?

Özet: İşlem hattı deseni

Temel noktalar:

Aşama: func(in <-chan T) <-chan U — işlem hatları oluşturmak için birleştirin
Bağlam aracılığıyla iptal; arabelleğe alınmış kanallar aracılığıyla geri basınç
Paralellik için bir aşama içinde fan-out kullanın
Hata yayılımı için değerleri bir sonuç yapısının içine sarın

Sıkça Sorulan Sorular