Go 语言从入门到进阶 | 第 8 章：并发编程——Goroutine 与 Channel

系列：Go 语言从入门到进阶
作者：耿雨飞
适用版本：go v1.26.2

前置条件

在开始本章学习之前，请确保：

• 已完成前七章的学习，掌握函数、接口和泛型基础
• 理解函数作为一等公民的概念（闭包、函数类型）
• 已获取 Go 1.26.2 源码树（go-go1.26.2目录）

导读

并发是 Go 语言最核心的设计哲学之一。Go 的并发模型基于 CSP（Communicating Sequential Processes，通信顺序进程）理论——不要通过共享内存来通信，而要通过通信来共享内存。这一理念贯穿了 Go 语言的设计，从轻量级的 goroutine 到类型安全的 channel，形成了一套简洁而强大的并发编程体系。

本章将从go关键字的使用出发，深入分析 goroutine 的创建与调度机制，然后系统讲解 channel 的各种用法和底层实现，最后通过select多路复用和常见并发模式，帮助你掌握 Go 并发编程的核心技能。

本章将对照 Go 1.26.2 源码中的以下关键路径：

学习目标

学完本章后，你应当能够：

1. 使用go关键字启动 goroutine，理解其轻量级特性
2. 理解 GMP 调度模型的基本原理，能对照src/runtime/proc.go找到关键函数
3. 正确使用无缓冲和有缓冲 channel 进行 goroutine 间通信
4. 掌握 channel 的发送、接收、关闭操作及其行为规则
5. 理解hchan结构体的核心字段和环形缓冲区设计
6. 使用select实现多路复用和超时控制
7. 运用生产者-消费者、Fan-in/Fan-out、Pipeline、Worker Pool 等常见并发模式

8.1 Goroutine 基础

8.1.1 go 关键字启动 goroutine

在 Go 中，启动一个并发执行单元极其简单——只需在函数调用前加上go关键字：

packagemainimport("fmt""time")funcsayHello(namestring){fmt.Printf("Hello, %s!\n",name)}funcmain(){gosayHello("World")// 启动一个新的 goroutinegosayHello("Go")// 再启动一个gofunc(){// 匿名函数也可以fmt.Println("Anonymous goroutine")}()time.Sleep(100*time.Millisecond)// 等待 goroutine 执行}

几个关键点：

• go后面跟的必须是函数调用（普通函数、方法、匿名函数均可）
• go语句本身不阻塞——它立即返回，新的 goroutine 在后台并发执行
• main函数本身也运行在一个 goroutine 中（称为main goroutine）
• 当 main goroutine 退出时，程序立即终止，不会等待其他 goroutine 完成

注意：上面使用time.Sleep等待 goroutine 只是演示用途。实际代码中应使用sync.WaitGroup（第 9 章）或 channel 来同步。

8.1.2 Goroutine 的轻量级特性

Goroutine 不是操作系统线程，而是 Go 运行时管理的用户态轻量级线程。与 OS 线程相比，goroutine 有三个显著优势：

1. 极小的初始栈

每个 goroutine 的初始栈仅2 KB（src/runtime/stack.go:78）：

// src/runtime/stack.go:78stackMin=2048

而 OS 线程的默认栈通常为 1-8 MB。这意味着同样的内存，Go 可以创建比 OS 线程多数百倍的 goroutine。

2. 动态栈增长

Goroutine 的栈不是固定大小的，而是按需增长。当栈空间不足时，运行时会自动分配更大的栈并迁移数据。Go 1.4+ 采用连续栈（contiguous stack）策略——分配一个两倍大的新栈，将旧栈内容复制过来，然后释放旧栈。

3. 极低的创建和切换开销

创建一个 goroutine 只需分配一个小的g结构体加上初始栈内存，而 goroutine 切换只需保存和恢复少量寄存器（gobuf结构体），不涉及内核态切换。

让我们验证一下 goroutine 的轻量级特性：

packagemainimport("fmt""runtime""sync")funcmain(){varwg sync.WaitGroup n:=100_000// 启动 10 万个 goroutinevarmemBefore runtime.MemStats runtime.ReadMemStats(&memBefore)fori:=0;i<n;i++{wg.Add(1)gofunc(){deferwg.Done()select{}// 永久阻塞，保持 goroutine 存活}()}varmemAfter runtime.MemStats runtime.ReadMemStats(&memAfter)fmt.Printf("启动 goroutine 数量: %d\n",n)fmt.Printf("内存增长: %.2f MB\n",float64(memAfter.Sys-memBefore.Sys)/(1024*1024))fmt.Printf("每个 goroutine 约占: %.2f KB\n",float64(memAfter.Sys-memBefore.Sys)/float64(n)/1024)fmt.Printf("当前 goroutine 总数: %d\n",runtime.NumGoroutine())}

实际运行会发现，10 万个 goroutine 仅消耗几百 MB 内存——这在 OS 线程模型中几乎不可能实现。

8.1.3 go 关键字的运行时实现

编译器会将go f(args)语句转换为对runtime.newproc的调用。让我们看看这个函数（src/runtime/proc.go:5295-5308）：

// src/runtime/proc.go:5295-5308// Create a new g running fn.// Put it on the queue of g's waiting to run.// The compiler turns a go statement into a call to this.funcnewproc(fn*funcval){gp:=getg()pc:=sys.GetCallerPC()systemstack(func(){newg:=newproc1(fn,gp,pc,false,waitReasonZero)pp:=getg().m.p.ptr()runqput(pp,newg,true)ifmainStarted{wakep()}})}

这段代码揭示了go语句的完整执行过程：

1. newproc1（src/runtime/proc.go:5313）：创建新的g结构体
   • 优先从 P 的空闲列表gFree中复用已结束的 goroutine
   • 若没有空闲的，调用malg(stackMin)分配一个新的，初始栈 2048 字节
   • 设置新 goroutine 的初始状态（PC、SP 等）
2. runqput（src/runtime/proc.go:7478）：将新 goroutine 放入当前 P 的本地运行队列
   • 优先放入runnext字段（下一个执行的 goroutine）
   • 本地队列满时，将一半转移到全局运行队列（runqputslow）
3. wakep：如果有空闲的 P，尝试唤醒或创建一个 M 来执行

8.1.4 GMP 调度模型概览

Go 的调度器采用GMP 模型，这是理解 goroutine 运行机制的关键。src/runtime/proc.go文件开头的注释（第 24-34 行）清晰地定义了三个核心概念：

// src/runtime/proc.go:24-34 // Goroutine scheduler // The scheduler's job is to distribute ready-to-run goroutines over worker threads. // // The main concepts are: // G - goroutine. // M - worker thread, or machine. // P - processor, a resource that is required to execute Go code. // M must have an associated P to execute Go code, however it can be // blocked or in a syscall w/o an associated P.

G（Goroutine）

g结构体定义在src/runtime/runtime2.go:473，是 goroutine 的运行时表示：

// src/runtime/runtime2.go:473（简化）typegstruct{stack stack// 栈内存范围 [stack.lo, stack.hi)stackguard0uintptr// 栈增长检测哨兵_panic*_panic// 最内层的 panic_defer*_defer// 最内层的 deferm*m// 当前关联的 Msched gobuf// 调度上下文（SP, PC, BP 等）atomicstatus atomic.Uint32// goroutine 状态goiduint64// goroutine IDstartpcuintptr// go 语句中函数的 PCparentGoiduint64// 创建此 goroutine 的父 goroutine IDwaiting*sudog// 等待中的 sudog 列表// ...}

Goroutine 的状态机定义在src/runtime/runtime2.go:17-80：

M（Machine / OS Thread）

m结构体定义在src/runtime/runtime2.go:618，代表一个操作系统线程：

// src/runtime/runtime2.go:618（简化）typemstruct{g0*g// 调度栈——每个 M 有一个专用的 g0curg*g// 当前正在运行的用户 goroutinep puintptr// 当前关联的 P（执行 Go 代码必须有 P）spinningbool// 是否处于自旋状态（正在寻找可运行的 G）park note// 用于 M 的休眠/唤醒// ...}

关键点：每个 M 有一个特殊的g0，g0使用系统线程栈，运行调度代码。用户 goroutine 的代码在curg上执行。

P（Processor）

p结构体定义在src/runtime/runtime2.go:772，代表一个逻辑处理器：

// src/runtime/runtime2.go:772（简化）typepstruct{idint32statusuint32// pidle/prunning/psyscall/pgcstop/pdeadm muintptr// 关联的 M（空闲时为 nil）mcache*mcache// 内存分配缓存// 本地运行队列（无锁访问）runqheaduint32runqtailuint32runq[256]guintptr// 固定大小 256 的环形队列runnext guintptr// 下一个优先执行的 GgFree gList// 已结束的 G 缓存（可复用）// ...}

P 的数量由GOMAXPROCS环境变量或runtime.GOMAXPROCS()函数决定，默认等于 CPU 核心数。

GMP 协作关系

┌─────────────────────────────────────┐ │ Global Run Queue │ │ ┌───┐ ┌───┐ ┌───┐ ┌───┐ │ │ │ G │ │ G │ │ G │ │ G │ ... │ │ └───┘ └───┘ └───┘ └───┘ │ └──────────────┬──────────────────────┘ │ steal / put ┌──────────────────┼──────────────────┐ │ │ │ ┌─────▼─────┐ ┌─────▼─────┐ ┌─────▼─────┐ │ P0 │ │ P1 │ │ P2 │ │ ┌───────┐ │ │ ┌───────┐ │ │ ┌───────┐ │ │ │Local Q│ │ │ │Local Q│ │ │ │Local Q│ │ │ └───────┘ │ │ └───────┘ │ │ └───────┘ │ └─────┬─────┘ └─────┬─────┘ └─────┬─────┘ │ │ │ ┌─────▼─────┐ ┌─────▼─────┐ ┌─────▼─────┐ │ M0 │ │ M1 │ │ M2 │ │ (Thread) │ │ (Thread) │ │ (Thread) │ └───────────┘ └───────────┘ └───────────┘

调度循环的核心逻辑在schedule函数（src/runtime/proc.go:4135）中：

// src/runtime/proc.go:4135（简化）funcschedule(){mp:=getg().m// ...gp,inheritTime,tryWakeP:=findRunnable()// 阻塞直到找到可运行的 G// ...execute(gp,inheritTime)// 切换到 gp 执行}

findRunnable（src/runtime/proc.go:3389）查找可运行 goroutine 的优先级顺序：

1. 本地运行队列（runqget）——无锁访问，最快
2. 全局运行队列（globrunqget）——需要加锁，每 61 次调度检查一次以防饥饿
3. 网络轮询器（netpoll）——检查就绪的网络 I/O
4. 工作窃取（work stealing）——从其他 P 的本地队列偷取一半

execute（src/runtime/proc.go:3331）完成从调度器到用户 goroutine 的切换：

// src/runtime/proc.go:3331（简化）funcexecute(gp*g,inheritTimebool){mp:=getg().m mp.curg=gp// 设置当前运行的 Ggp.m=mp// G 绑定 Mcasgstatus(gp,_Grunnable,_Grunning)// 状态：就绪 → 运行// ...gogo(&gp.sched)// 汇编实现：恢复 G 的寄存器，跳转执行}

goroutine 的阻塞与唤醒

当 goroutine 需要阻塞时（如等待 channel），调用gopark（src/runtime/proc.go:445）：

// src/runtime/proc.go:445funcgopark(unlockffunc(*g,unsafe.Pointer)bool,lock unsafe.Pointer,reason waitReason,traceReason traceBlockReason,traceskipint){// ...mp:=acquirem()gp:=mp.curg gp.waitreason=reason// 记录等待原因// ...mcall(park_m)// 切换到 g0 栈，将 G 状态改为 _Gwaiting，调用 schedule()}

当条件满足时（如 channel 有数据），调用goready（src/runtime/proc.go:481）唤醒：

// goready 将 gp 状态改为 _Grunnable，放入 P 的本地运行队列funcgoready(gp*g,traceskipint)

整个流程形成循环：schedule→execute→ 用户代码 →gopark（阻塞）→schedule→ …

8.2 Channel 通信

Channel 是 Go 并发编程的核心通信原语——