Como funciona o escalonador de tempo de execução do Go?

Question

Accepted Answer

O tempo de execução do Go inclui um **escalonador** que multiplexam muitas goroutines em um pequeno número de threads do SO. Este **escalonamento M:N** (M goroutines em N threads do SO) é o que torna as goroutines tão baratas e a concorrência do Go tão escalável. Entender isso explica o desempenho das goroutines.

## O modelo 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.
```

O tempo de execução mapeia muitas goroutines (G) em threads do SO (M) via processadores lógicos (P). Há um P por núcleo de CPU por padrão (`GOMAXPROCS`), cada um com uma fila de goroutines prontas para executar.

## Como alcança concorrência barata e escalável

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

Porque o escalonador lida com a alternância de goroutines no espaço do usuário (não em trocas de thread no nível do kernel), e as goroutines têm stacks minúsculos, você pode executar vastamente mais goroutines do que threads do SO, de forma barata.

## Comportamentos principais do escalonador

```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** mantém os núcleos ocupados, **preempção** evita que uma goroutine monopolize um núcleo, e crucialmente, quando uma goroutine bloqueia (em um canal ou syscall), o escalonador continua executando outras goroutines em vez de desperdiçar a thread.

## GOMAXPROCS

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

## Por que goroutines não são totalmente gratuitas

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

## Por que isso importa

O escalonador do Go é o motor por trás da notável economia e escalabilidade das goroutines — entender seu **modelo M:N** (muitas goroutines em poucas threads do SO via o design G-M-P) explica *por que* Go pode executar milhões de goroutines quando threads do SO chegam ao máximo em milhares, e *por que* sua concorrência é tão eficiente (alternância no espaço do usuário em vez de custosas trocas de contexto do SO, paralelismo verdadeiro entre núcleos via GOMAXPROCS).

O tratamento inteligente de bloqueios (estacionar goroutines bloqueadas em canais, transferir P em syscalls para que threads não sejam desperdiçadas), **work stealing** para balanceamento de carga, e **preempção** (desde 1.14) para evitar inanição são o que torna a concorrência do Go robusta em cargas de trabalho reais.

Ambora você raramente interaja com o escalonador diretamente, entendê-lo aprofunda sua intuição sobre o desempenho de goroutines, explica comportamentos (por que bloqueios não desperdiçam threads, por que você pode gerar tantas goroutines), e informa decisões como limitar concorrência.

É um tópico avançado que demonstra conhecimento genuíno do tempo de execução do Go e é valorizado em entrevistas para posições sênior.