📚 课程目录第1章 Goroutine基础

1. Goroutine 基础：Go 并发模型与轻量级原理

Go 语言在诞生之初就将“并发”作为一等公民。与传统的基于操作系统线程的并发模型不同，Go 提供了一种称为 Goroutine 的轻量级执行单元，使得开发者可以轻松创建成千上万个并发任务，而无需担心线程开销和调度复杂性。本节将深入剖析 Goroutine 的本质、它与线程的核心差异，以及其轻量级背后的实现原理。

1.1 Go 并发模型简介

Go 的并发模型基于 CSP（Communicating Sequential Processes，通信顺序进程） 理论，由 Tony Hoare 于 1978 年提出。该模型的核心思想是：不要通过共享内存来通信，而应通过通信来共享内存。Go 通过 Goroutine 和 Channel 完美实现了这一理念。

  核心组件：
  Goroutine：轻量级并发执行单元，由 Go 运行时管理。
Channel：Goroutine 之间的通信管道，用于传递数据和同步。
Select：多路复用机制，用于同时等待多个 Channel 操作。

下图展示了 Go 并发模型的基本架构：多个 Goroutine 通过 Channel 进行通信，而 Go 运行时（Runtime）负责调度这些 Goroutine 到操作系统线程上执行。

1.2 Goroutine 与线程的区别

Goroutine 常被称为“轻量级线程”，但它们在创建成本、调度方式、栈大小等方面存在本质区别。下表从多个维度进行了详细对比：

对比维度	操作系统线程（OS Thread）	Goroutine
创建成本	高：涉及内核态系统调用，分配内核栈（通常 1~8 MB）	极低：用户态创建，初始栈仅 2~4 KB，按需增长
栈大小	固定且较大（通常 1 MB 以上），无法动态调整	初始极小（2~4 KB），可动态伸缩至最大 1 GB
调度方式	由操作系统内核调度，涉及上下文切换（用户态↔内核态）	由 Go 运行时（GMP 模型）在用户态调度，切换成本极低
切换开销	高：约 1~10 μs，涉及寄存器保存、TLB 刷新等	低：约 0.1~1 μs，仅保存少量寄存器（PC、SP 等）
创建数量	有限：通常数千个（受内存和内核限制）	海量：轻松创建数十万甚至数百万个
标识符	有全局唯一 ID（PID/TID）	无全局 ID，由运行时内部管理
通信方式	通常通过共享内存 + 锁（Mutex、Semaphore）	推荐通过 Channel 通信，也支持共享内存 + 锁

关键结论：Goroutine 的创建和切换成本比线程低 2~3 个数量级。这使得在 Go 中，即使创建 10 万个 Goroutine 也不会对系统造成明显压力，而同等数量的线程则可能直接耗尽系统资源。

1.3 Goroutine 的轻量级原理

Goroutine 之所以如此轻量，主要归功于以下三个核心设计：动态栈管理、用户态调度（GMP 模型） 和 协作式抢占。

1.3.1 动态栈管理

传统线程的栈是固定大小的（通常 1~8 MB），无论实际使用多少，都会占用全部内存。Goroutine 则采用 动态栈 技术：

初始栈极小：每个 Goroutine 创建时仅分配 2~4 KB 的栈空间。
按需增长：当栈空间不足时，Go 运行时会通过 stackalloc 分配更大的栈（通常翻倍），并将旧栈内容复制到新栈。
栈收缩：当 Goroutine 长时间闲置且栈使用率低时，运行时会自动收缩栈，释放多余内存。

// 查看 Goroutine 栈大小的示例代码
package main

import (
    "fmt"
    "runtime"
)

func main() {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    fmt.Printf("初始栈大小: %d KB\n", m.StackInuse/1024)

    // 创建大量 Goroutine 观察栈变化
    const n = 100000
    done := make(chan bool, n)
    for i := 0; i < n; i++ {
        go func() {
            // 模拟栈使用
            var buf [1024]byte
            _ = buf
            done <- true
        }()
    }
    for i := 0; i < n; i++ {
        <-done
    }
    runtime.ReadMemStats(&m)
    fmt.Printf("创建 %d 个 Goroutine 后栈总占用: %d MB\n", n, m.StackInuse/1024/1024)
}

1.3.2 GMP 调度模型

Go 运行时实现了著名的 GMP 模型，这是 Goroutine 高效调度的核心：

组件	全称	职责	数量
G	Goroutine	代表一个并发执行的任务，包含栈、PC、SP 等上下文信息	动态创建，可达数百万
M	Machine（OS 线程）	实际执行 Goroutine 的操作系统线程	通常等于 GOMAXPROCS（默认 CPU 核数）
P	Processor（逻辑处理器）	管理本地 Goroutine 运行队列，为 M 提供执行上下文	等于 GOMAXPROCS（可配置）

下图展示了 GMP 模型的完整调度流程：

1.3.3 协作式抢占与调度点

Go 1.14 之前，Goroutine 采用 协作式调度，即 Goroutine 必须主动让出 CPU（如通过 runtime.Gosched()、Channel 操作、系统调用等）。Go 1.14 引入了 基于信号的异步抢占，使得长时间运行的 Goroutine 也能被强制暂停，从而避免“饿死”其他 Goroutine。

注意：虽然 Go 1.14+ 支持异步抢占，但某些场景（如密集循环、无函数调用的纯计算）仍可能导致调度延迟。在实际高并发系统中，建议在关键循环中显式调用 runtime.Gosched() 或插入 time.Sleep(0) 来主动让出 CPU，以提高调度公平性。

1.4 小结

本节从 Go 并发模型出发，详细介绍了 Goroutine 与线程的本质区别，并深入剖析了 Goroutine 轻量级的三大原理：

动态栈管理：初始栈仅 2~4 KB，按需增长和收缩，大幅降低内存占用。
GMP 用户态调度：Go 运行时在用户态完成 Goroutine 的调度，避免了昂贵的系统调用和内核态切换。
协作式抢占：通过调度点和信号机制，确保所有 Goroutine 都能公平获得 CPU 时间。