Piye carane Go runtime scheduler gawe?

Question

Accepted Answer

Go runtime kalebu **scheduler** sing nggabungake akeh goroutine menyang nomer cilik saka OS thread. Iki **M:N scheduling** (M goroutine ing N OS thread) sing nggawakake goroutine murah lan concurrency Go bisa diskalakake. Ngerti iki nerangake performa 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 petakan akeh goroutine (G) menyang OS thread (M) liwat logical processor (P). Ana P saben CPU core kanthi default (`GOMAXPROCS`), saben-sabenE duwe antrian goroutine sing siap kanggo dukung.

## Cara gawe concurrency murah lan bisa diskalakake

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

Amarga scheduler nangani goroutine switching ing user space (ora level kernel thread switch), lan goroutine duwe stack cilik, sampeyan bisa dukung akeh goroutine tinimbang OS thread, kanthi murah.

## Tingkah laku 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** ndadekake core sibuk, **preemption** nyegah siji goroutine saka nyiksa core, lan penting, nalika goroutine bloc (ing channel utawa syscall), scheduler tetep dukung goroutine liyane tinimbang buang thread.

## GOMAXPROCS

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

## Apa endi goroutine ora gratis, dene

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

## Apa endi sing penting

Go scheduler minangka mesin ing mburi goroutine remarkable murah lan scalability — ngerti **M:N model** (akeh goroutine ing sithik OS thread liwat design G-M-P) nerangake *apa endi* Go bisa dukung jutaan goroutine nalika OS thread beda ing sisan, lan *apa endi* concurrency murah (user-space switching tinimbang costly OS context switch, parallelism asli across core liwat GOMAXPROCS).

Penanganan cerdas blocking (parkir goroutine channel-bloc, serah P ing syscall supaya thread ora buang), **work stealing** kanggo load balancing, lan **preemption** (wiwit 1.14) kanggo cegah starvation iku apa nggawakake concurrency Go kuat ing workload asli.

Menapa jarang sesarengan langsung karo scheduler, ngerti iku nebus intuisi mudhun kanggo performa goroutine, nerangake tingkah laku (apa endi blocking ora buang thread, apa endi sampeyan bisa dukung goroutine akeh), lan ngandhani keputusan kayata ngebat concurrency.

Iku topik advanced sing nuduhake pangerten asli Go runtime lan dihargai ing interview senior.