Question

将 dead G 放回复用链表时，会尝试释放栈内存。

// proc.go

// Put on gfree list.
func gfput(_p_ *p, gp *g) {

	stksize := gp.stack.hi - gp.stack.lo

	if stksize != _FixedStack {
        
		// non-standard stack size - free it.
		stackfree(gp.stack)
        
		gp.stack.lo = 0
		gp.stack.hi = 0
		gp.stackguard0 = 0
	}
}

仅特定长度（FixedStack）栈内存可供复用。如发生扩容，则被释放。除此之外，copystack、shrinkstack 都会引发栈释放操作。

// stack.go

// stackfree frees an n byte stack allocation at stk.
func stackfree(stk stack) {
    
	v := unsafe.Pointer(stk.lo)
	n := stk.hi - stk.lo
    
    // 小块。
	if n < _FixedStack<<_NumStackOrders && n < _StackCacheSize {
        
        // 计算等级。
		order := uint8(0)
		n2 := n
		for n2 > _FixedStack {
			order++
			n2 >>= 1
		}
        
		x := gclinkptr(v)
		if stackNoCache != 0 || gp.m.p == 0 || gp.m.preemptoff != "" {
            
            // 放回池。
			lock(&stackpool[order].item.mu)
			stackpoolfree(x, order)
			unlock(&stackpool[order].item.mu)
            
		} else {
            
            // 如对应等级缓存过多，则转移一批到全局。
			c := gp.m.p.ptr().mcache
			if c.stackcache[order].size >= _StackCacheSize {
				stackcacherelease(c, order)
			}
            
            // 放回对应等级链表。
			x.ptr().next = c.stackcache[order].list
			c.stackcache[order].list = x
			c.stackcache[order].size += n
		}
	} else {
        
        // 大块：归还给堆，或放回大块缓存。
        
		s := spanOfUnchecked(uintptr(v))
		if gcphase == _GCoff {
			osStackFree(s)
			mheap_.freeManual(s, spanAllocStack)
		} else {
			log2npage := stacklog2(s.npages)
			lock(&stackLarge.lock)
			stackLarge.free[log2npage].insert(s)
			unlock(&stackLarge.lock)
		}
	}
}