Go 运行时调度器如何工作的？

Question

Go 运行时调度器如何工作的？

Accepted Answer

Go 运行时包含一个**调度器**，它将许多 goroutine 多路复用到少量的 OS 线程上。这种 **M:N 调度**（M 个 goroutine 在 N 个 OS 线程上）正是使 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.
```

运行时通过逻辑处理器（P）将许多 goroutine（G）映射到 OS 线程（M）。默认情况下每个 CPU 核心有一个 P（`GOMAXPROCS`），每个 P 都有一个准备运行的 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 的堆栈很小，所以你可以廉价地运行比 OS 线程多得多的 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 阻塞（在通道或系统调用上）时，调度器会继续运行其他 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 模型**（通过 G-M-P 设计在少量 OS 线程上运行许多 goroutine）解释了*为什么* Go 可以运行数百万个 goroutine 而 OS 线程仅限于数千个，以及*为什么*它的并发如此高效（用户空间切换而不是昂贵的 OS 上下文切换，通过 GOMAXPROCS 跨核心的真正并行性）。

对阻塞的智能处理（暂停被通道阻塞的 goroutine、在系统调用上转移 P 以避免浪费线程）、用于负载均衡的**工作窃取**以及**抢占**（自 1.14 起）以防止饥饿，都是使 Go 并发在实际工作负载中健壮的原因。

虽然你很少直接与调度器交互，但理解它可以深化你对 goroutine 性能的直觉，解释行为（为什么阻塞不会浪费线程、为什么你可以生成这么多 goroutine），并为诸如限制并发等决策提供信息。

这是一个高级主题，展示了对 Go 运行时知识的真正深度，在高级面试中备受重视。