Question

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

如栈没有扩容，保留。

另，copystack、shrinkstack，以及垃圾回收也会释放。

// 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
    }
}

释放同样区分大小块。

// 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
        }
        
        if stackNoCache != 0 || gp.m.p == 0 || gp.m.preemptoff != "" {
            stackpoolfree(x, order)
        } 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 {
        
        // 大块，归还给 heap，或存入全局缓存。
        
        s := spanOfUnchecked(uintptr(v))
        if gcphase == _GCoff {                                // sweeping!
            mheap_.freeManual(s, &memstats.stacks_inuse)
        } else {
            log2npage := stacklog2(s.npages)
            stackLarge.free[log2npage].insert(s)
        }
    }
}