Cum funcționează planificatorul runtime-ului Go?

Question

Accepted Answer

Runtime-ul Go include un **planificator** care mapează multe goroutine-uri pe un număr mic de thread-uri OS. Această **planificare M:N** (M goroutine-uri pe N thread-uri OS) este ceea ce face goroutine-urile atât de ieftine și concurența Go atât de scalabilă. Înțelegerea sa explică performanța goroutine-urilor.

## Modelul 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-ul mapează multe goroutine-uri (G) pe thread-uri OS (M) prin procesoare logice (P). Există un P per nucleu de CPU în mod implicit (`GOMAXPROCS`), fiecare cu o coadă de goroutine-uri gata să ruleze.

## Cum realizează concurență ieftină și scalabilă

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

Deoarece planificatorul gestionează comutarea goroutine-urilor în spațiul utilizator (nu schimbări de thread la nivel de kernel), și goroutine-urile au stive minuscule, puteți rula mult mai multe goroutine-uri decât thread-uri OS, în mod ieftin.

## Comportamente cheie ale planificatorului

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

**Furtul de muncă** ține nucleele ocupate, **preempțiunea** previne ca o goroutine să monopolizeze un nucleu, și în mod crucial, când o goroutine se blochează (pe un canal sau syscall), planificatorul ține alte goroutine-uri în execuție în loc să risipească thread-ul.

## GOMAXPROCS

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

## De ce goroutine-urile nu sunt complet gratuite, totuși

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

## De ce este important

Planificatorul Go este motorul din spatele ieftinelii și scalabilității remarcabile ale goroutine-urilor — înțelegerea modelului său **M:N** (multe goroutine-uri pe puține thread-uri OS prin designul G-M-P) explică *de ce* Go poate rula milioane de goroutine-uri când thread-urile OS se limitează la mii, și *de ce* concurența sa este atât de eficientă (comutare în spațiul utilizator în loc de schimburi de context OS scumpe, paralelism adevărat pe nucleele prin GOMAXPROCS).

Gestionarea inteligentă a blocării (parcare goroutine-uri blocate pe canal, cedarea P în syscall-uri astfel încât thread-urile nu sunt risipite), **furtul de muncă** pentru echilibrarea sarcinii, și **preempțiunea** (din 1.14) pentru a preveni foamea sunt ceea ce face concurența Go robustă sub sarcini reale.

Deși rareori interacționați direct cu planificatorul, înțelegerea sa aprofundează intuiția dumneavoastră pentru performanța goroutine-urilor, explică comportamente (de ce blocarea nu risipește thread-uri, de ce puteți genera atât de multe goroutine-uri), și informează decizii precum limitarea concurenței.

Este un subiect avansat care demonstrează o cunoaștere autentic aprofundată a runtime-ului Go și este apreciată în interviurile pentru poziții senior.