Kako deluje razporejevalnik izvajanja Go runtime?

Question

Accepted Answer

Go runtime vključuje **razporejevalnik** (scheduler), ki multipleksira številne gorutine na majhno število nitk operacijskega sistema. To **M:N razporejanje** (M gorutin na N nitkami OS) je tisto, kar naredi gorutine tako poceni in Go-jevo sočasnost tako skalabilno. Razumevanje tega pojasni zmogljivost gorutin.

## 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 preslika številne gorutine (G) na niti operacijskega sistema (M) preko logičnih procesorjev (P). Privzeto obstaja en P na jedro procesorja (`GOMAXPROCS`), vsak s čakalno vrsto gorutin, ki so pripravljene za izvajanje.

## Kako dosega poceni, skalabilno sočasnost

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

Ker razporejevalnik upravlja preklapljanjem gorutin v uporabniškem prostoru (ne preklapljanja niti na ravni jedra) in imajo gorutine majhne skladic, lahko izvajate bistveno več gorutin kot niti operacijskega sistema, in to poceni.

## Ključna vedenja razporejevalnika

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

**Kraja dela** (work stealing) ohranja jedra zasedena, **preempcija** preprečuje, da ena gorutina zasede jedro, in kritično je, da ko se gorutina blokira (na kanalu ali sistemskem klicu), razporejevalnik nadaljuje z izvajanjem drugih gorutin namesto da bi zapravil nit.

## GOMAXPROCS

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

## Zakaj gorutine niso brezplačne

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

## Zakaj je to pomembno

Go razporejevalnik je motor za neverjetno poceni in skalabilne gorutine — razumevanje njegovega **M:N modela** (številne gorutine na nekaj nitkami OS preko G-M-P zasnove) pojasni *zakaj* Go lahko izvaja milijone gorutin, ko niti operacijskega sistema dosežejo omejitev nekaj tisoč, in *zakaj* je njegova sočasnost tako učinkovita (preklapljanje v uporabniškem prostoru namesto dragih preklapljanj konteksta OS, pravi paralelizem čez jedra preko GOMAXPROCS).

Pametno ravnanje z blokanjem (parkiranje gorutin, blokiran na kanalih, predaja P pri sistemskih klicih, da niti niso zapravljena), **kraja dela** za uravnoteženje obremenitve in **preempcija** (od različice 1.14) za preprečevanje izgladovanja so tisto, kar naredi Go-jevo sočasnost robustno pod realnimi obremenitvami.

Čeprav redko neposredno medsebojno delujete z razporejevalnikom, ga razumevanje poglobi vašo intuicijo za zmogljivost gorutin, pojasni vedenja (zakaj blokiranje ne zapravlja niti, zakaj lahko sprožite toliko gorutin) in vpliva na odločitve, kot je omejitev sočasnosti.

To je napredna tematika, ki dokazuje resnino globino znanja Go runtime in se ceni pri intervjujih za starejše položaje.