Come funziona lo scheduler del runtime di Go?

Question

Accepted Answer

Il runtime di Go include uno **scheduler** che esegue il multiplexing di molte goroutine su un numero ridotto di thread del sistema operativo. Questo **scheduling M:N** (M goroutine su N thread del sistema operativo) è ciò che rende le goroutine così economiche e la concorrenza di Go così scalabile. Comprenderlo spiega le prestazioni delle goroutine.

## Perché è importante

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

Il runtime mappa molte goroutine (G) su thread del sistema operativo (M) tramite processori logici (P). C'è un P per core della CPU per impostazione predefinita (`GOMAXPROCS`), ognuno con una coda di goroutine pronte all'esecuzione.

## Come raggiunge concorrenza economica e scalabile

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

Poiché lo scheduler gestisce il cambio di goroutine nello spazio utente (non come cambio di thread a livello kernel), e le goroutine hanno stack minuscoli, puoi eseguire molte più goroutine rispetto ai thread del sistema operativo, in modo economico.

## Comportamenti chiave dello scheduler

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

Il **work stealing** mantiene i core occupati, la **preemption** impedisce a una goroutine di monopolizzare un core, e in modo cruciale, quando una goroutine si blocca (su un channel o syscall), lo scheduler continua a eseguire altre goroutine invece di sprecare il thread.

## GOMAXPROCS

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

## Perché le goroutine non sono gratuite, comunque

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

## Perché è importante

Lo scheduler di Go è il motore dietro l'economicità e la scalabilità straordinarie delle goroutine — comprenderne il **modello M:N** (molte goroutine su pochi thread del sistema operativo tramite il design G-M-P) spiega *perché* Go può eseguire milioni di goroutine quando i thread del sistema operativo si fermano a migliaia, e *perché* la sua concorrenza è così efficiente (cambio nello spazio utente invece di costosi context switch del sistema operativo, vero parallelismo tra core tramite GOMAXPROCS).

La gestione intelligente del blocco (parcheggio delle goroutine bloccate su channel, passaggio di P su syscall per non sprecare thread), il **work stealing** per il bilanciamento del carico, e la **preemption** (dalla versione 1.14) per prevenire l'inanizione sono ciò che rende la concorrenza di Go robusta con carichi di lavoro reali.

Alquanto raramente interagisci direttamente con lo scheduler, comprenderne il funzionamento approfondisce la tua intuizione per le prestazioni delle goroutine, spiega i comportamenti (perché il blocco non spreca thread, perché puoi generare così tante goroutine), e informa decisioni come limitare la concorrenza.

È un argomento avanzato che dimostra una genuina profondità di conoscenza del runtime di Go ed è apprezzato negli interview per posizioni senior.