Go 底层原理丨垃圾回收（三色标记法）

type gcTrigger struct {
	kind gcTriggerKind
	now  int64  // gcTriggerTime: 当前时间
	n    uint32 // gcTriggerCycle: 要启动的周期编号
}

const (
	// gcTriggerHeap: 当堆大小达到控制器计算的触发堆大小时启动
	gcTriggerHeap gcTriggerKind = iota
	
	// gcTriggerTime: 距离上次GC超过 forcegcperiod (2分钟) 时启动
	gcTriggerTime
	
	// gcTriggerCycle: 手动触发
	gcTriggerCycle
)

func (t gcTrigger) test() bool {
	// 必须满足：GC已启用、非panic状态、不在GC中
	if !memstats.enablegc || panicking.Load() != 0 || gcphase != _GCoff {
		return false
	}
	switch t.kind {
	case gcTriggerHeap:
		// 堆触发：heapLive >= trigger
		trigger, _ := gcController.trigger()
		return gcController.heapLive.Load() >= trigger
	case gcTriggerTime:
		// 时间触发：距上次GC > forcegcperiod (2分钟)
		if gcController.gcPercent.Load() < 0 {
			return false
		}
		lastgc := int64(atomic.Load64(&memstats.last_gc_nanotime))
		return lastgc != 0 && t.now-lastgc > forcegcperiod
	case gcTriggerCycle:
		// 手动触发
		return int32(t.n-work.cycles.Load()) > 0
	}
	return true
}

func gcStart(trigger gcTrigger) {
    // 1. 安全性检查 (Preamble)
    // 如果当前 Goroutine 正持有锁（如在 malloc 内部），或者不可抢占，
    // 强行启动 GC 可能会导致死锁或状态损坏。此时放弃，等待下一次机会。
    mp := acquirem()
    if gp := getg(); gp == mp.g0 || mp.locks > 1 || mp.preemptoff != "" {
        releasem(mp)
        return
    }
    releasem(mp)

    // 2. 清理上一轮的残余 (Finish Previous Sweep)
    // 在开启新一轮 GC 前，必须确保上一轮的垃圾清理（Sweep）完全结束。
    // 如果是后台触发，通常已经清完了；如果是手动强制触发，这里会循环清理直到干净。
    for trigger.test() && sweepone() != ^uintptr(0) {
    }

    // 抢占启动锁，防止多个 P 同时启动 GC
    semacquire(&work.startSema)
    
    // 再次检查触发条件（Double Check），防止在抢锁过程中条件已变化
    if !trigger.test() {
        semrelease(&work.startSema)
        return
    }

    // ============================================================
    // 3. 阶段一：扫描终止 (Sweep Termination) - STW 开始
    // ============================================================
    
    // 唤醒后台标记工作协程（gcBgMarkWorker），让它们准备好干活
    gcBgMarkStartWorkers()
    
    // 重置标记相关的全局状态（如重置工作队列等）
    systemstack(gcResetMarkState)

    // Stop The World! 
    // 这是 GC 周期的第一个 STW。目的是为了在一个静止的世界里，
    // 安全地切换 GC 阶段标志位，并开启写屏障。
    // 此时，所有用户代码暂停。
    var stw worldStop
    systemstack(func() {
        stw = stopTheWorldWithSema(stwGCSweepTerm)
    })

    // 在 STW 期间，确保所有 Span 的清理工作彻底完成（兜底）
    systemstack(func() {
        finishsweep_m()
    })

    // 清理 sync.Pool。
    // 这是一个权衡：必须在 STW 期间清空，否则老对象会活到下一轮。
    clearpools()

    // 增加 GC 计数器
    work.cycles.Add(1)

    // 初始化 GC 控制器，设定本轮的目标（基于 P 的数量等）
    gcController.startCycle(now, int(gomaxprocs), trigger)

    // ============================================================
    // 4. 阶段二：准备并发标记 (Prepare Concurrent Mark)
    // ============================================================

    // 【关键点】开启混合写屏障 (Hybrid Write Barrier)
    // setGCPhase 将全局状态改为 _GCmark。
    // 由于此时还在 STW，所有 P 在被唤醒后，都会看到这个新状态，
    // 从而在执行 pointer write 时自动触发屏障逻辑。
    setGCPhase(_GCmark)

    // 准备根对象（Globals, Stack, Registers 等）
    // 这一步必须在 assist 开启前完成。
    gcBgMarkPrepare() 
    gcPrepareMarkRoots()

    // 标记所有 tiny alloc 块为黑色。
    // 这是一个优化：小对象分配非常频繁，如果不预先染黑，
    // 每次分配都要触发屏障，性能会崩。
    gcMarkTinyAllocs()

    // 【关键点】启用 Mutator Assist (辅助标记)
    // 允许用户协程在分配内存太快时，“被迫”帮忙进行标记。
    // 必须在写屏障开启后才能启用。
    atomic.Store(&gcBlackenEnabled, 1)

    // ============================================================
    // 5. 恢复世界 (Start The World)
    // ============================================================

    // 此时状态已经切换为 _GCmark，写屏障已启用，后台 Worker 已就绪。
    // 恢复用户代码运行。
    systemstack(func() {
        now = startTheWorldWithSema(0, stw)
    })

    // 释放启动锁
    semrelease(&work.startSema)
}

func gcBgMarkStartWorkers() {
	ready := make(chan struct{}, 1)
	for gcBgMarkWorkerCount < gomaxprocs {
		go gcBgMarkWorker(ready)
		<-ready
	}
}

func gcBgMarkWorker(ready chan struct{}) {
	ready <- struct{}{}
	for {
    // 根据不同标记的工作者类型调用不同的标记函数
		systemstack(func() {
			switch pp.gcMarkWorkerMode {
			case gcMarkWorkerDedicatedMode:
				gcDrainMarkWorkerDedicated(&pp.gcw, true)
				if gp.preempt {
					if drainQ := runqdrain(pp); !drainQ.empty() {
						lock(&sched.lock)
						globrunqputbatch(&drainQ)
						unlock(&sched.lock)
					}
				}
				gcDrainMarkWorkerDedicated(&pp.gcw, false)
			case gcMarkWorkerFractionalMode:
				gcDrainMarkWorkerFractional(&pp.gcw)
			case gcMarkWorkerIdleMode:
				gcDrainMarkWorkerIdle(&pp.gcw)
			}
			casgstatus(gp, _Gwaiting, _Grunning)
		})
		
    // 检测标记终止
		if incnwait == work.nproc && !gcMarkWorkAvailable(nil) {
			gcMarkDone()
		}
	}
}

switch pp.gcMarkWorkerMode {
case gcMarkWorkerDedicatedMode:
	// Dedicated Worker: 专用标记工作者，持续标记直到没有更多工作或被抢占
	gcDrainMarkWorkerDedicated(&pp.gcw, true)
	if gp.preempt {
		// 被抢占时，清空运行队列
		if drainQ := runqdrain(pp); !drainQ.empty() {
			lock(&sched.lock)
			globrunqputbatch(&drainQ)
			unlock(&sched.lock)
		}
	}
	gcDrainMarkWorkerDedicated(&pp.gcw, false)
	
case gcMarkWorkerFractionalMode:
	// Fractional Worker: 分数标记工作者，按照目标使用率工作
	gcDrainMarkWorkerFractional(&pp.gcw)
	
case gcMarkWorkerIdleMode:
	// Idle Worker: 空闲标记工作者，仅在P空闲时工作
	gcDrainMarkWorkerIdle(&pp.gcw)
}

type gcWork struct {
    wbuf1, wbuf2 *workbuf  // 双缓冲：wbuf1 当前使用，wbuf2 备用
    bytesMarked uint64     // 本地标记的字节数
    flushedWork bool       // 是否将工作刷新到全局队列
}

// putObj 将一个灰色对象加入工作队列（生产）
func (w *gcWork) putObj(obj uintptr) {
    wbuf := w.wbuf1
    
    // 初始化或检查缓冲区
    if wbuf == nil {
        w.init()  // 初始化双缓冲
        wbuf = w.wbuf1
    } else if wbuf.nobj == len(wbuf.obj) {  // wbuf1 满了
        // 双缓冲切换：wbuf1 <-> wbuf2
        w.wbuf1, w.wbuf2 = w.wbuf2, w.wbuf1
        wbuf = w.wbuf1
        
        if wbuf.nobj == len(wbuf.obj) {  // 两个缓冲区都满了
            putfull(wbuf)  // 将满的缓冲区放入全局 full 队列
            w.flushedWork = true
            wbuf = getempty()  // 获取新的空缓冲区
            w.wbuf1 = wbuf
        }
    }
    
    // 将对象加入缓冲区
    wbuf.obj[wbuf.nobj] = obj
    wbuf.nobj++
}

// tryGetObj 从工作队列取出一个灰色对象（消费）
func (w *gcWork) tryGetObj() uintptr {
    wbuf := w.wbuf1
    
    if wbuf == nil {
        w.init()
        wbuf = w.wbuf1
    }
    
    if wbuf.nobj == 0 {  // wbuf1 空了
        // 双缓冲切换
        w.wbuf1, w.wbuf2 = w.wbuf2, w.wbuf1
        wbuf = w.wbuf1
        
        if wbuf.nobj == 0 {  // 两个缓冲区都空了
            owbuf := wbuf
            wbuf = trygetfull()  // 从全局 full 队列获取
            if wbuf == nil {
                return 0  // 没有工作了
            }
            putempty(owbuf)  // 将空缓冲区归还全局 empty 队列
            w.wbuf1 = wbuf
        }
    }
    
    // 从缓冲区取出对象
    wbuf.nobj--
    return wbuf.obj[wbuf.nobj]
}

func gcPrepareMarkRoots() {
	assertWorldStopped()
	
	// 1. 计算data段和bss段的根对象数量
	work.nDataRoots = 0
	work.nBSSRoots = 0
	for _, datap := range activeModules() {
		nDataRoots := nBlocks(datap.edata - datap.data)
		if nDataRoots > work.nDataRoots {
			work.nDataRoots = nDataRoots
		}
		nBSSRoots := nBlocks(datap.ebss - datap.bss)
		if nBSSRoots > work.nBSSRoots {
			work.nBSSRoots = nBSSRoots
		}
	}
	
	// 2. 准备扫描span中的finalizer specials
	mheap_.markArenas = mheap_.heapArenas[:len(mheap_.heapArenas):len(mheap_.heapArenas)]
	work.nSpanRoots = len(mheap_.markArenas) * (pagesPerArena / pagesPerSpanRoot)
	
	// 3. 准备扫描所有goroutine的栈
	// 在此点之后创建的G会从重置状态开始，所以不需要扫描
	work.stackRoots = allGsSnapshot()
	work.nStackRoots = len(work.stackRoots)
	
	// 计算总的根对象扫描任务数
	work.markrootNext = 0
	work.markrootJobs = uint32(fixedRootCount + work.nDataRoots + 
	                           work.nBSSRoots + work.nSpanRoots + work.nStackRoots)
	
	// 计算各类根对象的基础索引
	work.baseData = uint32(fixedRootCount)
	work.baseBSS = work.baseData + uint32(work.nDataRoots)
	work.baseSpans = work.baseBSS + uint32(work.nBSSRoots)
	work.baseStacks = work.baseSpans + uint32(work.nSpanRoots)
	work.baseEnd = work.baseStacks + uint32(work.nStackRoots)
}

func gcDrain(gcw *gcWork, flags gcDrainFlags) {
    // === 1. 初始化和模式设置 ===
  	// ...  
  
    // 设置检查点：定期检查是否应该退出
    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  // 分数模式：检查是否达到目标时间
        }
    }

    // === 2. 阶段一：排空根标记任务 ===
    // 根对象包括：全局变量、goroutine 栈、finalizer 等
  	// 即前面 gcPrepareMarkRoots() 准备的内容
    if work.markrootNext < work.markrootJobs {
        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  // 空闲模式有其他工作 or 分数模式达到时间
            }
            
            // GreenTeaGC: 如果需要，启动新工作者
            if goexperiment.GreenTeaGC && gcw.mayNeedWorker {
                gcw.mayNeedWorker = false
                if gcphase == _GCmark {
                    gcController.enlistWorker()
                }
            }
        }
    }

    // === 3. 阶段二：排空堆标记任务（主循环）===
    for !(gp.preempt && (preemptible || sched.gcwaiting.Load() || pp.runSafePointFn != 0)) {
        // 3.1 工作平衡：保持全局队列有工作，避免其他工作者等待
        if work.full == 0 {
            gcw.balance()  // 将本地缓冲的部分工作放回全局队列
        }

        // 3.2 按优先级顺序获取工作（见 mgcwork.go 注释）
        var b uintptr  // 对象指针
        var s objptr   // span 指针
        
        // 优先级 1: P-local workbuf
        if b = gcw.tryGetObjFast(); b == 0 {
            // 优先级 2: P-local span queue (GreenTeaGC)
            if s = gcw.tryGetSpan(false); s == 0 {
                // 优先级 3: 全局 workbuf
                if b = gcw.tryGetObj(); b == 0 {
                    // 刷新写屏障缓冲区，可能产生新工作
                    wbBufFlush()
                    if b = gcw.tryGetObj(); b == 0 {
                        // 优先级 4: 全局 span queue
                        s = gcw.tryGetSpan(true)
                    }
                }
            }
        }
        
        // 3.3 处理获取到的工作
        if b != 0 {
            scanobject(b, gcw)  // 扫描对象：遍历其指针字段，标记引用
        } else if s != 0 {
            scanSpan(s, gcw)    // 扫描 span：批量处理 span 中的对象
        } else {
            break  // 没有工作了，退出
        }

        // 3.4 可能启动新工作者
        if goexperiment.GreenTeaGC && gcw.mayNeedWorker {
            gcw.mayNeedWorker = false
            if gcphase == _GCmark {
                gcController.enlistWorker()
            }
        }

        // 3.5 刷新扫描工作信用（用于 mutator assist 的记账）
        if gcw.heapScanWork >= gcCreditSlack {  // 累积了 2000 字节扫描工作
            gcController.heapScanWork.Add(gcw.heapScanWork)  // 刷新到全局
            
            if flushBgCredit {
                // 后台标记：产生信用，让 mutator 可以借用
                gcFlushBgCredit(gcw.heapScanWork - initScanWork)
                initScanWork = 0
            }
            
            checkWork -= gcw.heapScanWork
            gcw.heapScanWork = 0
            
            // 定期检查退出条件
            if checkWork <= 0 {
                checkWork += drainCheckThreshold
                if check != nil && check() {
                    break
                }
            }
        }
    }

done:
    // === 4. 清理：刷新剩余的扫描工作 ===
    if gcw.heapScanWork > 0 {
        gcController.heapScanWork.Add(gcw.heapScanWork)
        if flushBgCredit {
            gcFlushBgCredit(gcw.heapScanWork - initScanWork)
        }
        gcw.heapScanWork = 0
    }
}

// markroot 标记第 i 个根对象任务
// 根对象是 GC 追踪的起点，包括全局变量、栈、finalizer 等
func markroot(gcw *gcWork, i uint32, flushBgCredit bool) int64 {
    var workDone int64
    var workCounter *atomic.Int64
    
    switch {
    // === 1. 全局变量（data 段）===
    case work.baseData <= i && i < work.baseBSS:
        workCounter = &gcController.globalsScanWork
        for _, datap := range activeModules() {
            // 扫描 data 段：已初始化的全局变量
            workDone += markrootBlock(
                datap.data,              // 起始地址
                datap.edata-datap.data,  // 大小
                datap.gcdatamask.bytedata, // 指针位图
                gcw,
                int(i-work.baseData),    // 分片索引
            )
        }
    
    // === 2. 全局变量（BSS 段）===
    case work.baseBSS <= i && i < work.baseSpans:
        workCounter = &gcController.globalsScanWork
        for _, datap := range activeModules() {
            // 扫描 BSS 段：未初始化的全局变量
            workDone += markrootBlock(
                datap.bss,
                datap.ebss-datap.bss,
                datap.gcbssmask.bytedata,
                gcw,
                int(i-work.baseBSS),
            )
        }
    
    // === 3. Finalizer 队列 ===
    case i == fixedRootFinalizers:
        for fb := allfin; fb != nil; fb = fb.alllink {
            cnt := uintptr(atomic.Load(&fb.cnt))
            // 扫描 finalizer 结构体中的指针
            scanblock(uintptr(unsafe.Pointer(&fb.fin[0])), 
                      cnt*unsafe.Sizeof(fb.fin[0]), 
                      &finptrmask[0], gcw, nil)
        }
    
    // === 4. 释放死亡 G 的栈 ===
    case i == fixedRootFreeGStacks:
        systemstack(markrootFreeGStacks)
    
    // === 5. Cleanup 队列 ===
    case i == fixedRootCleanups:
        for cb := (*cleanupBlock)(gcCleanups.all.Load()); cb != nil; cb = cb.alllink {
            n := uintptr(atomic.Load(&cb.n))
            scanblock(uintptr(unsafe.Pointer(&cb.cleanups[0])), 
                      n*goarch.PtrSize, 
                      &cleanupBlockPtrMask[0], gcw, nil)
        }
    
    // === 6. Span 特殊对象（如 finalizer specials）===
    case work.baseSpans <= i && i < work.baseStacks:
        markrootSpans(gcw, int(i-work.baseSpans))
    
    // === 7. Goroutine 栈（最重要！）===
    default:
        workCounter = &gcController.stackScanWork
        if i < work.baseStacks || work.baseEnd <= i {
            throw("markroot: bad index")
        }
        
        gp := work.stackRoots[i-work.baseStacks]  // 获取 goroutine
        
        systemstack(func() {
            // 处理自扫描情况
            userG := getg().m.curg
            selfScan := gp == userG && readgstatus(userG) == _Grunning
            if selfScan {
                casGToWaitingForSuspendG(userG, _Grunning, waitReasonGarbageCollectionScan)
            }
            
            // 暂停 goroutine 并扫描其栈
            stopped := suspendG(gp)
            if stopped.dead {
                gp.gcscandone = true
                return
            }
            if gp.gcscandone {
                throw("g already scanned")
            }
            
            workDone += scanstack(gp, gcw)  // 扫描栈！
            gp.gcscandone = true
            resumeG(stopped)  // 恢复 goroutine
            
            if selfScan {
                casgstatus(userG, _Gwaiting, _Grunning)
            }
        })
    }
    
    // 更新工作统计和信用
    if workCounter != nil && workDone != 0 {
        workCounter.Add(workDone)
        if flushBgCredit {
            gcFlushBgCredit(workDone)  // 产生 assist 信用
        }
    }
    return workDone
}

// scanobject 扫描地址 b 处的对象，将其变黑，并将引用的对象变灰
func scanobject(b uintptr, gcw *gcWork) {
    // 预取对象，提高缓存命中率
    sys.Prefetch(b)
    
    // === 1. 获取对象信息 ===
    s := spanOfUnchecked(b)  // 获取对象所在的 span
    n := s.elemsize           // 对象大小
    
    if n == 0 {
        throw("scanobject n == 0")
    }
    if s.spanclass.noscan() {
        throw("scanobject of a noscan object")  // noscan 对象不应该到这
    }
    
    // === 2. 处理大对象：拆分成 oblets ===
    var tp typePointers  // 类型指针迭代器
    if n > maxObletBytes {  // 对象 > 128KB
        // 大对象拆分成多个 128KB 的 oblet，提高并行性和降低延迟
        if b == s.base() {
            // 只在第一次遇到对象时，将其他 oblet 入队
            for oblet := b + maxObletBytes; oblet < s.base()+s.elemsize; oblet += maxObletBytes {
                if !gcw.putObjFast(oblet) {
                    gcw.putObj(oblet)  // 将 oblet 加入工作队列
                }
            }
        }
        
        // 计算当前 oblet 的大小
        n = s.base() + s.elemsize - b
        n = min(n, maxObletBytes)
        tp = s.typePointersOfUnchecked(s.base())
        tp = tp.fastForward(b-tp.addr, b+n)  // 跳到当前 oblet
    } else {
        // 小对象，直接获取类型指针
        tp = s.typePointersOfUnchecked(b)
    }
    
    // === 3. 遍历对象中的所有指针 ===
    var scanSize uintptr
    for {
        var addr uintptr
        // 快速路径：尝试快速获取下一个指针
        if tp, addr = tp.nextFast(); addr == 0 {
            // 慢速路径：需要更多处理
            if tp, addr = tp.next(b + n); addr == 0 {
                break  // 没有更多指针了
            }
        }
        
        // 跟踪扫描进度（用于统计）
        scanSize = addr - b + goarch.PtrSize
        
        // === 4. 读取指针值 ===
        obj := *(*uintptr)(unsafe.Pointer(addr))
        
        // === 5. 快速过滤 ===
        // 过滤 nil 和指向当前对象内部的指针
        if obj != 0 && obj-b >= n {
            // === 6. 标记被引用的对象 ===
            if !tryDeferToSpanScan(obj, gcw) {
                // 查找对象
                if obj, span, objIndex := findObject(obj, b, addr-b); obj != 0 {
                    // 将对象标记为灰色（核心！）
                    greyobject(obj, b, addr-b, span, gcw, objIndex)
                }
            }
        }
    }
    
    // === 7. 统计 ===
    gcw.bytesMarked += uint64(n)     // 标记的字节数
    gcw.heapScanWork += int64(scanSize)  // 扫描的字节数
    if debug.gctrace > 1 {
        gcw.stats[s.spanclass.sizeclass()].sparseObjsScanned++
    }
}

// greyobject 将对象 obj 标记为灰色
// obj: 对象地址
// base, off: 用于调试，指示从哪里发现的这个引用
// span: 对象所在的 span
// gcw: 工作队列
// objIndex: 对象在 span 中的索引
func greyobject(obj, base, off uintptr, span *mspan, gcw *gcWork, objIndex uintptr) {
    // === 1. 对齐检查 ===
    if obj&(goarch.PtrSize-1) != 0 {
        throw("greyobject: obj not pointer-aligned")
    }
    
    // === 2. 获取标记位 ===
    mbits := span.markBitsForIndex(objIndex)
    
    if useCheckmark {
        // 调试模式：checkmark
        if setCheckmark(obj, base, off, mbits) {
            return  // 已标记
        }
        if debug.checkfinalizers > 1 {
            print("  mark ", hex(obj), " found at *(", hex(base), "+", hex(off), ")\n")
        }
    } else {
        // === 3. 检查是否已标记 ===
        if mbits.isMarked() {
            return  // 已经是灰色或黑色，跳过
        }
        
        // === 4. 设置标记位（白→灰）===
        mbits.setMarked()
        
        // === 5. 标记 span 的页位图 ===
        // 用于快速判断某页是否有存活对象
        arena, pageIdx, pageMask := pageIndexOf(span.base())
        if arena.pageMarks[pageIdx]&pageMask == 0 {
            atomic.Or8(&arena.pageMarks[pageIdx], pageMask)
        }
    }
    
    // === 6. noscan 对象快速路径 ===
    // noscan 对象（如 []byte）没有指针，直接变黑，不需要扫描
    if span.spanclass.noscan() {
        gcw.bytesMarked += uint64(span.elemsize)
        return  // 不入队，直接完成
    }
    
    // === 7. 预取对象 ===
    // 对象即将被扫描，预取到 CPU 缓存
    sys.Prefetch(obj)
    
    // === 8. 将对象加入工作队列（灰色队列）===
    // 对象现在是灰色的，等待被扫描（变黑）
    if !gcw.putObjFast(obj) {
        gcw.putObj(obj)  // 快速路径失败，使用慢速路径
    }
}

func gcMarkDone() {
	semacquire(&work.markDoneSema)
	
top:
	// 检查终止条件：
	// 1. 当前处于标记阶段
	// 2. 所有worker都在等待 (nwait == nproc)
	// 3. 没有可用的标记工作
	if !(gcphase == _GCmark && work.nwait == work.nproc && !gcMarkWorkAvailable(nil)) {
		semrelease(&work.markDoneSema)
		return
	}
	
	semacquire(&worldsema)
	
	// 阻止weak->strong转换产生额外的GC工作
	work.strongFromWeak.block = true
	
	// === Ragged Barrier ===
	// 刷新所有P的本地缓冲区
	gcMarkDoneFlushed = 0
	forEachP(waitReasonGCMarkTermination, func(pp *p) {
		// 刷新写屏障缓冲
		wbBufFlush1(pp)
		
		// 刷新gcWork缓冲
		pp.gcw.dispose()
		
		// 收集flushedWork标志
		if pp.gcw.flushedWork {
			atomic.Xadd(&gcMarkDoneFlushed, 1)
			pp.gcw.flushedWork = false
		}
	})
	
	// 如果发现新的灰色对象，重新开始检测
	if gcMarkDoneFlushed != 0 {
		semrelease(&worldsema)
		goto top
	}
	
	// === 标记终止 (STW) ===
	now := nanotime()
	work.tMarkTerm = now
	getg().m.preemptoff = "gcing"
	systemstack(func() {
		stw = stopTheWorldWithSema(stwGCMarkTerm)
	})
	
	// 处理ragged barrier后的写屏障产生的工作
	restart := false
	systemstack(func() {
		for _, p := range allp {
			wbBufFlush1(p)
			if !p.gcw.empty() {
				restart = true
				break
			}
		}
	})
	
	// 如果又发现新工作，重启并发标记
	if restart {
		getg().m.preemptoff = ""
		systemstack(func() {
			now := startTheWorldWithSema(0, stw)
			work.pauseNS += now - stw.startedStopping
		})
		semrelease(&worldsema)
		goto top
	}
	
	// 禁用标记和assists
	atomic.Store(&gcBlackenEnabled, 0)
	gcWakeAllAssists()
	
	// 结束周期，计算下次GC触发点
	gcController.endCycle(now, int(gomaxprocs), work.userForced)
	
	// 执行标记终止
	gcMarkTermination(stw)
}

// 返回 bool：true = 同步扫描完成，false = 后台并发扫描
func gcSweep(mode gcMode) bool {
  // 必须在世界停止（STW）时调用
	assertWorldStopped()
	
  // GC 阶段必须已经切换到 _GCoff（标记已完成）
	if gcphase != _GCoff {
		throw("gcSweep being done but phase is not GCoff")
	}
	
	// 准备扫描状态
	lock(&mheap_.lock)
	mheap_.sweepgen += 2  // 代数递增 2，后面解释
	sweep.active.reset()
	mheap_.pagesSwept.Store(0)
	mheap_.sweepArenas = mheap_.heapArenas // 记录要扫描的 arenas
	mheap_.reclaimIndex.Store(0)
	mheap_.reclaimCredit.Store(0)
	unlock(&mheap_.lock)
	
	sweep.centralIndex.clear()  // 清空中心索引
	
	// 特殊情况：同步扫描
	if !concurrentSweep || mode == gcForceBlockMode {
		lock(&mheap_.lock)
		mheap_.sweepPagesPerByte = 0
		unlock(&mheap_.lock)
		
		// 刷新所有mcache
		for _, pp := range allp {
			pp.mcache.prepareForSweep()
		}
		
		// 立即扫描所有span
		for sweepone() != ^uintptr(0) {
		}
		
		// 释放工作缓冲区
		prepareFreeWorkbufs()
		for freeSomeWbufs(false) {
		}
		
		mProf_NextCycle()
		mProf_Flush()
		return true
	}
	
	// 后台并发扫描
	lock(&sweep.lock)
	if sweep.parked {
		sweep.parked = false
		ready(sweep.g, 0, true)  // 唤醒后台扫描 goroutine
	}
	unlock(&sweep.lock)
	return false
}

func sweepone() uintptr {
	gp := getg()
	gp.m.locks++  // 防止抢占
	
	// 1. 获取扫描锁
	sl := sweep.active.begin()
	if !sl.valid {
		gp.m.locks--
		return ^uintptr(0)  // 没有工作
	}
	
	// 2. 查找要扫描的 span
	npages := ^uintptr(0)
	var noMoreWork bool
	for {
		s := mheap_.nextSpanForSweep()
		if s == nil {
			noMoreWork = sweep.active.markDrained()
			break
		}
		
		// 检查 span 状态
		if state := s.state.get(); state != mSpanInUse {
			continue  // 跳过非使用中的 span
		}
		
		// 3. 尝试获取 span 的扫描所有权，tryAcquire 里面就用到了 sweepgen
		if s, ok := sl.tryAcquire(s); ok {
			npages = s.npages
			
			// 4. 执行扫描
			if s.sweep(false) {
				// 整个 span 被释放，计入回收积分
				mheap_.reclaimCredit.Add(npages)
			} else {
				// span 仍在使用，返回 0 页
				npages = 0
			}
			break
		}
	}
	
	sweep.active.end(sl)
	
	// 5. 如果没有更多工作，唤醒清道夫
	if noMoreWork {
		scavenger.ready()
	}
	
	gp.m.locks--
	return npages
}

// sweep 回收未标记的对象，准备 span 给下次分配使用
// 返回 true 表示 span 已归还堆
func (sl *sweepLocked) sweep(preserve bool) bool {
    s := sl.mspan
    sweepgen := mheap_.sweepgen
    
    // ==================== 1. 验证状态 ====================
    // 确保 span 正在使用且处于扫描中状态 (sweepgen-1)
    if state := s.state.get(); state != mSpanInUse || s.sweepgen != sweepgen-1 {
        throw("mspan.sweep: bad span state")
    }
    
    // ==================== 2. 处理 Specials ====================
    // 处理 finalizers、弱引用等特殊记录
    hadSpecials := s.specials != nil
    siter := newSpecialsIter(s)
    for siter.valid() {
        objIndex := uintptr(siter.s.offset) / size
        p := s.base() + objIndex*size
        mbits := s.markBitsForIndex(objIndex)
        
        if !mbits.isMarked() {
            // 对象未标记（将被回收）
            hasFinAndRevived := false
            
            // Pass 1: 检查是否有 finalizer
            for tmp := siter.s; tmp != nil && uintptr(tmp.offset) < endOffset; tmp = tmp.next {
                if tmp.kind == _KindSpecialFinalizer {
                    // 有 finalizer：复活对象！
                    mbits.setMarkedNonAtomic()  // 重新标记为存活
                    hasFinAndRevived = true
                    break
                }
            }
            
            if hasFinAndRevived {
                // Pass 2: 将 finalizer 加入执行队列，清除弱引用
                for siter.valid() && uintptr(siter.s.offset) < endOffset {
                    special := siter.s
                    p := s.base() + uintptr(special.offset)
                    if special.kind == _KindSpecialFinalizer || special.kind == _KindSpecialWeakHandle {
                        siter.unlinkAndNext()
                        freeSpecial(special, unsafe.Pointer(p), size)
                    } else {
                        siter.next()
                    }
                }
            } else {
                // Pass 2: 对象真的死了，释放所有 specials
                for siter.valid() && uintptr(siter.s.offset) < endOffset {
                    special := siter.s
                    p := s.base() + uintptr(special.offset)
                    siter.unlinkAndNext()
                    freeSpecial(special, unsafe.Pointer(p), size)
                }
            }
        } else {
            // 对象存活，保留 specials
            if siter.s.kind == _KindSpecialReachable {
                special := siter.unlinkAndNext()
                (*specialReachable)(unsafe.Pointer(special)).reachable = true
                freeSpecial(special, unsafe.Pointer(p), size)
            } else {
                siter.next()
            }
        }
    }
    
    // ==================== 3. 检查僵尸对象 ====================
    // 僵尸对象 = 被标记但未分配（理论上不应存在）
    if s.freeindex < s.nelems {
        obj := uintptr(s.freeindex)
        // 检查：gcmarkBits 为 1 且 allocBits 为 0
        if (*s.gcmarkBits.bytep(obj/8) &^ *s.allocBits.bytep(obj/8))>>(obj%8) != 0 {
            s.reportZombies()  // 报告错误
        }
        for i := obj/8 + 1; i < divRoundUp(uintptr(s.nelems), 8); i++ {
            if *s.gcmarkBits.bytep(i) &^ *s.allocBits.bytep(i) != 0 {
                s.reportZombies()
            }
        }
    }
  
    // ==================== 4. 【核心】位图交换 ====================
    // gcmarkBits 变成 allocBits（标记结果变成分配状态）
    s.allocBits = s.gcmarkBits
    // 获取新的空白 gcmarkBits，为下次 GC 准备
    s.gcmarkBits = newMarkBits(uintptr(s.nelems))
    
    // 刷新 pinnerBits（如果存在）
    if s.pinnerBits != nil {
        s.refreshPinnerBits()
    }
    
    // 初始化分配位缓存
    s.refillAllocCache(0)
    
    // ==================== 5. 更新 sweepgen ====================
    // 原子更新：sweepgen-1 → sweepgen（标记为已扫描）
    atomic.Store(&s.sweepgen, sweepgen)
    
    // ==================== 6. 归类 span ====================
    if spc.sizeclass() != 0 {
        // 小对象 span
        if nfreed > 0 {
            s.needzero = 1  // 标记需要清零
            // 更新统计信息
            gcController.totalFree.Add(int64(nfreed) * int64(s.elemsize))
        }
        
        if !preserve {
            if nalloc == 0 {
                // 完全空闲：直接归还给堆
                mheap_.freeSpan(s)
                return true
            }
            if nalloc == s.nelems {
                // 完全占满：放入 fullSwept 列表
                mheap_.central[spc].mcentral.fullSwept(sweepgen).push(s)
            } else {
                // 部分占用：放入 partialSwept 列表
                mheap_.central[spc].mcentral.partialSwept(sweepgen).push(s)
            }
        }
    } else if !preserve {
        // 大对象 span
        if nfreed != 0 {
            // 释放大对象到堆
            gcController.totalFree.Add(int64(size))
            mheap_.freeSpan(s)
            return true
        }
        // 添加到 fullSwept 列表
        mheap_.central[spc].mcentral.fullSwept(sweepgen).push(s)
    }
    
    return false
}

// 在 gcController.endCycle 中计算
// 基本公式：
// heapGoal = heapMarked * (1 + GOGC/100)
// trigger = heapGoal - runway

// 其中：
// - heapMarked: 标记阶段存活的堆大小
// - GOGC: 环境变量，默认100
// - runway: 给 GC 留出的缓冲空间，让它能在 heapGoal 前完成标记

// ❌ 避免：频繁小对象分配
for i := 0; i < n; i++ {
    s := fmt.Sprintf("%d", i)  // 每次分配
}

// ✅ 优化：复用 buffer
var buf bytes.Buffer
for i := 0; i < n; i++ {
    buf.Reset()
    fmt.Fprintf(&buf, "%d", i)
}

var bufPool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

// 使用
buf := bufPool.Get().(*bytes.Buffer)
defer bufPool.Put(buf)
buf.Reset()

// ❌ 避免：动态扩容
var s []int
for i := 0; i < 10000; i++ {
    s = append(s, i)  // 多次扩容
}

// ✅ 优化：预分配
s := make([]int, 0, 10000)
for i := 0; i < 10000; i++ {
    s = append(s, i)
}

// ❌ 避免：大量指针
type Node struct {
    Value *int
    Next  *Node
}

// ✅ 优化：值类型
type Node struct {
    Value int
    Next  *Node  // 只保留必要指针
}

// ❌ 逃逸到堆
func bad() *int {
    x := 42
    return &x  // 逃逸
}

// ✅ 栈分配
func good() int {
    x := 42
    return x  // 栈上
}

package main

import (
	"net/http"
	"sync"
  
  _ "net/http/pprof"		// pprof 需要
)

func main() {

	go func() {
		wg := sync.WaitGroup{}
		wg.Add(10)
		for i := 0; i < 10; i++ {
			go func(wg *sync.WaitGroup) {
				var counter int
				for i := 0; i < 1e10; i++ {
					counter++
				}
				wg.Done()
			}(&wg)
		}
		wg.Wait()
	}()

	_ = http.ListenAndServe(":8080", nil)
}