Go Academy · Ders

Goroutine Başlatma

go anahtar sözcüğü, goroutine yaşam döngüsü ve WaitGroups

1. ders / 412 adım

Goroutine Başlatma, 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.

Goroutine Nedir?

Bir goroutine, Go çalışma zamanı tarafından yönetilen, eşzamanlı olarak yürütülen hafif bir işlevdir. Goroutine'ler işletim sistemi iş parçacıklarından çok daha düşük maliyetlidir; binlercesini çalıştırabilirsiniz:

go anahtar sözcüğüyle başlatılır
Yaklaşık 2 KB'lık başlangıç yığını vardır (dinamik olarak büyür)
İşletim sistemi tarafından değil, Go çalışma zamanı tarafından zamanlanır
Paylaşılan bellek yerine kanallar aracılığıyla iletişim kurar

go Anahtar Sözcüğü

Herhangi bir işlev çağrısının önüne go ekleyerek onu bir goroutine olarak başlatın:

package main
import ("fmt"; "time")

func greet(name string) {
    fmt.Printf("Hello, %s!\n", name)
}

func main() {
    go greet("Alice")   // runs concurrently
    go greet("Bob")     // runs concurrently
    time.Sleep(100 * time.Millisecond) // wait for goroutines
    fmt.Println("done")
}

Goroutine Yaşam Döngüsü

Bir goroutine, go ifadesi yürütüldüğünde başlar ve işlevi döndürdüğünde sona erer. main dönerse tüm goroutine'ler sonlandırılır:

package main
import ("fmt"; "time")

func worker(id int) {
    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(time.Duration(id) * 50 * time.Millisecond)
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    for i := 1; i <= 3; i++ {
        go worker(i)
    }
    time.Sleep(300 * time.Millisecond) // naive wait
}

Koordinasyon için sync.WaitGroup

Goroutine'lerin tamamlanmasını beklemek için sleep yerine sync.WaitGroup kullanın:

package main
import ("fmt"; "sync")

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()  // signal completion
    fmt.Printf("Worker %d working\n", id)
}

func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 5; i++ {
        wg.Add(1)           // register one goroutine
        go worker(i, &wg)
    }
    wg.Wait()               // block until all Done()
    fmt.Println("all workers finished")
}

Anonim Goroutine

Anonim bir işlevi doğrudan goroutine olarak başlatın — satır içi eşzamanlı görevler için kullanışlıdır:

package main
import ("fmt"; "sync")

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 3; i++ {
        i := i  // capture loop variable
        wg.Add(1)
        go func() {
            defer wg.Done()
            fmt.Printf("goroutine %d\n", i)
        }()
    }
    wg.Wait()
}

Döngü Değişkenini Yakalama Tuzakları

Döngü değişkenini yakalamazsanız tüm goroutine'ler aynı (son) değeri görebilir — Go'da klasik bir eşzamanlılık hatası:

package main
import ("fmt"; "sync")

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go func(n int) {  // pass i as argument — safe
            defer wg.Done()
            fmt.Println(n)  // prints 0, 1, 2 in some order
        }(i)
    }
    wg.Wait()
}

Goroutine ve İş Parçacıkları

Goroutine'lerin işletim sistemi iş parçacıklarına tercih edilmesinin nedenleri:

İşletim sistemi iş parçacıklarındaki yaklaşık 1 MB'a karşılık 2 KB başlangıç yığını
Oluşturulmaları milisaniyeler yerine mikrosaniyeler sürer
Go çalışma zamanı, goroutine'leri GOMAXPROCS işletim sistemi iş parçığı üzerinde çoklar
Goroutine geçişleri işbirlikçidir — çekirdek devreye girmez
Zamanlamayı Go yönetir, siz mantığa odaklanırsınız

GOMAXPROCS

runtime.GOMAXPROCS, goroutine'leri paralel olarak çalıştıran işletim sistemi iş parçacığı sayısını denetler (varsayılan olarak CPU sayısıdır):

package main
import ("fmt"; "runtime")

func main() {
    // Default: number of available CPU cores
    fmt.Println("CPUs:", runtime.NumCPU())
    fmt.Println("GOMAXPROCS:", runtime.GOMAXPROCS(0)) // 0 = query without changing

    // Set to 1 for debugging race conditions:
    // runtime.GOMAXPROCS(1)

    fmt.Println("Goroutines:", runtime.NumGoroutine())
}

Goroutine Sızıntıları

Bir goroutine başlatıldığı hâlde hiç sona ermezse goroutine sızıntısı oluşur. Yaygın nedenler: engellenmiş kanal alma işlemi, engellenmiş kilit, iptal işleminin olmaması:

package main
import ("fmt"; "time"; "runtime")

func leaky() {
    ch := make(chan int)  // nobody sends to ch
    go func() {
        v := <-ch  // blocks forever — goroutine leaked!
        fmt.Println(v)
    }()
}

func main() {
    leaky()
    time.Sleep(10 * time.Millisecond)
    fmt.Println("goroutines:", runtime.NumGoroutine()) // > 1
}

Goroutine için En İyi Uygulamalar

Goroutine yönergeleri:

Bir goroutine'in nasıl sona ereceğini her zaman bilin
Eşzamanlama için sleep yerine WaitGroup veya kanallar kullanın
Döngü değişkenlerini kapanış aracılığıyla değil, işlev bağımsız değişkenleri olarak aktarın
Goroutine'leri context ile iptal edin, çalışmaya devam etmelerine izin vermeyin
Yarış algılayıcısını kullanın: go run -race main.go

Kısa Kontrol

Goroutine'lerde döngü değişkenini yakalama hatasını önlemenin doğru yolu nedir?

İnteraktif derste cevapla

Özet: Goroutine Başlatma

Özet:

go fn() ile başlatın — hafif ve düşük maliyetlidir
Beklemek için sync.WaitGroup kullanın: Add(1), defer Done(), Wait()
Döngü değişkenlerini bağımsız değişkenle veya yeniden tanımlayarak yakalayın
Her goroutine'in nasıl sona ereceğini her zaman bilin — sızıntıları önleyin
Veri yarışlarını algılamak için -race bayrağını kullanın

Başlamak ücretsiz

Yapay zeka eğitmeniyle Go öğren — ücretsiz

Tarayıcında gerçek kod yaz ve çalıştır, 7/24 yapay zeka eğitmeninden anında yardım al; web'de ya da uygulamada kaldığın yerden devam et.

Kurslar: 51
Dersler: 203

Ücretsiz öğrenmeye başla Tüm kursu görüntüle

Sıkça Sorulan Sorular

“Goroutine Başlatma” dersi ücretsiz mi?

Evet — “Goroutine Başlatma” 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.

“Goroutine Başlatma” dersinde ne öğreneceğim?

go anahtar sözcüğü, goroutine yaşam döngüsü ve WaitGroups 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.

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.

“Goroutine Başlatma” 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.

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.

Bu kursun tüm dersleri

← Go Academy Sayfasına Dön