// init 函數(shù)在包初始化時運行，啟動一個強制 GC 的輔助 goroutine
func init() {
	go forcegchelper()  // 啟動一個獨立 goroutine，專門負責觸發(fā)強制 GC
}

// forcegchelper 是強制 GC 的后臺輔助 goroutine
func forcegchelper() {
	forcegc.g = getg()

	lockInit(&forcegc.lock, lockRankForcegc)

	for {
		lock(&forcegc.lock)

		if forcegc.idle.Load() {
			throw("forcegc: phase error")
		}

		forcegc.idle.Store(true)

		// 將當前 goroutine 掛起，釋放鎖，等待 sysmon（系統(tǒng)監(jiān)控 goroutine）喚醒
		goparkunlock(&forcegc.lock, waitReasonForceGCIdle, traceBlockSystemGoroutine, 1)

		if debug.gctrace > 0 {
			println("GC forced")
		}

		gcStart(gcTrigger{kind: gcTriggerTime, now: nanotime()})
	}
}

		if t := (gcTrigger{kind: gcTriggerTime, now: now}); t.test() && atomic.Load(&forcegc.idle) != 0 {
			lock(&forcegc.lock)
			forcegc.idle = 0
			var list gList
			// 放回隊列
			list.push(forcegc.g)
			injectglist(&list)
			unlock(&forcegc.lock)
		}

// gcStart 啟動 Go 垃圾回收（GC）。
//
// trigger: 指示 GC 啟動條件的觸發(fā)器，例如堆大小超過閾值或手動觸發(fā)。
//
// 注意：
// - 如果當前在系統(tǒng)棧上或持有鎖，不會啟動 GC。
// - 根據(jù) debug.gcstoptheworld 的設置，可能執(zhí)行并發(fā) GC 或 Stop-The-World GC。
func gcStart(trigger gcTrigger) {
	...

    // 啟動后臺 mark 工作 goroutine
    // 就是這里面做的標記工作
    gcBgMarkStartWorkers()

    // 初始化 STW（Stop-The-World）相關信息
    work.stwprocs, work.maxprocs = gomaxprocs, gomaxprocs
    if work.stwprocs > numCPUStartup {
        work.stwprocs = numCPUStartup
    }
    work.heap0 = gcController.heapLive.Load()
    work.pauseNS = 0
    work.mode = mode

    now := nanotime()
    work.tSweepTerm = now

    // 系統(tǒng)棧執(zhí)行 STW
    var stw worldStop
    systemstack(func() {
        stw = stopTheWorldWithSema(stwGCSweepTerm)
    })

    // 累計暫停時間
    work.cpuStats.accumulateGCPauseTime(stw.stoppingCPUTime, 1)

    // 在系統(tǒng)棧完成 sweep
    systemstack(func() {
        finishsweep_m()
    })

    // 清理對象池
    clearpools()

    // GC 周期計數(shù)加一
    work.cycles.Add(1)

    // 啟用協(xié)助機制和工作線程
    gcController.startCycle(now, int(gomaxprocs), trigger)
    gcCPULimiter.startGCTransition(true, now)

    if mode != gcBackgroundMode {
        schedEnableUser(false) // STW 模式下禁止用戶 goroutine 調度
    }

    // 進入并發(fā) mark 階段，并啟用寫屏障
    setGCPhase(_GCmark)
    gcBgMarkPrepare()
    // 這個函數(shù)挺重要的，會把所有的待掃描的對象空間分成多個 task。
    gcPrepareMarkRoots()
    gcMarkTinyAllocs()
    atomic.Store(&gcBlackenEnabled, 1)

    mp = acquirem()

    // 更新 CPU 統(tǒng)計信息
    work.cpuStats.accumulateGCPauseTime(nanotime()-stw.finishedStopping, work.maxprocs)

    // 并發(fā) mark 開始，STW 停止
    systemstack(func() {
        now = startTheWorldWithSema(0, stw)
        work.pauseNS += now - stw.startedStopping
        work.tMark = now

        gcCPULimiter.finishGCTransition(now)
    })

	...
}

checkWork := int64(1<<63 - 1)
var check func() bool
if flags&(gcDrainIdle|gcDrainFractional) != 0 {
    checkWork = initScanWork + drainCheckThreshold
    if idle {
        check = pollWork
    } else if flags&gcDrainFractional != 0 {
        check = pollFractionalWorkerExit
    }
}

for !(gp.preempt && (preemptible || sched.gcwaiting.Load() || pp.runSafePointFn != 0)) {
    job := atomic.Xadd(&work.markrootNext, +1) - 1
    if job >= work.markrootJobs {
        break
    }
    markroot(gcw, job, flushBgCredit)
	if check != nil && check() {
		goto done
	}
    ...
}

// gcPrepareMarkRoots 準備 GC 根對象掃描任務
func gcPrepareMarkRoots() {
    // 確認此時世界已停止（STW），防止在掃描過程中有 goroutine 修改 root
    assertWorldStopped()

    // 用于計算需要多少個 root block（數(shù)據(jù)塊）來存儲給定字節(jié)數(shù)的 root
    nBlocks := func(bytes uintptr) int {
        return int(divRoundUp(bytes, rootBlockBytes))
    }

    // 初始化 data 和 BSS root 的數(shù)量
    work.nDataRoots = 0
    work.nBSSRoots = 0

    // 掃描全局變量段（data / BSS 段）
    for _, datap := range activeModules() {
        nDataRoots := nBlocks(datap.edata - datap.data) // data 段需要多少 root block
        if nDataRoots > work.nDataRoots {
            work.nDataRoots = nDataRoots
        }

        nBSSRoots := nBlocks(datap.ebss - datap.bss) // BSS 段需要多少 root block
        if nBSSRoots > work.nBSSRoots {
            work.nBSSRoots = nBSSRoots
        }
    }

    // 掃描 span roots（用于 finalizer 特殊對象）
    // GC 會掃描在 mark 階段開始時可用的 heapArenas（即 markArenas）
    mheap_.markArenas = mheap_.heapArenas[:len(mheap_.heapArenas):len(mheap_.heapArenas)]
    work.nSpanRoots = len(mheap_.markArenas) * (pagesPerArena / pagesPerSpanRoot)

    // 掃描 goroutine 棧
    // 注意，之后新創(chuàng)建的 goroutine 不會被掃描，但它們的 root 會被寫屏障捕獲
    work.stackRoots = allGsSnapshot()
    work.nStackRoots = len(work.stackRoots)

    // 初始化 root 掃描任務索引
    work.markrootNext = 0
    // 總共需要掃描的 root 數(shù)量
    work.markrootJobs = uint32(fixedRootCount + work.nDataRoots + work.nBSSRoots + work.nSpanRoots + work.nStackRoots)

    // 計算每類 root 的起始索引，用于 markroot 調度
    work.baseData = uint32(fixedRootCount)                      // data root 起始索引
    work.baseBSS = work.baseData + uint32(work.nDataRoots)     // BSS root 起始索引
    work.baseSpans = work.baseBSS + uint32(work.nBSSRoots)     // span root 起始索引
    work.baseStacks = work.baseSpans + uint32(work.nSpanRoots) // stack root 起始索引
    work.baseEnd = work.baseStacks + uint32(work.nStackRoots)  // 所有 root 的結束索引
}

// 這是 GC 的 heap 標記循環(huán)，用于從灰色對象隊列中繼續(xù)標記對象，直到隊列為空或需要暫停。
// 此循環(huán)在 GC 的標記階段執(zhí)行（_GCmark）。
//
// 循環(huán)條件：如果當前 G 被標記為可搶占，并且滿足以下任意條件則停止循環(huán)：
// - preemptible 為 true
// - sched.gcwaiting 表示有人想觸發(fā) STW（Stop The World）
// - pp.runSafePointFn != 0 表示有 P 正在執(zhí)行安全點函數(shù)
for !(gp.preempt && (preemptible || sched.gcwaiting.Load() || pp.runSafePointFn != 0)) {

    // 嘗試保證全局隊列中有可用工作。
    // 如果 work.full == 0，說明本地隊列空了，需要從全局隊列平衡一些工作。
    if work.full == 0 {
        gcw.balance()
    }

    // 從工作隊列中獲取下一個待掃描對象或 span
    var b uintptr  // 單個對象指針
    var s objptr   // span 指針

    // 嘗試按優(yōu)先級獲取灰色對象
    if b = gcw.tryGetObjFast(); b == 0 {          // 優(yōu)先嘗試快速隊列
        if s = gcw.tryGetSpan(false); s == 0 {   // 沒有對象，嘗試獲取 span
            if b = gcw.tryGetObj(); b == 0 {     // 再嘗試普通隊列
                wbBufFlush()                     // 寫屏障緩沖區(qū) flush，可能產生新的灰色對象
                if b = gcw.tryGetObj(); b == 0 { // 再次嘗試獲取對象
                    s = gcw.tryGetSpan(true)     // 最后嘗試獲取 span
                }
            }
        }
    }

    // 如果拿到對象或 span，就掃描它們
    if b != 0 {
        scanobject(b, gcw)  // 掃描對象，將其引用的對象加入灰色隊列
    } else if s != 0 {
        scanSpan(s, gcw)    // 掃描 span，處理里面的對象
    } else {
        // 隊列空，無法獲取更多工作，循環(huán)結束
        break
    }

    // 如果實驗性 GreenTea GC 需要新 worker，則啟動
    if goexperiment.GreenTeaGC && gcw.mayNeedWorker {
        gcw.mayNeedWorker = false
        if gcphase == _GCmark {
            gcController.enlistWorker()
        }
    }

    // 將本地累積的掃描工作量計入全局，供 mutator assist 使用
    if gcw.heapScanWork >= gcCreditSlack {
        gcController.heapScanWork.Add(gcw.heapScanWork) // 增加全局 heapScanWork
        if flushBgCredit {
            gcFlushBgCredit(gcw.heapScanWork - initScanWork) // flush 背景掃描信用
            initScanWork = 0
        }
        checkWork -= gcw.heapScanWork
        gcw.heapScanWork = 0

        // 檢查，之前提到的 check
        if checkWork <= 0 {
            checkWork += drainCheckThreshold
            if check != nil && check() {
                break
            }
        }
    }
}

// greyobject 將一個堆對象標記為灰色（可掃描），并將其加入到 P 的本地工作隊列 gcw 中，以便后續(xù)掃描其內部指針。
// 如果對象不可掃描（noscan），則直接標記為黑色。
//
// 參數(shù)說明：
// obj       : 要標記的對象起始地址
// base, off : 調試信息，用于記錄對象是通過哪個 root 掃描到的
// span      : 對象所在的內存 span
// gcw       : 當前 P 的本地 GC 工作隊列
// objIndex  : 對象在 span 中的索引
//
// go:nowritebarrierrec 表示此函數(shù)不會觸發(fā)寫屏障，且可遞歸調用
func greyobject(obj, base, off uintptr, span *mspan, gcw *gcWork, objIndex uintptr) {
	...

	// 將對象加入 P 的本地工作隊列，以便后續(xù) scanobject 掃描其指針
	if !gcw.putObjFast(obj) { // 快速入隊
		gcw.putObj(obj)       // 慢速入隊（如果快速失敗）
	}
}

// scanobject 掃描以 b 開頭的堆對象，將對象內部的指針加入 gcw 隊列。
// b 必須指向一個堆對象或 oblet（大對象的分塊）。
// scanobject 會根據(jù) GC 的位圖獲取指針掩碼，并通過 span 獲取對象大小。
//
//go:nowritebarrier 表示該函數(shù)不會觸發(fā)寫屏障。
func scanobject(b uintptr, gcw *gcWork) {
	...
	var scanSize uintptr
	for {
		var addr uintptr
		// 嘗試快速獲取下一個指針
		if tp, addr = tp.nextFast(); addr == 0 {
			// 如果沒有快速指針，再走慢路徑
			if tp, addr = tp.next(b + n); addr == 0 {
				break
			}
		}

		// 更新掃描范圍，用于統(tǒng)計 heapScanWork
		scanSize = addr - b + goarch.PtrSize

		// 讀取對象中的潛在指針
		obj := *(*uintptr)(unsafe.Pointer(addr))

		// 過濾掉 nil 和指向當前對象內部的指針
		if obj != 0 && obj-b >= n {
			// 判斷 obj 是否指向 Go 堆中的對象，如果是則標記
			// 注意可能存在與分配同時發(fā)生的競爭，findObject 可能失敗
			if !tryDeferToSpanScan(obj, gcw) {
				if obj, span, objIndex := findObject(obj, b, addr-b); obj != 0 {
					// 將指針對象標記為灰色，并入隊等待掃描
					greyobject(obj, b, addr-b, span, gcw, objIndex)
				}
			}
		}
	}

	// 更新本地 GC 工作隊列的統(tǒng)計信息
	gcw.bytesMarked += uint64(n)
	gcw.heapScanWork += int64(scanSize)
	if debug.gctrace > 1 {
		gcw.stats[s.spanclass.sizeclass()].sparseObjsScanned++
	}
}

markroot（掃描 root 對象：全局變量、棧、span specials）
    ↓
發(fā)現(xiàn)堆對象 → greyobject → 標灰 + 入本地隊列 gcw
    ↓
heap 掃描階段（drain heap marking jobs）
    ↓
從 gcw 隊列取灰對象（tryGetObj/tryGetSpan）
    ↓
scanobject 掃描對象內部指針
    ↓
掃描出的新對象 → greyobject → 入 gcw 隊列（迭代處理）
    ↓
重復直到隊列為空 → 所有可達對象都被標記

// mallocgc 分配一個指定大小的對象。
// 小對象從 P（處理器本地）緩存的 free list 分配。
// 大對象（> 32 KB）直接從堆分配。
// mallocgc 是 runtime 內部接口，但一些第三方庫通過 //go:linkname 調用。
// 請勿修改函數(shù)簽名，否則可能破壞 runtime。
//
// 參數(shù):
//   size     - 需要分配的字節(jié)數(shù)
//   typ      - 對象類型信息 (_type)，用于 GC 掃描指針；nil 表示 noscan
//   needzero - 是否需要將分配的內存清零
//
// 返回值:
//   unsafe.Pointer - 指向分配好的對象
//
// go:linkname 指令允許其他包直接調用 runtime.mallocgc
//
// mallocgc 核心功能:
// 1. 檢查 GC assist，決定 mutator 是否需要幫忙做標記。
// 2. 根據(jù)對象大小選擇 tiny allocator / small allocator / large allocator。
// 3. 調用 sanitizers（race、msan、asan、valgrind）。
// 4. 調整 GC assist 債務。
func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
	...

	// 當前是否在 GC mark 階段且 write barrier 啟用
	// 如果需要，mutator（分配者）需要幫忙標記一些對象
	if gcBlackenEnabled != 0 {
		deductAssistCredit(size) // 扣除助理信用，并可能觸發(fā) gcDrain
	}

	...
}