const (    
	// 根据堆分配内存情况，判断是否触发
	GC    gcTriggerHeap gcTriggerKind = iota    
	// 定时触发
	GC    gcTriggerTime    
	// 手动触发
	GC    gcTriggerCycle 
}	

func (t gcTrigger) test() bool {    
// ...    
	switch t.kind {    
	case gcTriggerHeap:        
		// ...        
		// 如果是堆内存分配导致的 GC，会 Check 当前堆内存的使用情况
		trigger, _ := gcController.trigger()        
		return atomic.Load64(&gcController.heapLive) >= trigger    
	case gcTriggerTime:        
		// 如果是守护协程 GC，则会check当前距离上一次 GC 是否已经达到 2 min
		if gcController.gcPercent.Load() < 0 {            
			return false        
		}        
		lastgc := int64(atomic.Load64(&memstats.last_gc_nanotime))        
		return lastgc != 0 && t.now-lastgc > forcegcperiod  
	case gcTriggerCycle:        
		// ...        
		// 如果是手动触发 GC，check 前一轮 GC 有没有结束
		return int32(t.n-work.cycles) > 0    
	}    
	return true
}

func findRunnable() (gp *g, inheritTime, tryWakeP bool) {
	// ...
top:
	// ...
	// 尝试获取一个并发标记协程
	if gcBlackenEnabled != 0 {
		gp, tnow := gcController.findRunnableGCWorker(pp, now)
		// 如果能找到 GC 相关的G，则返回对应的 G
		if gp != nil {
			return gp, false, true
		}
		now = tnow
	}

		// 周期性检查全局队列，防止全局队列饥饿
		// 也就是说每 61 次，就会发生一次全局 G 的调用
	if pp.schedtick%61 == 0 && sched.runqsize > 0 {
		lock(&sched.lock)
		gp := globrunqget()
		unlock(&sched.lock)
		if gp != nil {
			return gp, false, false
		}
	}
	
	// ...

	// 获取本地 P 队列中的 G
	if gp, inheritTime := runqget(pp); gp != nil {
		return gp, inheritTime, false
	}

	// 获取全局队列中的 G
	if sched.runqsize != 0 {
		lock(&sched.lock)
		gp, q, qsize := globrunqgetbatch(int32(len(pp.runq)) / 2)
		unlock(&sched.lock)
		if gp != nil {
			if runqputbatch(pp, &q, qsize); !q.empty() {
				throw("Couldn't put Gs into empty local runq")
			}
			return gp, false, false
		}
	}

	// 优先轮询 I/O 是否有就绪 goroutine。
	if netpollinited() && netpollAnyWaiters() && sched.lastpoll.Load() != 0 {
		if list, delta := netpoll(0); !list.empty() { // non-blocking
			gp := list.pop()
			injectglist(&list)
			netpollAdjustWaiters(delta)
			trace := traceAcquire()
			casgstatus(gp, _Gwaiting, _Grunnable)
			if trace.ok() {
				trace.GoUnpark(gp, 0)
				traceRelease(trace)
			}
			return gp, false, false
		}
	}

	// 从其他队列中获取 work stealing
	if mp.spinning || 2*sched.nmspinning.Load() < gomaxprocs-sched.npidle.Load() {
		if !mp.spinning {
			mp.becomeSpinning()
		}

		gp, inheritTime, tnow, w, newWork := stealWork(now)
		if gp != nil {
			// Successfully stole.
			return gp, inheritTime, false
		}
		if newWork {
			// There may be new timer or GC work; restart to
			// discover.
			goto top
		}

		now = tnow
		if w != 0 && (pollUntil == 0 || w < pollUntil) {
			// Earlier timer to wait for.
			pollUntil = w
		}
	}

	// ....
	
	// 如果上面的 case 都没有执行，代表此时可以释放 P，则再进行一次 double check 后，释放
	lock(&sched.lock)
	if sched.gcwaiting.Load() || pp.runSafePointFn != 0 {
		unlock(&sched.lock)
		goto top
	}
	// check 全局 G 中还有没有 G
	if sched.runqsize != 0 {
		gp, q, qsize := globrunqgetbatch(int32(len(pp.runq)) / 2)
		unlock(&sched.lock)
		if gp == nil {
			throw("global runq empty with non-zero runqsize")
		}
		if runqputbatch(pp, &q, qsize); !q.empty() {
			throw("Couldn't put Gs into empty local runq")
		}
		return gp, false, false
	}
	// 如果没有当前 M 会和 P work stealing，M 进入休眠（线程阻塞，等待唤醒而不是就绪哦）
	stopm()
	goto top
}

func gcBgMarkWorker(ready chan struct{}) {
	// ...
	for {
		// ...
		gopark(func(g *g, nodep unsafe.Pointer) bool {
			// ...
			casGToWaitingForGC(gp, _Grunning, waitReasonGCWorkerActive)
			switch pp.gcMarkWorkerMode {
			default:
				throw("gcBgMarkWorker: unexpected gcMarkWorkerMode")
			case gcMarkWorkerDedicatedMode:
				// ...
				// 全职
				gcDrainMarkWorkerDedicated(&pp.gcw, false)
			case gcMarkWorkerFractionalMode:
				// 分时复用
				gcDrainMarkWorkerFractional(&pp.gcw)
			case gcMarkWorkerIdleMode:
				// 空闲时标记
				gcDrainMarkWorkerIdle(&pp.gcw)
			}
			casgstatus(gp, _Gwaiting, _Grunning)
		})
}

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

	// ...

	// Root 对象标记
	if work.markrootNext < work.markrootJobs {
		// Stop if we're preemptible, if someone wants to STW, or if
		// someone is calling forEachP.
		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
			}
		}
	}
	
	// 循环扫描堆对象 直到退出或被抢占
	for !(gp.preempt && (preemptible || sched.gcwaiting.Load() || pp.runSafePointFn != 0)) {
		// ...
		scanobject(b, gcw)
		// ...
	}

done:
	// Flush remaining scan work credit.
	if gcw.heapScanWork > 0 {
		gcController.heapScanWork.Add(gcw.heapScanWork)
		if flushBgCredit {
			gcFlushBgCredit(gcw.heapScanWork - initScanWork)
		}
		gcw.heapScanWork = 0
	}
}

func greyobject(obj, base, off uintptr, span *mspan, gcw *gcWork, objIndex uintptr) {
	// obj should be start of allocation, and so must be at least pointer-aligned.
	if obj&(goarch.PtrSize-1) != 0 {
		throw("greyobject: obj not pointer-aligned")
	}
    // 获取 obj 对应的 mspan 对应的位图，用于查看 obj 是不是已经被标记了
	mbits := span.markBitsForIndex(objIndex)
    
    // 如果已经被标记过，则跳过
	if useCheckmark {
		if setCheckmark(obj, base, off, mbits) {
			// Already marked.
			return
		}
	} else {
        // 如果当前 GC 尝试标记一个未分配内存或者已经释放的对象，则报错
		if debug.gccheckmark > 0 && span.isFree(objIndex) {
			print("runtime: marking free object ", hex(obj), " found at *(", hex(base), "+", hex(off), ")\n")
			gcDumpObject("base", base, off)
			gcDumpObject("obj", obj, ^uintptr(0))
			getg().m.traceback = 2
			throw("marking free object")
		}

        // 如果还没被标记，则标记
		if mbits.isMarked() {
			return
		}
		mbits.setMarked()
        
        // 在对应的页上标记
		// Mark span.
		arena, pageIdx, pageMask := pageIndexOf(span.base())
		if arena.pageMarks[pageIdx]&pageMask == 0 {
			atomic.Or8(&arena.pageMarks[pageIdx], pageMask)
		}
	}
    
    // 如果是一个 noscan 对象，则直接染黑后返回
	if span.spanclass.noscan() {
		gcw.bytesMarked += uint64(span.elemsize)
		return
	}
	// ...
	sys.Prefetch(obj)
	// Queue the obj for scanning.
	if !gcw.putFast(obj) {
		gcw.put(obj)
	}
}