Question

对于执行结束的 dead G 并不会释放，而是缓存在 P 本地或全局，以待复用。

// runtime2.go

type schedt struct {
    // Global cache of dead G's.
    gFree struct {
        stack   gList    // Gs with stacks
        noStack gList    // Gs without stacks
        n       int32
    }
}

type p struct {
    // Available G's (status == Gdead)
    gFree struct {
        gList
        n int32
    }
}

gList 是一个以 G.schedlink 构建的链表。

先从 P 本地链表提取，准备复用。

如果没有，那么先全局批量提取一些填充到本地。

// proc.go

// Get from gfree list.
// If local list is empty, grab a batch from global list.

func gfget(_p_ *p) *g {
retry:
    
    // 如果本地复用链表为空，则从全局转移一批过来。
    if _p_.gFree.empty() && (!sched.gFree.stack.empty() || !sched.gFree.noStack.empty()) {
        
        // 尽可能让本地凑足 32 个。
        for _p_.gFree.n < 32 {
            
            // 优先选择有栈内存的。
            gp := sched.gFree.stack.pop()
            if gp == nil {
                gp = sched.gFree.noStack.pop()
                if gp == nil {
                    break
                }
            }
            
            sched.gFree.n--
            _p_.gFree.push(gp)
            _p_.gFree.n++
        }
        
        // 转移过后，重试！确保本地队列不为空。
        goto retry
    }
    
    // 从本地提取。
    gp := _p_.gFree.pop()
    if gp == nil {
        return nil
    }
    
    _p_.gFree.n--
    
    // 补上栈内存。
    if gp.stack.lo == 0 {
        systemstack(func() {
            gp.stack = stackalloc(_FixedStack)
        })
        gp.stackguard0 = gp.stack.lo + _StackGuard
    }
    
    return gp
}

执行完的被放回 P 本地链表。

如果本地链表过长，则转移一批到全局，供其他 P 使用。

// proc.go

// Put on gfree list.
// If local list is too long, transfer a batch to the global 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
    }
    
    // 存入本地链表。
    _p_.gFree.push(gp)
    _p_.gFree.n++
    
    // 如果本地数量超过 64，则转移一批到全局。
    if _p_.gFree.n >= 64 {
        
        // 本地只留 32 个。
        for _p_.gFree.n >= 32 {
            _p_.gFree.n--
            gp = _p_.gFree.pop()
            
            // 根据栈内存是否释放选择目标位置。
            if gp.stack.lo == 0 {
                sched.gFree.noStack.push(gp)
            } else {
                sched.gFree.stack.push(gp)
            }
            
            sched.gFree.n++
        }
    }
}