Jak funguje plánovač Go runtime?

Question

Accepted Answer

Go runtime obsahuje **plánovač** (scheduler), který multiplexuje mnoho goroutin na malý počet OS vláken. Toto **M:N plánování** (M goroutin na N OS vláken) je to, co činí goroutiny tak levné a Go concurrency tak škálovatelný. Pochopení toho vysvětluje výkon goroutin.

## 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 mapuje mnoho goroutin (G) na OS vlákna (M) prostřednictvím logických procesorů (P). Ve výchozím nastavení je jeden P na jádro CPU (`GOMAXPROCS`), každý s frontou goroutin připravených ke spuštění.

## Jak dosahuje levné, škálovatelné concurrency

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

Protože plánovač zpracovává přepínání goroutin v uživatelském prostoru (nikoliv přepínání vláken na úrovni jádra) a goroutiny mají velmi malé stacky, můžete spustit výrazně více goroutin než OS vláken, a to levně.

## Klíčové chování plánovače

```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** udržuje jádra obsazená, **preemption** brání tomu, aby jedna goroutina zavládla jádrem, a zásadně, když se goroutina zablokuje (na kanálu nebo syscall), plánovač udržuje ostatní goroutiny spuštěné místo toho, aby plýtvalo vláknem.

## GOMAXPROCS

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

## Proč goroutiny nejsou zdarma

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

## Proč to má значение

Plánovač Go je motorem za pozoruhodnou levností a škálovatelností goroutin — pochopení jeho **M:N modelu** (mnoho goroutin na málo OS vláken prostřednictvím G-M-P designu) vysvětluje, *proč* Go může spustit miliony goroutin, když OS vlákna dosáhnou maximálně tisíce, a *proč* je jeho concurrency tak efektivní (přepínání v uživatelském prostoru namísto drahých OS context switchů, skutečný paralelismus napříč jádry prostřednictvím GOMAXPROCS).

Chytré zpracování blokování (parkování goroutin blokovaných na kanálu, předání P na syscalls, aby vlákna nebyla plýtvána), **work stealing** pro vyrovnávání zatížení a **preemption** (od verze 1.14) pro zabránění hladovění je to, co činí Go concurrency robustní v reálných úlohách.

Ačkoliv se se plánovačem zřídka přímo interaguje, jeho pochopení prohloubí vaši intuici pro výkon goroutin, vysvětluje chování (proč blokování neplýtvá vlákny, proč můžete spawnout tolik goroutin) a informuje rozhodnutí jako omezení concurrency.

Je to pokročilé téma, které demonstruje skutečnou hloubku znalostí Go runtime a je ceněno v rozhovorech pro senior pozice.