Question

优先从 cache 本地无锁获取。

同样以等级为索引的链表数组。

链表存储的是分割好的内存地址。

提取后通过 [stack.lo, hi) 设定边界。

// mcache.go

type mcache struct {
    stackcache [_NumStackOrders]stackfreelist
}

type stackfreelist struct {
    list gclinkptr            // linked list of free stacks
    size uintptr              // total size of stacks in list
}

分配时有大小上限。

如果超出，就直接从全局大块缓存获取。

// malloc.go

// Per-P, per order stack segment cache size.
_StackCacheSize = 32 * 1024

// stack.go

// Global pool of large stack spans.

var stackLarge struct {
    lock mutex
    free [heapAddrBits - pageShift]mSpanList     // free lists by log_2(s.npages)
}

大块先从全局缓存找，或直接从 heap 分配。

// stack.go

// stackalloc allocates an n byte stack.

func stackalloc(n uint32) stack {
    
    // 判断是否超过限制。
    if n < _FixedStack<<_NumStackOrders && n < _StackCacheSize {
        
        // 计算所属大小等级。
        order := uint8(0)
        n2 := n
        for n2 > _FixedStack {
            order++
            n2 >>= 1
        }
        
        var x gclinkptr
        if stackNoCache != 0 || thisg.m.p == 0 || thisg.m.preemptoff != "" {
         
            // 直接从全局 pool 分配。
            x = stackpoolalloc(order)
         
        } else {
         
            // 从 cache 对应等级链表获取。
            c := thisg.m.p.ptr().mcache
            x = c.stackcache[order].list
         
            if x.ptr() == nil {
                // 扩容，重试。
                stackcacherefill(c, order)
                x = c.stackcache[order].list
            }
         
            c.stackcache[order].list = x.ptr().next
            c.stackcache[order].size -= uintptr(n)
        }
        
        v = unsafe.Pointer(x)
    } else {
        
        // 超出上限。
        
        var s *mspan
        npage := uintptr(n) >> _PageShift
        log2npage := stacklog2(npage)
        
        // 从全局大缓存获取。
        if !stackLarge.free[log2npage].isEmpty() {
            s = stackLarge.free[log2npage].first
            stackLarge.free[log2npage].remove(s)
        }
        
        // 直接从堆获取。
        if s == nil {
            s = mheap_.allocManual(npage, &memstats.stacks_inuse)
            s.elemsize = uintptr(n)
        }
        
        v = unsafe.Pointer(s.base())
    }
    
    return stack{uintptr(v), uintptr(v) + uintptr(n)}
}

除 malg 外，从复用列表获取 dead G 时，也可能重分配栈内存。

// proc.go

// Get from gfree list.

func gfget(_p_ *p) *g {
    if gp.stack.lo == 0 {
        systemstack(func() {
            gp.stack = stackalloc(_FixedStack)
        })
        
        gp.stackguard0 = gp.stack.lo + _StackGuard
    }
}