内存回收属于

// GC 阶段定义
const (
	_GCoff             = iota // GC not running; sweeping in background, write barrier disabled
	_GCmark                   // GC marking roots and workbufs: allocate black, write barrier ENABLED
	_GCmarktermination        // GC mark termination: allocate black, P's help GC, write barrier ENABLED
)

// 是垃圾收集器当前处于的阶段，可能处于 _GCoff、_GCmark 和 _GCmarktermination，Goroutine 在读取或者修改该阶段时需要保证原子性；
var gcphase uint32

// 布尔值，当垃圾收集处于标记阶段时，该变量会被置为 1，在这里辅助垃圾收集的用户程序和后台标记的任务可以将对象涂黑；
var gcBlackenEnabled uint32

//实现了垃圾收集的调步算法，它能够决定触发并行垃圾收集的时间和待处理的工作；
var gcController gcControllerState

// 触发垃圾收集的内存增长百分比，默认情况下为 100，即堆内存相比上次垃圾收集增长 100% 时应该触发 GC
// Initialized from $GOGC.  GOGC=off means no GC.
var gcpercent int32

// Holding worldsema grants an M the right to try to stop the world.
var worldsema uint32 = 1

// gcMode indicates how concurrent a GC cycle should be.
type gcMode int

const (
   gcBackgroundMode gcMode = iota // concurrent GC and sweep 并发模式
   gcForceMode                    // stop-the-world GC now, concurrent sweep
   gcForceBlockMode               // stop-the-world GC now and STW sweep (forced by user)
)

var gcController gcControllerState



// 会根据全局处理器的个数以及垃圾收集的 CPU 利用率计算出 dedicatedMarkWorkersNeeded 和 fractionalUtilizationGoal 以决定不同模式的工作协程的数量。
gcControllerState.startCycle()
gcControllerState.enlistWorker()

// 返回当前P所绑定的 后台 Mark Worker Goroutine（如果可运行），
// 根据当前运行状态及策略设置处理器的 gcMarkWorkerMode 工作模式，然后唤醒
gcControllerState.findRunnableGCWorker() 

type gcMarkWorkerMode int

const (
   gcMarkWorkerDedicatedMode gcMarkWorkerMode = iota   	// 全力模式
   gcMarkWorkerFractionalMode							// 部分模式
   gcMarkWorkerIdleMode									// 空闲模式
)

// The compiler knows about this variable.
// If you change it, you must change builtin/runtime.go, too.
// If you change the first four bytes, you must also change the write
// barrier insertion code.
var writeBarrier struct {
	enabled bool    // 写屏障的开启与关闭标记；
	pad     [3]byte // compiler uses 32-bit load for "enabled" field
	needed  bool    // whether we need a write barrier for current GC phase
	cgo     bool    // whether we need a write barrier for a cgo check
	alignme uint64  // guarantee alignment so that compiler can use a 32 or 64-bit load
}

//go:nowritebarrier
func gcDrain(gcw *gcWork, flags gcDrainFlags) {
	if !writeBarrier.needed {
		throw("gcDrain phase incorrect")
	}
    ...
}

var work struct {
   full  lfstack          // lock-free list of full blocks workbuf
   empty lfstack          // lock-free list of empty blocks workbuf
   pad0  cpu.CacheLinePad // prevents false-sharing between full/empty and nproc/nwait

   wbufSpans struct {
      lock mutex
      // free is a list of spans dedicated to workbufs, but
      // that don't currently contain any workbufs.
      free mSpanList
      // busy is a list of all spans containing workbufs on
      // one of the workbuf lists.
      busy mSpanList
   }

   // Restore 64-bit alignment on 32-bit.
   _ uint32

   // bytesMarked is the number of bytes marked this cycle. This
   // includes bytes blackened in scanned objects, noscan objects
   // that go straight to black, and permagrey objects scanned by
   // markroot during the concurrent scan phase. This is updated
   // atomically during the cycle. Updates may be batched
   // arbitrarily, since the value is only read at the end of the
   // cycle.
   //
   // Because of benign races during marking, this number may not
   // be the exact number of marked bytes, but it should be very
   // close.
   //
   // Put this field here because it needs 64-bit atomic access
   // (and thus 8-byte alignment even on 32-bit architectures).
   bytesMarked uint64

   markrootNext uint32 // next markroot job
   markrootJobs uint32 // number of markroot jobs

   nproc  uint32
   tstart int64
   nwait  uint32
   ndone  uint32

   // Number of roots of various root types. Set by gcMarkRootPrepare.
   nFlushCacheRoots                               int
   nDataRoots, nBSSRoots, nSpanRoots, nStackRoots int

   // Each type of GC state transition is protected by a lock.
   // Since multiple threads can simultaneously detect the state
   // transition condition, any thread that detects a transition
   // condition must acquire the appropriate transition lock,
   // re-check the transition condition and return if it no
   // longer holds or perform the transition if it does.
   // Likewise, any transition must invalidate the transition
   // condition before releasing the lock. This ensures that each
   // transition is performed by exactly one thread and threads
   // that need the transition to happen block until it has
   // happened.
   //
   // startSema protects the transition from "off" to mark or
   // mark termination.
   startSema uint32
   // markDoneSema protects transitions from mark to mark termination.
   markDoneSema uint32

   bgMarkReady note   // signal background mark worker has started
   bgMarkDone  uint32 // cas to 1 when at a background mark completion point
   // Background mark completion signaling

   // mode is the concurrency mode of the current GC cycle.
   mode gcMode

   // userForced indicates the current GC cycle was forced by an
   // explicit user call.
   userForced bool

   // totaltime is the CPU nanoseconds spent in GC since the
   // program started if debug.gctrace > 0.
   totaltime int64

   // initialHeapLive is the value of memstats.heap_live at the
   // beginning of this GC cycle.
   initialHeapLive uint64

   // assistQueue is a queue of assists that are blocked because
   // there was neither enough credit to steal or enough work to
   // do.
   assistQueue struct {
      lock mutex
      q    gQueue
   }

   // sweepWaiters is a list of blocked goroutines to wake when
   // we transition from mark termination to sweep.
   sweepWaiters struct {
      lock mutex
      list gList
   }

   // cycles is the number of completed GC cycles, where a GC
   // cycle is sweep termination, mark, mark termination, and
   // sweep. This differs from memstats.numgc, which is
   // incremented at mark termination.
   cycles uint32

   // Timing/utilization stats for this cycle.
   stwprocs, maxprocs                 int32
   tSweepTerm, tMark, tMarkTerm, tEnd int64 // nanotime() of phase start

   pauseNS    int64 // total STW time this cycle
   pauseStart int64 // nanotime() of last STW

   // debug.gctrace heap sizes for this cycle.
   heap0, heap1, heap2, heapGoal uint64
}

// A gcTrigger is a predicate for starting a GC cycle. Specifically,
// it is an exit condition for the _GCoff phase.
type gcTrigger struct {
   kind gcTriggerKind
   now  int64  // gcTriggerTime: current time
   n    uint32 // gcTriggerCycle: cycle number to start
}

// test reports whether the trigger condition is satisfied, meaning
// that the exit condition for the _GCoff phase has been met. The exit
// condition should be tested when allocating.
func (t gcTrigger) test() bool {
	if !memstats.enablegc || panicking != 0 || gcphase != _GCoff {
		return false
	}
	switch t.kind {
	case gcTriggerHeap: 
		return memstats.heap_live >= memstats.gc_trigger
	case gcTriggerTime:
		if gcpercent < 0 {
			return false
		}
		lastgc := int64(atomic.Load64(&memstats.last_gc_nanotime))
		return lastgc != 0 && t.now-lastgc > forcegcperiod
	case gcTriggerCycle:
		// t.n > work.cycles, but accounting for wraparound.
		return int32(t.n-work.cycles) > 0
	}
	return true
}