for {
    // Go to sleep until woken by gcController.findRunnable.
    // We can't releasem yet since even the call to gopark
    // may be preempted.
    // 让g进入休眠
    gopark(func(g *g, parkp unsafe.Pointer) bool {
        park := (*parkInfo)(parkp)

        // The worker G is no longer running, so it's
        // now safe to allow preemption.
        // 释放当前抢占的m
        releasem(park.m.ptr())

        // If the worker isn't attached to its P,
        // attach now. During initialization and after
        // a phase change, the worker may have been
        // running on a different P. As soon as we
        // attach, the owner P may schedule the
        // worker, so this must be done after the G is
        // stopped.
        // 设置关联p，上面已经设置过了
        if park.attach != 0 {
            p := park.attach.ptr()
            park.attach.set(nil)
            // cas the worker because we may be
            // racing with a new worker starting
            // on this P.
            if !p.gcBgMarkWorker.cas(0, guintptr(unsafe.Pointer(g))) {
                // The P got a new worker.
                // Exit this worker.
                return false
            }
        }
        return true
    }, unsafe.Pointer(park), waitReasonGCWorkerIdle, traceEvGoBlock, 0)

    // Loop until the P dies and disassociates this
    // worker (the P may later be reused, in which case
    // it will get a new worker) or we failed to associate.
    // 检查P的gcBgMarkWorker是否和当前的G一致, 不一致时结束当前的任务
    if _p_.gcBgMarkWorker.ptr() != gp {
        break
    }

    // Disable preemption so we can use the gcw. If the
    // scheduler wants to preempt us, we'll stop draining,
    // dispose the gcw, and then preempt.
    // gopark第一个函数中释放了m，这里再抢占回来
    park.m.set(acquirem())

    if gcBlackenEnabled == 0 {
        throw("gcBgMarkWorker: blackening not enabled")
    }

    startTime := nanotime()
    // 设置gcmark的开始时间
    _p_.gcMarkWorkerStartTime = startTime

    decnwait := atomic.Xadd(&work.nwait, -1)
    if decnwait == work.nproc {
        println("runtime: work.nwait=", decnwait, "work.nproc=", work.nproc)
        throw("work.nwait was > work.nproc")
    }
    // 切换到g0工作
    systemstack(func() {
        // Mark our goroutine preemptible so its stack
        // can be scanned. This lets two mark workers
        // scan each other (otherwise, they would
        // deadlock). We must not modify anything on
        // the G stack. However, stack shrinking is
        // disabled for mark workers, so it is safe to
        // read from the G stack.
        // 设置G的状态为waiting，以便于另一个g扫描它的栈(两个g可以互相扫描对方的栈)
        casgstatus(gp, _Grunning, _Gwaiting)
        switch _p_.gcMarkWorkerMode {
        default:
            throw("gcBgMarkWorker: unexpected gcMarkWorkerMode")
        case gcMarkWorkerDedicatedMode:
            // 专心执行标记工作的模式
            gcDrain(&_p_.gcw, gcDrainUntilPreempt|gcDrainFlushBgCredit)
            if gp.preempt {
                // 被抢占了，把所有本地运行队列中的G放到全局运行队列中
                // We were preempted. This is
                // a useful signal to kick
                // everything out of the run
                // queue so it can run
                // somewhere else.
                lock(&sched.lock)
                for {
                    gp, _ := runqget(_p_)
                    if gp == nil {
                        break
                    }
                    globrunqput(gp)
                }
                unlock(&sched.lock)
            }
            // Go back to draining, this time
            // without preemption.
            // 继续执行标记工作
            gcDrain(&_p_.gcw, gcDrainNoBlock|gcDrainFlushBgCredit)
        case gcMarkWorkerFractionalMode:
            // 执行标记工作，知道被抢占
            gcDrain(&_p_.gcw, gcDrainFractional|gcDrainUntilPreempt|gcDrainFlushBgCredit)
        case gcMarkWorkerIdleMode:
            // 空闲的时候执行标记工作
            gcDrain(&_p_.gcw, gcDrainIdle|gcDrainUntilPreempt|gcDrainFlushBgCredit)
        }
        // 把G的waiting状态转换到runing状态
        casgstatus(gp, _Gwaiting, _Grunning)
    })

    // If we are nearing the end of mark, dispose
    // of the cache promptly. We must do this
    // before signaling that we're no longer
    // working so that other workers can't observe
    // no workers and no work while we have this
    // cached, and before we compute done.
    // 及时处理本地缓存，上交到全局的队列中
    if gcBlackenPromptly {
        _p_.gcw.dispose()
    }

    // Account for time.
    // 累加耗时
    duration := nanotime() - startTime
    switch _p_.gcMarkWorkerMode {
    case gcMarkWorkerDedicatedMode:
        atomic.Xaddint64(&gcController.dedicatedMarkTime, duration)
        atomic.Xaddint64(&gcController.dedicatedMarkWorkersNeeded, 1)
    case gcMarkWorkerFractionalMode:
        atomic.Xaddint64(&gcController.fractionalMarkTime, duration)
        atomic.Xaddint64(&_p_.gcFractionalMarkTime, duration)
    case gcMarkWorkerIdleMode:
        atomic.Xaddint64(&gcController.idleMarkTime, duration)
    }

    // Was this the last worker and did we run out
    // of work?
    incnwait := atomic.Xadd(&work.nwait, +1)
    if incnwait > work.nproc {
        println("runtime: p.gcMarkWorkerMode=", _p_.gcMarkWorkerMode,
            "work.nwait=", incnwait, "work.nproc=", work.nproc)
        throw("work.nwait > work.nproc")
    }

    // If this worker reached a background mark completion
    // point, signal the main GC goroutine.
    if incnwait == work.nproc && !gcMarkWorkAvailable(nil) {
        // Make this G preemptible and disassociate it
        // as the worker for this P so
        // findRunnableGCWorker doesn't try to
        // schedule it.
        // 取消p m的关联
        _p_.gcBgMarkWorker.set(nil)
        releasem(park.m.ptr())

        gcMarkDone()

        // Disable preemption and prepare to reattach
        // to the P.
        //
        // We may be running on a different P at this
        // point, so we can't reattach until this G is
        // parked.
        park.m.set(acquirem())
        park.attach.set(_p_)
    }
}

}
gcDrain
三色标记的主要实现

gcDrain扫描所有的roots和对象，并表黑灰色对象，知道所有的roots和对象都被标记

func gcDrain(gcw *gcWork, flags gcDrainFlags) {
if !writeBarrier.needed {
throw(“gcDrain phase incorrect”)
}

gp := getg().m.curg
// 看到抢占标识是否要返回
preemptible := flags&gcDrainUntilPreempt != 0
// 没有任务时是否要等待任务
blocking := flags&(gcDrainUntilPreempt|gcDrainIdle|gcDrainFractional|gcDrainNoBlock) == 0
// 是否计算后台的扫描量来减少辅助GC和唤醒等待中的G
flushBgCredit := flags&gcDrainFlushBgCredit != 0
// 是否在空闲的时候执行标记任务
idle := flags&gcDrainIdle != 0
// 记录初始的已经执行过的扫描任务
initScanWork := gcw.scanWork

// checkWork is the scan work before performing the next
// self-preempt check.
// 设置对应模式的工作检查函数
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
    }
}

// Drain root marking jobs.
// 如果root对象没有扫描完，则扫描
if work.markrootNext < work.markrootJobs {
    for !(preemptible && gp.preempt) {
        job := atomic.Xadd(&work.markrootNext, +1) - 1
        if job >= work.markrootJobs {
            break
        }
        // 执行root扫描任务
        markroot(gcw, job)
        if check != nil && check() {
            goto done
        }
    }
}

// Drain heap marking jobs.
// 循环直到被抢占
for !(preemptible && gp.preempt) {
    // Try to keep work available on the global queue. We used to
    // check if there were waiting workers, but it's better to
    // just keep work available than to make workers wait. In the
    // worst case, we'll do O(log(_WorkbufSize)) unnecessary
    // balances.
    if work.full == 0 {
        // 平衡工作，如果全局的标记队列为空，则分一部分工作到全局队列中
        gcw.balance()
    }

    var b uintptr
    if blocking {
        b = gcw.get()
    } else {
        b = gcw.tryGetFast()
        if b == 0 {
            b = gcw.tryGet()
        }
    }
    // 获取任务失败，跳出循环
    if b == 0 {
        // work barrier reached or tryGet failed.
        break
    }
    // 扫描获取的到对象
    scanobject(b, gcw)

    // Flush background scan work credit to the global
    // account if we've accumulated enough locally so
    // mutator assists can draw on it.
    // 如果当前扫描的数量超过了 gcCreditSlack，就把扫描的对象数量加到全局的数量，批量更新
    if gcw.scanWork >= gcCreditSlack {
        atomic.Xaddint64(&gcController.scanWork, gcw.scanWork)
        if flushBgCredit {
            gcFlushBgCredit(gcw.scanWork - initScanWork)
            initScanWork = 0
        }
        checkWork -= gcw.scanWork
        gcw.scanWork = 0
        // 如果扫描的对象数量已经达到了 执行下次抢占的目标数量 checkWork， 则调用对应模式的函数
        // idle模式为 pollWork， Fractional模式为 pollFractionalWorkerExit ，在第20行
        if checkWork <= 0 {
            checkWork += drainCheckThreshold
            if check != nil && check() {
                break
            }
        }
    }
}

// In blocking mode, write barriers are not allowed after this
// point because we must preserve the condition that the work
// buffers are empty.

// Note: if you add a case here, please also update heapdump.go:dumproots.
switch {
// 释放mcache中的span
case baseFlushCache <= i && i < baseData:
    flushmcache(int(i - baseFlushCache))
// 扫描可读写的全局变量
case baseData <= i && i < baseBSS:
    for _, datap := range activeModules() {
        markrootBlock(datap.data, datap.edata-datap.data, datap.gcdatamask.bytedata, gcw, int(i-baseData))
    }
// 扫描只读的全局队列
case baseBSS <= i && i < baseSpans:
    for _, datap := range activeModules() {
        markrootBlock(datap.bss, datap.ebss-datap.bss, datap.gcbssmask.bytedata, gcw, int(i-baseBSS))
    }
// 扫描Finalizer队列
case i == fixedRootFinalizers:
    // Only do this once per GC cycle since we don't call
    // queuefinalizer during marking.
    if work.markrootDone {
        break
    }
    for fb := allfin; fb != nil; fb = fb.alllink {
        cnt := uintptr(atomic.Load(&fb.cnt))
        scanblock(uintptr(unsafe.Pointer(&fb.fin[0])), cnt*unsafe.Sizeof(fb.fin[0]), &finptrmask[0], gcw)
    }
// 释放已经终止的stack
case i == fixedRootFreeGStacks:
    // Only do this once per GC cycle; preferably
    // concurrently.
    if !work.markrootDone {
        // Switch to the system stack so we can call
        // stackfree.
        systemstack(markrootFreeGStacks)
    }
// 扫描MSpan.specials
case baseSpans <= i && i < baseStacks:
    // mark MSpan.specials
    markrootSpans(gcw, int(i-baseSpans))

default:
    // the rest is scanning goroutine stacks
    // 获取需要扫描的g
    var gp *g
    if baseStacks <= i && i < end {
        gp = allgs[i-baseStacks]
    } else {
        throw("markroot: bad index")
    }

    // remember when we've first observed the G blocked
    // needed only to output in traceback
    status := readgstatus(gp) // We are not in a scan state
    if (status == _Gwaiting || status == _Gsyscall) && gp.waitsince == 0 {
        gp.waitsince = work.tstart
    }

    // scang must be done on the system stack in case
    // we're trying to scan our own stack.
    // 转交给g0进行扫描
    systemstack(func() {
        // If this is a self-scan, put the user G in
        // _Gwaiting to prevent self-deadlock. It may
        // already be in _Gwaiting if this is a mark
        // worker or we're in mark termination.
        userG := getg().m.curg
        selfScan := gp == userG && readgstatus(userG) == _Grunning
        // 如果是扫描自己的，则转换自己的g的状态
        if selfScan {
            casgstatus(userG, _Grunning, _Gwaiting)
            userG.waitreason = waitReasonGarbageCollectionScan
        }

        // TODO: scang blocks until gp's stack has
        // been scanned, which may take a while for
        // running goroutines. Consider doing this in
        // two phases where the first is non-blocking:
        // we scan the stacks we can and ask running
        // goroutines to scan themselves; and the
        // second blocks.
        // 扫描g的栈
        scang(gp, gcw)

        if selfScan {
            casgstatus(userG, _Gwaiting, _Grunning)
        }
    })
}

b := b0 + uintptr(shard)*rootBlockBytes
// 如果需扫描的block区域，超出b0+n0的区域，直接返回
if b >= b0+n0 {
    return
}
ptrmask := (*uint8)(add(unsafe.Pointer(ptrmask0), uintptr(shard)*(rootBlockBytes/(8*sys.PtrSize))))
n := uintptr(rootBlockBytes)
if b+n > b0+n0 {
    n = b0 + n0 - b
}

// Scan this shard.
// 扫描给定block的shard
scanblock(b, n, ptrmask, gcw)

for i := uintptr(0); i < n; {
    // Find bits for the next word.
    // 找到bitmap中对应的bits
    bits := uint32(*addb(ptrmask, i/(sys.PtrSize*8)))
    if bits == 0 {
        i += sys.PtrSize * 8
        continue
    }
    for j := 0; j < 8 && i < n; j++ {
        if bits&1 != 0 {
            // 如果该地址包含指针
            // Same work as in scanobject; see comments there.
            obj := *(*uintptr)(unsafe.Pointer(b + i))
            if obj != 0 {
                // 如果该地址下找到了对应的对象，标灰
                if obj, span, objIndex := findObject(obj, b, i); obj != 0 {
                    greyobject(obj, b, i, span, gcw, objIndex)
                }
            }
        }
        bits >>= 1
        i += sys.PtrSize
    }
}

if useCheckmark {
    // 这里是用来debug，确保所有的对象都被正确标识
    if !mbits.isMarked() {
        // 这个对象没有被标记
        printlock()
        print("runtime:greyobject: checkmarks finds unexpected unmarked object obj=", hex(obj), "\n")
        print("runtime: found obj at *(", hex(base), "+", hex(off), ")\n")

        // Dump the source (base) object
        gcDumpObject("base", base, off)

        // Dump the object
        gcDumpObject("obj", obj, ^uintptr(0))

        getg().m.traceback = 2
        throw("checkmark found unmarked object")
    }
    hbits := heapBitsForAddr(obj)
    if hbits.isCheckmarked(span.elemsize) {
        return
    }
    hbits.setCheckmarked(span.elemsize)
    if !hbits.isCheckmarked(span.elemsize) {
        throw("setCheckmarked and isCheckmarked disagree")
    }
} else {
    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 marked we have nothing to do.
    // 对象被正确标记了，无需做其他的操作
    if mbits.isMarked() {
        return
    }
    // mbits.setMarked() // Avoid extra call overhead with manual inlining.
    // 标记对象
    atomic.Or8(mbits.bytep, mbits.mask)
    // If this is a noscan object, fast-track it to black
    // instead of greying it.
    // 如果对象不是指针，则只需要标记，不需要放进队列，相当于直接标黑
    if span.spanclass.noscan() {
        gcw.bytesMarked += uint64(span.elemsize)
        return
    }
}

// Queue the obj for scanning. The PREFETCH(obj) logic has been removed but
// seems like a nice optimization that can be added back in.
// There needs to be time between the PREFETCH and the use.
// Previously we put the obj in an 8 element buffer that is drained at a rate
// to give the PREFETCH time to do its work.
// Use of PREFETCHNTA might be more appropriate than PREFETCH
// 判断对象是否被放进队列，没有则放入，标灰步骤完成
if !gcw.putFast(obj) {
    gcw.put(obj)
}