Goroutine'ler nedir?

Question

Accepted Answer

Bir **goroutine**, Go runtime tarafından yönetilen hafif, eşzamanlı olarak çalışan bir fonksiyondur. Başlatmak basittir — bir fonksiyon çağrısının önüne `go` koymanız yeterlidir. Goroutine'ler Go'nun imza eşzamanlılık özelliğidir — OS thread'lerinden çok daha ucuzdur, bu nedenle binlerce veya milyonlarca goroutine çalıştırabilirsiniz.

## Goroutine başlatma

```go
func sayHello() {
    fmt.Println("Hello from a goroutine")
}

go sayHello()        // launch concurrently — main does NOT wait for it
go func() {           // or an anonymous function
    fmt.Println("inline goroutine")
}()
```

`go` anahtar sözcüğü, fonksiyonu yeni bir goroutine üzerinde başlatır ve hemen döner — çağıran kod beklemeye gerek kalmadan devam eder.

## Goroutine'lerin özel olması: ucuzdurlar

```text
OS thread:  ~1–2 MB of memory each → thousands max
Goroutine:  ~2 KB initial stack (grows as needed) → MILLIONS feasible
The Go runtime SCHEDULES many goroutines onto a small pool of OS threads (M:N).
```

Goroutine'ler OS thread'leri değildir — Go scheduler'ı birçok goroutine'i birkaç OS thread'inin üzerine çoklama yapar. Bu onları olağanüstü derecede ucuz kılar ve muazzam eşzamanlılığı mümkün kılar (örneğin milyonlarca bağlantı işleyen bir sunucuda her bağlantı için bir goroutine).

## Senkronizasyon sorunu: main çok erken çıkabilir

```go
func main() {
    go sayHello()    // ❌ main might EXIT before this goroutine runs → nothing printed
    // program ends immediately
}
```

`main` döndüğünde, program sona erer — hala çalışan goroutine'leri öldürür. Koordinasyona ihtiyacınız vardır.

## sync.WaitGroup ile bekleme

```go
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
    wg.Add(1)                    // increment the counter
    go func(n int) {
        defer wg.Done()          // decrement when this goroutine finishes
        fmt.Println("worker", n)
    }(i)                          // pass i as an argument (avoid the loop-var capture bug)
}
wg.Wait()                         // BLOCK until all goroutines call Done()
```

`sync.WaitGroup`, bir dizi goroutine'in tamamlanmasını beklemenin standart yoludur.

## Kanallar ile iletişim

```go
ch := make(chan string)
go func() { ch <- "result" }()   // send a result on the channel
msg := <-ch                       // receive (blocks until a value arrives)
```

Go felsefesi: **"Belleği paylaşarak iletişim kurmayın; iletişim kurarak belleği paylaşın"** — paylaşılan değişkenler + kilitler yerine goroutine'ler arasında veri geçirmek için kanalları kullanın.

## Neden önemli

Goroutine'ler Go'nun tanımlayıcı özelliğidir ve eşzamanlı, ağlı sistemlerde mükemmel performans göstermesinin ana nedenidir.

Bunların aşırı hafifliği (thread'ler için megabayt karşısında kilobayt, OS thread'lerine M:N şekilde planlanmış) muazzam eşzamanlılığı pratik ve kolay kılar — bir sunucu, OS thread'leriyle zor veya imkansız olan kaynak kaygıları olmadan her istek veya bağlantı için bir goroutine başlatabilir.

Bunları nasıl başlatacağınızı (`go`), **senkronizasyon**ın kritik önemini (main çıkmak goroutine'leri öldürür; beklemek için `WaitGroup` kullanın) ve Go'nun paylaşılan bellekten ziyade **kanallar aracılığıyla iletişim** tercihini anlamak, doğru eşzamanlı Go yazması için temeldir.

Goroutine'ler (ve etraflarındaki desenler) Go'nun değer önerisinin merkezini oluşturur ve dilde en önemli ve en sık test edilen konuların arasındadır.