Go Goroutine 栈底层实现全解析：分段栈到连续栈、morestack 触发与栈缩容机制

面试怎么问

「goroutine 的栈有多大？为什么能开几十万个 goroutine？无限递归一定会栈溢出吗？栈上的内存会被 GC 管理吗？」——这是并发篇之外最能区分「背八股」和「懂运行时」的题。本文所有结论均对照 Go 官方发布说明与 runtime 源码（2026-11-14 核对 master 分支）给出。

一、为什么 goroutine 栈要「小起步、动态涨」

系统线程的栈是固定大小的，通常预分配数 MB。C 程序开 10 万个线程，仅栈就要占用数十 GB 虚拟内存，这就是为什么传统服务端用线程池而不是每连接一线程。

goroutine 的破局思路正好相反：起步极小、按需增长、不用收缩。一个几乎不占栈的 goroutine（比如阻塞在 channel 收发上）可能只用到几百字节的栈，百万 goroutine 的内存开销才可控。代价是：运行时必须自己管理栈的生长与收缩——这就是本文的主角。

一个常见误区先澄清：「网上很多资料说 goroutine 初始栈是 8KB」。这个数字已经过时。runtime/stack.go 当前的定义是（2026-11-14 核对 master 分支）：

// The minimum size of stack used by Go code
stackMin = 2048

即当前源码中栈最小单元是 2048 字节（2KB），实际分配还会加上平台相关的保留区（如 Windows 信号处理区）。面试时被问「初始栈多大」，最稳妥的答法是：「很小，KB 级别，具体值随版本演进，当前 runtime 源码里 stackMin 是 2KB」。

二、历史演进：分段栈为什么被废弃

Go 1.3 之前用的是分段栈（segmented stacks）：栈由若干段组成，段间用指针链接，用尽当前段就链接一个新段。思路轻巧，但有一个著名 bug——hot split（热分裂）：如果计算反复在段边界上徘徊，就会不停地「加一段、退一段、再加一段」，开销巨大且难以预测。

Go 1.3 起改为连续栈（contiguous stacks）——这是官方 Go 1.3 Release Notes 明确记载的变化：当 goroutine 需要更多栈时，分配一块更大的连续内存，把旧栈整体拷贝过去，此后这块大栈一直归该 goroutine 使用，直到缩容或销毁。一次性拷贝的代价会被后续运行均摊，热分裂问题被根除。

连续栈方案牵一发而动全身，它要求运行时能精确知道栈上每个位置是不是指针（否则拷贝后无法修正指针）。Go 1.3 同时为栈实现了精确 GC（precise GC）——栈上的整数值永远不会被误当成指针。这也带来一条硬规则（同样出自 Go 1.3 Release Notes）：用 unsafe.Pointer 把整数藏进指针类型、或把栈指针存进整数字段，自此属于非法操作，栈扩容或 GC 可能因此产生悬垂指针，且极难排查。

三、栈增长：morestack 是怎么被触发的

每个 goroutine 的结构里记录了栈的上下界（stack.lo / stack.hi）和保护指针 stackguard0。编译器在**每个函数的序言（prologue）**里插入一段检查，逻辑等价于：

if SP < stackguard0 { // 栈快用完了
    call morestack()  // 走增长流程
}

也就是说：栈增长检查是逐函数调用的，不是定时轮询。函数还没开帧就先确认剩余空间够不够，不够就暂停业务逻辑，转去执行 morestack → copystack，拿到新栈后重新执行这个函数。

两个细节面试常追问：

增长幅度是翻倍：copystack 分配新栈时 newsize = oldsize * 2。2KB → 4KB → 8KB……按需翻倍，摊销后均摊成本接近 O(1)。默认上限 1GB（64 位平台），可通过 debug.SetMaxStack 调整。
NOSPLIT 函数例外：//go:nosplit 标记的函数（runtime 内部及少量高频函数）序言里没有栈检查，因为检查本身需要栈空间。所以 runtime 必须保证 NOSPLIT 函数链的总栈耗有硬上限（源码里 stackNosplit 常量），否则可能在检查发生前就踩穿栈。

四、copystack：搬家时怎么把指针挨个改对

栈是一块连续内存，「搬家」意味着旧栈上所有指向栈自身的指针都必须加上偏移量修正。运行时靠编译器生成的**栈地图（stack map）**完成这件事：编译器记录每个函数帧里哪些偏移位置是指针，GC 和 copystack 拿着这张表就能精确调整。

流程简述：

stackalloc(newsize) 分配一块翻倍的新栈；
按栈地图把旧栈内容逐帧拷贝过去，并修正所有栈内指针；
调整 gp.stack、gp.sched.sp 等寄存器快照；
释放旧栈，回到被中断的函数继续执行。

栈地图机制正是第二节「精确 GC」的同一套基础设施——栈增长和栈扫描在 Go 里是一对孪生兄弟。

五、栈缩容：用得少了就还回去

栈只涨不还也不行——典型场景：某个请求处理过程中递归很深，栈涨到了 8MB，之后这个 goroutine 回到事件循环，常年只用几 KB，8MB 就白占了。

缩容由 shrinkstack 在 GC 时统一处理（不会函数返回时顺手缩，避免抖动）。源码逻辑（2026-11-14 核对 master 分支）非常朴素：

newsize := oldsize / 2
if newsize < fixedStack { return }        // 不低于最小栈
if used := gp.stack.hi - gp.sched.sp + stackNosplit; used >= avail/4 {
	return                                // 使用量 ≥ 1/4 不缩
}
copystack(gp, newsize)

即三条规则：每次减半；不低于最小栈；只有使用量不足当前栈的 1/4 才缩。1/4 阈值是防止「刚缩完又涨」的抖动。所以结论是：缩容是 GC 驱动的、保守的，一个偶发深递归的 goroutine，栈会在几次 GC 后逐步还回去。

六、动手验证：两个可运行实验

实验一：小帧函数的深度递归——证明栈是动态增长的：

package main

import "fmt"

// 每帧只占极少栈空间的小函数
func sum(n int) int {
	if n <= 0 {
		return 0
	}
	return n + sum(n-1)
}

func main() {
	// 100 万层递归照常跑完：栈已从 KB 级自动翻倍增长到几十 MB
	fmt.Println(sum(1000000)) // 输出: 500000500000
}

实验二：用 debug.SetMaxStack 人为压低栈上限，观察「栈溢出」的真实形态：

package main

import (
	"fmt"
	"runtime/debug"
)

func sum(n int) int {
	if n <= 0 {
		return 0
	}
	return n + sum(n-1)
}

func main() {
	debug.SetMaxStack(1 << 20) // 1MB 上限，仅作演示
	fmt.Println(sum(1000000))
}

运行后程序会打印形如 fatal error: goroutine stack exceeds 1000000-byte limit 的 fatal error 并直接退出——注意它不是 panic，recover 捕获不到，进程退出码非零。这就是 Go 栈溢出与普通 panic 的本质区别，面试答「无限递归会怎样」时要带上这一句。

七、面试速查清单

问题	一句话答案
goroutine 栈多大？	起步很小（当前源码 stackMin = 2KB），按需翻倍增长，默认上限 1GB
为什么能开百万 goroutine？	栈 KB 级起步 + 动态伸缩，空转 goroutine 几乎不占内存
栈什么时候增长？	函数序言里的 SP < stackguard0 检查触发 morestack → copystack
增长幅度？	翻倍（2KB→4KB→8KB…），摊销后接近 O(1)
栈会缩小吗？	会。GC 时 shrinkstack：减半、不低于最小栈、用量 < 1/4 才缩
为什么 hot split 不是问题了？	Go 1.3 起分段栈改连续栈，整体拷贝、一劳永逸
栈上的内存归 GC 管吗？	栈本身由 runtime 管理，GC 需要精确扫描栈（Go 1.3 起栈值精确），配合栈地图完成
unsafe 把栈指针存进 int 会怎样？	非法。连续栈拷贝 + 精确 GC 会把它判死，产生悬垂指针
NOSPLIT 是什么？	序言无栈检查的函数，runtime 保证其栈耗硬上限
栈溢出能被 recover 吗？	不能。它是 fatal error，进程直接退出

八、追问预判：指针调整的两个刁钻问题

「栈会搬家，那为什么把局部变量指针传出去是安全的？」——因为安全与否由逃逸分析在编译期裁定：编译器发现指针会被外部长期持有（逃逸出函数生命周期），就把它分配到堆上，栈上只留指针或干脆不留。能安全留在栈上的指针，其生命周期必然短于这次栈搬家，或只被栈地图覆盖的调用帧使用。所以「栈会移动」对业务代码是透明的。

「函数返回后它的栈帧还在吗？」——SP 回退即逻辑销毁，但内存还在栈块里，直到被后续调用覆盖。这也是为什么不能用 unsafe 拿栈地址当长期句柄。

Go 编程语言之旅

io

math

reflect

path

container

list

crypto

md5

text

template

testing

runtime

hash

crc32

archive