Bagaimana cara kerja scheduler Go runtime?

Question

Accepted Answer

Go runtime mencakup **scheduler** yang menggandakan banyak goroutine ke sejumlah kecil thread OS. **Penjadwalan M:N** ini (M goroutine pada N thread OS) adalah yang membuat goroutine sangat murah dan concurrency Go sangat dapat diskalakan. Memahaminya menjelaskan kinerja goroutine.

## Model G-M-P

```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 memetakan banyak goroutine (G) ke thread OS (M) melalui processor logis (P). Ada satu P per core CPU secara default (`GOMAXPROCS`), masing-masing dengan antrian goroutine yang siap dijalankan.

## Bagaimana cara mencapai concurrency yang murah dan dapat diskalakan

```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
```

Karena scheduler menangani penggantian goroutine di ruang pengguna (bukan penggantian thread tingkat kernel), dan goroutine memiliki stack kecil, Anda dapat menjalankan jauh lebih banyak goroutine daripada thread OS, dengan murah.

## Perilaku scheduler kunci

```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** membuat core tetap sibuk, **preemption** mencegah satu goroutine dari menghabiskan core, dan yang paling penting, ketika goroutine memblokir (pada channel atau syscall), scheduler terus menjalankan goroutine lain daripada membuang thread.

## GOMAXPROCS

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

## Mengapa goroutine tidak gratis, meskipun demikian

```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.
```

## Mengapa ini penting

Scheduler Go adalah mesin di balik kecerapatan dan skalabilitas goroutine yang luar biasa — memahami **model M:N**-nya (banyak goroutine pada beberapa thread OS melalui desain G-M-P) menjelaskan *mengapa* Go dapat menjalankan jutaan goroutine ketika thread OS mencapai batas di ribuan, dan *mengapa* concurrency-nya sangat efisien (penggantian ruang pengguna bukan OS context switch yang mahal, paralelisme sebenarnya di seluruh core melalui GOMAXPROCS).

Penanganan blockage yang cerdas (memarkir goroutine yang diblokir channel, menyerahkan P pada syscall sehingga thread tidak terbuang), **work stealing** untuk penyeimbangan beban, dan **preemption** (sejak 1.14) untuk mencegah kelaparan adalah yang membuat concurrency Go tangguh di bawah beban kerja nyata.

Meskipun Anda jarang berinteraksi langsung dengan scheduler, memahaminya memperdalam intuisi Anda tentang kinerja goroutine, menjelaskan perilaku (mengapa memblokir tidak membuang thread, mengapa Anda dapat menspawn begitu banyak goroutine), dan menginformasikan keputusan seperti pembatasan concurrency.

Ini adalah topik lanjutan yang menunjukkan pengetahuan Go runtime yang benar-benar mendalam dan dihargai dalam wawancara senior.