Bagaimanakah penjadual masa jalan Go berfungsi?

Question

Accepted Answer

Masa jalan Go termasuk satu **penjadual** (scheduler) yang menggandakan banyak goroutine ke atas sebilangan kecil thread OS. **Penjadualan M:N** ini (M goroutine pada N thread OS) ialah yang menjadikan goroutine begitu murah dan keserentakan Go begitu boleh skala. Memahaminya menjelaskan prestasi 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.
```

Masa jalan memetakan banyak goroutine (G) ke atas thread OS (M) melalui pemproses logik (P). Terdapat satu P bagi setiap teras CPU secara lalai (`GOMAXPROCS`), masing-masing dengan baris gilir goroutine yang sedia untuk dijalankan.

## Bagaimana ia mencapai keserentakan yang murah dan boleh skala

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

Oleh kerana penjadual mengendalikan pertukaran goroutine dalam ruang pengguna (bukan pertukaran thread peringkat kernel), dan goroutine mempunyai stack yang kecil, anda boleh menjalankan jauh lebih banyak goroutine berbanding thread OS, dengan murah.

## Tingkah laku penjadual utama

```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** memastikan teras sentiasa sibuk, **preemption** menghalang satu goroutine daripada menguasai teras, dan yang penting, apabila goroutine tersekat (pada channel atau syscall), penjadual mengekalkan goroutine lain berjalan dan bukannya membazirkan 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 tetap tidak percuma

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

Penjadual Go ialah enjin di sebalik kemurahan dan kebolehskalaan goroutine yang luar biasa — memahami **model M:N**nya (banyak goroutine pada sedikit thread OS melalui reka bentuk G-M-P) menjelaskan *mengapa* Go boleh menjalankan berjuta-juta goroutine sedangkan thread OS mencapai had pada ribuan, dan *mengapa* keserentakannya begitu cekap (pertukaran ruang pengguna dan bukan pertukaran konteks OS yang mahal, keselarian sebenar merentas teras melalui GOMAXPROCS).

Pengendalian pintar terhadap penyekatan (memarkir goroutine yang tersekat pada channel, menyerahkan P pada syscall supaya thread tidak dibazirkan), **work stealing** untuk pengimbangan beban, dan **preemption** (sejak 1.14) untuk mencegah kebuluran ialah yang menjadikan keserentakan Go kukuh di bawah beban kerja sebenar.

Walaupun anda jarang berinteraksi dengan penjadual secara langsung, memahaminya mendalamkan gerak hati anda terhadap prestasi goroutine, menjelaskan tingkah laku (mengapa penyekatan tidak membazirkan thread, mengapa anda boleh menjana begitu banyak goroutine), dan memaklumkan keputusan seperti membataskan keserentakan.

Ia topik lanjutan yang menunjukkan kedalaman pengetahuan masa jalan Go yang sebenar dan dihargai dalam temu duga senior.