Go runtime scheduler nasıl çalışır?

Question

Accepted Answer

Go runtime, birçok goroutine'i küçük sayıda OS thread'ine multipleks eden bir **scheduler** içerir. Bu **M:N scheduling** (M goroutine'in N OS thread'inde çalışması) goroutine'leri bu kadar ucuz ve Go'nun concurrency'sini bu kadar ölçeklenebilir yapan şeydir. Bunu anlamak goroutine performansını açıklar.

## G-M-P modeli

```text
G (Goroutine) — your concurrent task (lightweight, ~2KB stack to start)
M (Machine)   — an OS thread (the actual thread the OS schedules)
P (Processor) — a logical processor / scheduling context; holds a queue of runnable Gs
                (the number of P's = GOMAXPROCS, default = number of CPU cores)

The scheduler runs G's on M's, coordinated through P's:
  Each P has a local run queue of goroutines; an M must hold a P to run G's.
```

Runtime, birçok goroutine'i (G) logical processor'lar (P) aracılığıyla OS thread'lerine (M) eşler. Varsayılan olarak her CPU çekirdeği için bir P vardır (`GOMAXPROCS`), her biri çalışmaya hazır goroutine'lerin kuyruğuna sahiptir.

## Ucuz, ölçeklenebilir concurrency'yi nasıl başarır

```text
✓ Creating a goroutine is cheap (tiny stack, runtime-managed) → millions feasible
✓ Switching goroutines happens in USER space (runtime), not via expensive OS
  context switches → far lighter than switching OS threads
✓ With P = CPU cores, Go runs goroutines truly in parallel across cores
```

Scheduler goroutine değiştirmesini user space'de (kernel-level thread switch değil) gerçekleştirdiği ve goroutine'lerin küçük stack'e sahip olduğu için, OS thread'lerine kıyasla çok daha fazla goroutine'yi, ucuz bir şekilde çalıştırabilirsiniz.

## Temel scheduler davranışları

```text
✓ Work stealing — an idle P STEALS goroutines from a busy P's queue → load balancing
✓ Cooperative + preemptive — goroutines yield at function calls/channel ops/blocking;
  since Go 1.14, the scheduler can also PREEMPT long-running goroutines (no starvation)
✓ Blocking handled smartly:
   - A goroutine blocked on a CHANNEL/sync → parked, the M runs other goroutines (no thread wasted)
   - A goroutine blocked on a SYSCALL (e.g. file I/O) → the M blocks, but the P is
     handed to ANOTHER M so other goroutines keep running
```

**Work stealing** çekirdekleri meşgul tutar, **preemption** bir goroutine'in bir çekirdeği tekeline almasını engeller ve çok önemlisi, bir goroutine bloke olduğunda (channel veya syscall'da), scheduler diğer goroutine'leri çalıştırmaya devam eder ve thread'i boşa harcamaz.

## GOMAXPROCS

```go
runtime.GOMAXPROCS(4)    // limit to 4 OS threads running Go code simultaneously
// default = number of CPU cores; rarely needs changing
```

## Goroutine'ler neden tamamen ücretsiz değil

```text
Goroutines are cheap but not zero-cost — millions still use memory, and excessive
goroutines add scheduling overhead. Bound concurrency (worker pools) for heavy loads.
```

## Neden önemli

Go scheduler, goroutine'lerin olağanüstü ucuzluğu ve ölçeklenebilirliğinin motoru olup, **M:N modelini** (G-M-P tasarımı aracılığıyla az sayıda OS thread'inde birçok goroutine) anlamak, Go'nun OS thread'lerinin binlerle sınırlandığı durumda milyonlarca goroutine'i çalıştırabileceğini ve concurrency'sinin neden bu kadar verimli olduğunu (pahalı OS bağlam anahtarları yerine user-space switching, GOMAXPROCS aracılığıyla çekirdekler arasında gerçek paralellik) açıklar.

Bloke olma işleminin akıllı kullanımı (channel'da bloke olan goroutine'leri parking etmek, syscall'da P'yi devralmak böylece thread'ler boşa harcanmaz), yük dengeleme için **work stealing** ve starvation'ı önlemek için **preemption** (1.14'ten beri) Go'nun concurrency'sini gerçek workload'lar altında sağlam yapan şeylerdir.

Scheduler'i nadiren doğrudan kullanır olsanız da, onu anlamak goroutine performansı için sezgilerinizi derinleştirir, davranışları açıklar (neden bloke olmak thread'leri boşa harcamaz, neden bu kadar çok goroutine oluşturabilirsiniz) ve concurrency sınırlandırması gibi kararları bilgilendirir.

Go runtime bilgisinin gerçek derinliğini gösteren ve senior mülakatlar tarafından değerlendirilen gelişmiş bir konudur.