Как работает планировщик среды выполнения Go?

Question

Accepted Answer

Среда выполнения Go включает **планировщик**, который мультиплексирует множество goroutine на небольшое количество потоков ОС. Это **M:N планирование** (M goroutine на N потоков ОС) — то, что делает goroutine такими дешёвыми и параллелизм Go столь масштабируемым. Понимание его механизма объясняет производительность goroutine.

## Модель 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.
```

Среда выполнения отображает множество goroutine (G) на потоки ОС (M) через логические процессоры (P). По умолчанию имеется один P на ядро процессора (`GOMAXPROCS`), каждый с очередью goroutine, готовых к выполнению.

## Как достигается дешёвый, масштабируемый параллелизм

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

Поскольку планировщик обрабатывает переключение goroutine в пользовательском пространстве (а не переключением потоков на уровне ядра), и goroutine имеют крошечные стеки, можно запустить значительно больше goroutine, чем потоков ОС, и при этом дешево.

## Ключевые поведения планировщика

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

**Кража работы** держит ядра занятыми, **вытеснение** предотвращает монополизацию одного ядра одной goroutine, и критически важно — когда goroutine блокируется (на канале или syscall), планировщик продолжает запускать другие goroutine вместо того, чтобы впустую расходовать поток.

## GOMAXPROCS

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

## Почему goroutine не совсем бесплатны

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

## Почему это важно

Планировщик Go — это двигатель, стоящий за замечательной дешевизной и масштабируемостью goroutine. Понимание его **M:N модели** (множество goroutine на несколько потоков ОС через проектирование G-M-P) объясняет, *почему* Go может запустить миллионы goroutine, тогда как потоки ОС исчерпываются на тысячах, и *почему* его параллелизм настолько эффективен (переключение в пользовательском пространстве вместо дорогостоящих переключений контекста ОС, истинный параллелизм на ядрах через GOMAXPROCS).

Умная обработка блокировок (парковка goroutine, заблокированных на канале, передача P при syscall, чтобы потоки не впустую расходовались), **кража работы** для балансировки нагрузки и **вытеснение** (с версии 1.14) для предотвращения голодания — вот то, что делает параллелизм Go надёжным при реальных нагрузках.

Хотя вы редко взаимодействуете с планировщиком напрямую, понимание его углубляет вашу интуицию в отношении производительности goroutine, объясняет поведение (почему блокировка не расходует потоки впустую, почему можно создавать так много goroutine) и влияет на решения вроде ограничения параллелизма.

Это продвинутая тема, демонстрирующая истинную глубину знания среды выполнения Go и высоко ценимая на собеседованиях для senior позиций.