$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 128528
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) unlimited
open files                      (-n) 4194304
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 515129
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

type stack struct {
	lo uintptr
	hi uintptr
}

var stackpool [_NumStackOrders]struct {
   item stackpoolItem
   _    [cpu.CacheLinePadSize - unsafe.Sizeof(stackpoolItem{})%cpu.CacheLinePadSize]byte
}
//go:notinheap
type stackpoolItem struct {
   mu   mutex
   span mSpanList
}
// Global pool of large stack spans.
var stackLarge struct {
   lock mutex
   free [heapAddrBits - pageShift]mSpanList // free lists by log_2(s.npages)
}

func stackinit() {
   if _StackCacheSize&_PageMask != 0 {
      throw("cache size must be a multiple of page size")
   }
   for i := range stackpool {
      stackpool[i].item.span.init()
      lockInit(&stackpool[i].item.mu, lockRankStackpool)
   }
   for i := range stackLarge.free {
      stackLarge.free[i].init()
      lockInit(&stackLarge.lock, lockRankStackLarge)
   }
}

//go:systemstack
func stackalloc(n uint32) stack {
   ...
   thisg := getg()
   ...
   var v unsafe.Pointer
   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 != "" {
         // thisg.m.p == 0 can happen in the guts of exitsyscall
         // or procresize. Just get a stack from the global pool.
         // Also don't touch stackcache during gc
         // as it's flushed concurrently.
         lock(&stackpool[order].item.mu)
         x = stackpoolalloc(order) // 全局棧緩存池
         unlock(&stackpool[order].item.mu)
      } else {
         c := thisg.m.p.ptr().mcache // 線程緩存的棧緩存中
         x = c.stackcache[order].list
         if x.ptr() == nil { // 不夠就調(diào)用stackcacherefill從堆上獲取
            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 {
      ...
   }
   ...
   return stack{uintptr(v), uintptr(v) + uintptr(n)}
}

//go:systemstack
func stackalloc(n uint32) stack {
   ...
   thisg := getg()
   ...
   var v unsafe.Pointer
   if n < _FixedStack<<_NumStackOrders && n < _StackCacheSize {
      ...
   } else {
      var s *mspan
      npage := uintptr(n) >> _PageShift
      log2npage := stacklog2(npage)
      // Try to get a stack from the large stack cache.
      lock(&stackLarge.lock)
      if !stackLarge.free[log2npage].isEmpty() { // 從stackLarge拿
         s = stackLarge.free[log2npage].first
         stackLarge.free[log2npage].remove(s)
      }
      unlock(&stackLarge.lock)
      lockWithRankMayAcquire(&mheap_.lock, lockRankMheap)
      if s == nil { // 從堆拿
         // Allocate a new stack from the heap.
         s = mheap_.allocManual(npage, spanAllocStack)
         if s == nil {
            throw("out of memory")
         }
         osStackAlloc(s)
         s.elemsize = uintptr(n)
      }
      v = unsafe.Pointer(s.base())
   }
   ...
   return stack{uintptr(v), uintptr(v) + uintptr(n)}
}

func shrinkstack(gp *g) {
	...
	oldsize := gp.stack.hi - gp.stack.lo
	newsize := oldsize / 2
	if newsize < _FixedStack {
		return
	}
	avail := gp.stack.hi - gp.stack.lo
	if used := gp.stack.hi - gp.sched.sp + _StackLimit; used >= avail/4 {
		return
	}
	copystack(gp, newsize)
}