writePointer(slot, ptr):  
    shade(*slot)  
    if any stack is grey:  
        shade(ptr)  
    *slot = ptr 
1.
2.
3.
4.
5.

[go] b = obj  
[go] oldx = nil  
[gc] scan oldx...  
[go] oldx = b.x // 复制b.x到本地变量, 不进过写屏障  
[go] b.x = ptr // 写屏障应该标记b.x的原值  
[gc] scan b...  
如果写屏障不标记原值, 那么oldx就不会被扫描到. 
1.
2.
3.
4.
5.
6.
7.

[go] a = ptr  
[go] b = obj  
[gc] scan b...  
[go] b.x = a // 写屏障应该标记b.x的新值  
[go] a = nil  
[gc] scan a...  
如果写屏障不标记新值, 那么ptr就不会被扫描到. 
1.
2.
3.
4.
5.
6.
7.

func gcStart(mode gcMode, trigger gcTrigger) {  
    // Since this is called from malloc and malloc is called in  
    // the guts of a number of libraries that might be holding  
    // locks, don't attempt to start GC in non-preemptible or  
    // potentially unstable situations.  
    // 判断当前g是否可以抢占，不可抢占时不触发GC  
    mp := acquirem()  
    if gp := getg(); gp == mp.g0 || mp.locks > 1 || mp.preemptoff != "" {  
        releasem(mp)  
        return  
    }  
    releasem(mp)  
    mp = nil  
    // Pick up the remaining unswept/not being swept spans concurrently  
    //  
    // This shouldn't happen if we're being invoked in background  
    // mode since proportional sweep should have just finished  
    // sweeping everything, but rounding errors, etc, may leave a  
    // few spans unswept. In forced mode, this is necessary since  
    // GC can be forced at any point in the sweeping cycle.  
    //  
    // We check the transition condition continuously here in case  
    // this G gets delayed in to the next GC cycle.  
    // 清扫 残留的未清扫的垃圾  
    for trigger.test() && gosweepone() != ^uintptr(0) {  
        sweep.nbgsweep++  
    }  
    // Perform GC initialization and the sweep termination  
    // transition.  
    semacquire(&work.startSema)  
    // Re-check transition condition under transition lock.  
    // 判断gcTrriger的条件是否成立  
    if !trigger.test() {  
        semrelease(&work.startSema)  
        return  
    }  
    // For stats, check if this GC was forced by the user  
    // 判断并记录GC是否被强制执行的，runtime.GC()可以被用户调用并强制执行  
    work.userForced = trigger.kind == gcTriggerAlways || trigger.kind == gcTriggerCycle  
    // In gcstoptheworld debug mode, upgrade the mode accordingly.  
    // We do this after re-checking the transition condition so  
    // that multiple goroutines that detect the heap trigger don't  
    // start multiple STW GCs.  
    // 设置gc的mode  
    if mode == gcBackgroundMode {  
        if debug.gcstoptheworld == 1 {  
            mode = gcForceMode  
        } else if debug.gcstoptheworld == 2 {  
            mode = gcForceBlockMode  
        }  
    }  
    // Ok, we're doing it! Stop everybody else  
    semacquire(&worldsema) 
    if trace.enabled {  
        traceGCStart()  
    }  
    // 启动后台标记任务  
    if mode == gcBackgroundMode {  
        gcBgMarkStartWorkers()  
    }  
    // 重置gc 标记相关的状态  
    gcResetMarkState()  
    work.stwprocs, work.maxprocs = gomaxprocs, gomaxprocs  
    if work.stwprocs > ncpu {  
        // This is used to compute CPU time of the STW phases,  
        // so it can't be more than ncpu, even if GOMAXPROCS is.  
        work.stwprocs = ncpu  
    }  
    work.heap0 = atomic.Load64(&memstats.heap_live)  
    work.pauseNS = 0  
    work.mode = mode  
    now := nanotime()  
    work.tSweepTerm = now  
    work.pauseStart = now  
    if trace.enabled {  
        traceGCSTWStart(1)  
    }  
    // STW,停止世界  
    systemstack(stopTheWorldWithSema)  
    // Finish sweep before we start concurrent scan.  
    // 先清扫上一轮的垃圾，确保上轮GC完成  
    systemstack(func() {  
        finishsweep_m()  
    })  
    // clearpools before we start the GC. If we wait they memory will not be  
    // reclaimed until the next GC cycle.  
    // 清理 sync.pool sched.sudogcache、sched.deferpool，这里不展开，sync.pool已经说了，剩余的后面的文章会涉及  
    clearpools()  
    // 增加GC技术  
    work.cycles++  
    if mode == gcBackgroundMode { // Do as much work concurrently as possible  
        gcController.startCycle()  
        work.heapGoal = memstats.next_gc  
        // Enter concurrent mark phase and enable  
        // write barriers. 
        //  
        // Because the world is stopped, all Ps will  
        // observe that write barriers are enabled by  
        // the time we start the world and begin  
        // scanning.  
        //  
        // Write barriers must be enabled before assists are  
        // enabled because they must be enabled before  
        // any non-leaf heap objects are marked. Since  
        // allocations are blocked until assists can  
        // happen, we want enable assists as early as  
        // possible.  
        // 设置GC的状态为 gcMark  
        setGCPhase(_GCmark)  
        // 更新 bgmark 的状态  
        gcBgMarkPrepare() // Must happen before assist enable.  
        // 计算并排队root 扫描任务，并初始化相关扫描任务状态  
        gcMarkRootPrepare()  
        // Mark all active tinyalloc blocks. Since we're  
        // allocating from these, they need to be black like  
        // other allocations. The alternative is to blacken  
        // the tiny block on every allocation from it, which  
        // would slow down the tiny allocator.  
        // 标记 tiny 对象  
        gcMarkTinyAllocs()  
        // At this point all Ps have enabled the write  
        // barrier, thus maintaining the no white to  
        // black invariant. Enable mutator assists to  
        // put back-pressure on fast allocating  
        // mutators.  
        // 设置 gcBlackenEnabled 为 1，启用写屏障  
        atomic.Store(&gcBlackenEnabled, 1)  
        // Assists and workers can start the moment we start  
        // the world.  
        gcController.markStartTime = now  
        // Concurrent mark.  
        systemstack(func() {  
            now = startTheWorldWithSema(trace.enabled)  
        })  
        work.pauseNS += now - work.pauseStart  
        work.tMark = now  
    } else {  
        // 非并行模式  
        // 记录完成标记阶段的开始时间  
        if trace.enabled {  
            // Switch to mark termination STW.  
            traceGCSTWDone()  
            traceGCSTWStart(0)  
        }  
        t := nanotime()  
        work.tMark, work.tMarkTerm = t, t  
        workwork.heapGoal = work.heap0  
        // Perform mark termination. This will restart the world.  
        // stw,进行标记，清扫并start the world 
         gcMarkTermination(memstats.triggerRatio)  
    }  
    semrelease(&work.startSema)  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.

func gcBgMarkStartWorkers() {  
    // Background marking is performed by per-P G's. Ensure that  
    // each P has a background GC G.  
    for _, p := range allp {  
        if p.gcBgMarkWorker == 0 {  
            go gcBgMarkWorker(p)  
            // 等待gcBgMarkWorker goroutine 的 bgMarkReady信号再继续  
            notetsleepg(&work.bgMarkReady, -1)  
            noteclear(&work.bgMarkReady)  
        }  
    }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

func gcBgMarkWorker(_p_ *p) {  
    gp := getg()  
    // 用于休眠结束后重新获取p和m  
    type parkInfo struct {  
        m      muintptr // Release this m on park.  
        attach puintptr // If non-nil, attach to this p on park.  
    }  
    // We pass park to a gopark unlock function, so it can't be on  
    // the stack (see gopark). Prevent deadlock from recursively  
    // starting GC by disabling preemption.  
    gp.m.preemptoff = "GC worker init"  
    park := new(parkInfo)  
    gp.m.preemptoff = ""  
    // 设置park的m和p的信息，留着后面传给gopark，在被gcController.findRunnable唤醒的时候，便于找回  
    park.m.set(acquirem())  
    park.attach.set(_p_)  
    // Inform gcBgMarkStartWorkers that this worker is ready.  
    // After this point, the background mark worker is scheduled  
    // cooperatively by gcController.findRunnable. Hence, it must  
    // never be preempted, as this would put it into _Grunnable  
    // and put it on a run queue. Instead, when the preempt flag  
    // is set, this puts itself into _Gwaiting to be woken up by  
    // gcController.findRunnable at the appropriate time.  
    // 让gcBgMarkStartWorkers notetsleepg停止等待并继续及退出  
    notewakeup(&work.bgMarkReady)  
    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: workwork.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,  
                "workwork.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_)  
        }  
    }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171.
172.
173.
174.
175.
176.
177.
178.
179.
180.
181.
182.

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.  
done:  
    // Flush remaining scan work credit.  
    if gcw.scanWork > 0 {  
        // 把扫描的对象数量添加到全局  
        atomic.Xaddint64(&gcController.scanWork, gcw.scanWork)  
        if flushBgCredit {  
            gcFlushBgCredit(gcw.scanWork - initScanWork)  
        }  
        gcw.scanWork = 0  
    }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.

func markroot(gcw *gcWork, i uint32) {  
    // TODO(austin): This is a bit ridiculous. Compute and store  
    // the bases in gcMarkRootPrepare instead of the counts.  
    baseFlushCache := uint32(fixedRootCount)  
    baseData := baseFlushCache + uint32(work.nFlushCacheRoots)  
    baseBSS := baseData + uint32(work.nDataRoots)  
    baseSpans := baseBSS + uint32(work.nBSSRoots)  
    baseStacks := baseSpans + uint32(work.nSpanRoots)  
    end := baseStacks + uint32(work.nStackRoots)  
    // 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; fbfb = 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)  
            }  
        })  
    }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.

func markrootBlock(b0, n0 uintptr, ptrmask0 *uint8, gcw *gcWork, shard int) {  
    if rootBlockBytes%(8*sys.PtrSize) != 0 {  
        // This is necessary to pick byte offsets in ptrmask0.  
        throw("rootBlockBytes must be a multiple of 8*ptrSize")  
    }  
    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)  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

func scanblock(b0, n0 uintptr, ptrmask *uint8, gcw *gcWork) {  
    // Use local copies of original parameters, so that a stack trace  
    // due to one of the throws below shows the original block  
    // base and extent.  
    b := b0  
    n := n0  
    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  
        }  
    }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.

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&(sys.PtrSize-1) != 0 {  
        throw("greyobject: obj not pointer-aligned")  
    }  
    mbits := span.markBitsForIndex(objIndex)  
    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)  
    }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.

func (w *gcWork) putFast(obj uintptr) bool {  
    wbuf := w.wbuf1  
    if wbuf == nil {  
        // 没有申请缓存队列，返回false  
        return false  
    } else if wbuf.nobj == len(wbuf.obj) {  
        // wbuf1队列满了，返回false  
        return false  
    }  
    // 向未满wbuf1队列中加入对象  
    wbuf.obj[wbuf.nobj] = obj  
    wbuf.nobj++  
    return true  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

func (w *gcWork) put(obj uintptr) {  
    flushed := false  
    wbuf := w.wbuf1  
    if wbuf == nil {  
        // 如果wbuf1不存在，则初始化wbuf1 wbuf2两个队列  
        w.init()  
        wwbuf = w.wbuf1  
        // wbuf is empty at this point.  
    } else if wbuf.nobj == len(wbuf.obj) {  
        // wbuf1满了，更换wbuf1 wbuf2的角色  
        w.wbuf1, ww.wbuf2 = w.wbuf2, w.wbuf1  
        wwbuf = w.wbuf1  
        if wbuf.nobj == len(wbuf.obj) {  
            // 更换角色后，wbuf1也满了，说明两个队列都满了  
            // 把 wbuf1上交全局并获取一个空的队列  
            putfull(wbuf)  
            wbuf = getempty()  
            w.wbuf1 = wbuf  
            // 设置队列上交的标志位  
            flushed = true  
        }  
    }  
    wbuf.obj[wbuf.nobj] = obj  
    wbuf.nobj++  
    // If we put a buffer on full, let the GC controller know so  
    // it can encourage more workers to run. We delay this until  
    // the end of put so that w is in a consistent state, since  
    // enlistWorker may itself manipulate w.  
    // 此时全局已经有标记满的队列，GC controller选择调度更多work进行工作  
    if flushed && gcphase == _GCmark {  
        gcController.enlistWorker()  
    }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.

func (w *gcWork) balance() {  
    if w.wbuf1 == nil {  
        // 这里wbuf1 wbuf2队列还没有初始化  
        return  
    }  
    // 如果wbuf2不为空，则上交到全局，并获取一个空岛队列给wbuf2  
    if wbuf := w.wbuf2; wbuf.nobj != 0 {  
        putfull(wbuf)  
        w.wbuf2 = getempty()  
    } else if wbuf := w.wbuf1; wbuf.nobj > 4 {  
        // 把未满的wbuf1分成两半，并把其中一半上交的全局队列  
        w.wbuf1 = handoff(wbuf)  
    } else {  
        return  
    }  
    // We flushed a buffer to the full list, so wake a worker.  
    // 这里，全局队列有满的队列了，其他work可以工作了  
    if gcphase == _GCmark {  
        gcController.enlistWorker()  
    }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.

func (w *gcWork) get() uintptr {  
    wbuf := w.wbuf1  
    if wbuf == nil {  
        w.init()  
        wwbuf = w.wbuf1  
        // wbuf is empty at this point.  
    }  
    if wbuf.nobj == 0 {  
        // wbuf1空了，更换wbuf1 wbuf2的角色  
        w.wbuf1, ww.wbuf2 = w.wbuf2, w.wbuf1  
        wwbuf = w.wbuf1  
        // 原wbuf2也是空的，尝试从全局队列获取一个满的队列  
        if wbuf.nobj == 0 {  
            owbuf := wbuf  
            wbuf = getfull()  
            // 获取不到，则返回  
            if wbuf == nil {  
                return 0  
            }  
            // 把空的队列上传到全局空队列，并把获取的满的队列，作为自身的wbuf1  
            putempty(owbuf)  
            w.wbuf1 = wbuf  
        }  
    }  
    // TODO: This might be a good place to add prefetch code 
    wbuf.nobj--  
    return wbuf.obj[wbuf.nobj]  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.

func scanobject(b uintptr, gcw *gcWork) {  
    // Find the bits for b and the size of the object at b.  
    //  
    // b is either the beginning of an object, in which case this  
    // is the size of the object to scan, or it points to an  
    // oblet, in which case we compute the size to scan below.  
    // 获取b对应的bits  
    hbits := heapBitsForAddr(b)  
    // 获取b所在的span  
    s := spanOfUnchecked(b)  
    n := s.elemsize  
    if n == 0 {  
        throw("scanobject n == 0")  
    }  
    // 对象过大，则切割后再扫描，maxObletBytes为128k  
    if n > maxObletBytes {  
        // Large object. Break into oblets for better  
        // parallelism and lower latency.  
        if b == s.base() {  
            // It's possible this is a noscan object (not  
            // from greyobject, but from other code  
            // paths), in which case we must *not* enqueue  
            // oblets since their bitmaps will be  
            // uninitialized.  
            // 如果不是指针，直接标记返回，相当于标黑了  
            if s.spanclass.noscan() {  
                // Bypass the whole scan.  
                gcw.bytesMarked += uint64(n)  
                return  
            }  
            // Enqueue the other oblets to scan later.  
            // Some oblets may be in b's scalar tail, but  
            // these will be marked as "no more pointers",  
            // so we'll drop out immediately when we go to  
            // scan those.  
            // 按maxObletBytes切割后放入到 队列  
            for oblet := b + maxObletBytes; oblet < s.base()+s.elemsize; oblet += maxObletBytes {  
                if !gcw.putFast(oblet) {  
                    gcw.put(oblet)  
                }  
            }  
        }  
        // Compute the size of the oblet. Since this object  
        // must be a large object, s.base() is the beginning  
        // of the object.  
        n = s.base() + s.elemsize - b  
        if n > maxObletBytes {  
            n = maxObletBytes  
        }  
    }  
    var i uintptr  
    for i = 0; i < n; i += sys.PtrSize {  
        // Find bits for this word.  
        // 获取到对应的bits  
        if i != 0 {  
            // Avoid needless hbits.next() on last iteration.  
            hbitshbits = hbits.next()  
        }  
        // Load bits once. See CL 22712 and issue 16973 for discussion.  
        bits := hbits.bits()  
        // During checkmarking, 1-word objects store the checkmark  
        // in the type bit for the one word. The only one-word objects  
        // are pointers, or else they'd be merged with other non-pointer  
        // data into larger allocations.  
        if i != 1*sys.PtrSize && bits&bitScan == 0 {  
            break // no more pointers in this object  
        }  
        // 不是指针，继续  
        if bits&bitPointer == 0 {  
            continue // not a pointer  
        }  
        // Work here is duplicated in scanblock and above.  
        // If you make changes here, make changes there too.  
        obj := *(*uintptr)(unsafe.Pointer(b + i))  
        // At this point we have extracted the next potential pointer.  
        // Quickly filter out nil and pointers back to the current object.  
        if obj != 0 && obj-b >= n {  
            // Test if obj points into the Go heap and, if so,  
            // mark the object.  
            //  
            // Note that it's possible for findObject to  
            // fail if obj points to a just-allocated heap  
            // object because of a race with growing the  
            // heap. In this case, we know the object was  
            // just allocated and hence will be marked by  
            // allocation itself.  
            // 找到指针对应的对象，并标灰  
            if obj, span, objIndex := findObject(obj, b, i); obj != 0 {  
                greyobject(obj, b, i, span, gcw, objIndex)  
            }  
        }  
    }  
    gcw.bytesMarked += uint64(n)  
    gcw.scanWork += int64(i)  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.

func gcMarkDone() {  
top:  
    semacquire(&work.markDoneSema)  
    // Re-check transition condition under transition lock.  
    if !(gcphase == _GCmark && work.nwait == work.nproc && !gcMarkWorkAvailable(nil)) {  
        semrelease(&work.markDoneSema)  
        return  
    }  
    // Disallow starting new workers so that any remaining workers  
    // in the current mark phase will drain out.  
    //  
    // TODO(austin): Should dedicated workers keep an eye on this  
    // and exit gcDrain promptly?  
    // 禁止新的标记任务  
    atomic.Xaddint64(&gcController.dedicatedMarkWorkersNeeded, -0xffffffff)  
    prevFractionalGoal := gcController.fractionalUtilizationGoal  
    gcController.fractionalUtilizationGoal = 0  
    // 如果gcBlackenPromptly表名需要所有本地缓存队列立即上交到全局队列，并禁用本地缓存队列  
    if !gcBlackenPromptly {  
        // Transition from mark 1 to mark 2.  
        //  
        // The global work list is empty, but there can still be work  
        // sitting in the per-P work caches.  
        // Flush and disable work caches.  
        // Disallow caching workbufs and indicate that we're in mark 2.  
        // 禁用本地缓存队列，进入mark2阶段  
        gcBlackenPromptly = true  
        // Prevent completion of mark 2 until we've flushed  
        // cached workbufs.  
        atomic.Xadd(&work.nwait, -1)  
        // GC is set up for mark 2. Let Gs blocked on the  
        // transition lock go while we flush caches.  
        semrelease(&work.markDoneSema)  
        // 切换到g0执行，本地缓存上传到全局的操作  
        systemstack(func() {  
            // Flush all currently cached workbufs and  
            // ensure all Ps see gcBlackenPromptly. This  
            // also blocks until any remaining mark 1  
            // workers have exited their loop so we can  
            // start new mark 2 workers.  
            forEachP(func(_p_ *p) {  
                wbBufFlush1(_p_)  
                _p_.gcw.dispose()  
            })  
        })  
        // Check that roots are marked. We should be able to  
        // do this before the forEachP, but based on issue  
        // #16083 there may be a (harmless) race where we can  
        // enter mark 2 while some workers are still scanning  
        // stacks. The forEachP ensures these scans are done.  
        //  
        // TODO(austin): Figure out the race and fix this  
        // properly.  
        // 检查所有的root是否都被标记了  
        gcMarkRootCheck()  
        // Now we can start up mark 2 workers.  
        atomic.Xaddint64(&gcController.dedicatedMarkWorkersNeeded, 0xffffffff)  
        gcController.fractionalUtilizationGoal = prevFractionalGoal  
        incnwait := atomic.Xadd(&work.nwait, +1)  
        // 如果没有更多的任务，则执行第二次调用，从mark2阶段转换到mark termination阶段  
        if incnwait == work.nproc && !gcMarkWorkAvailable(nil) {  
            // This loop will make progress because  
            // gcBlackenPromptly is now true, so it won't  
            // take this same "if" branch.  
            goto top  
        }  
    } else {  
        // Transition to mark termination.  
        now := nanotime()  
        work.tMarkTerm = now  
        work.pauseStart = now  
        getg().m.preemptoff = "gcing"  
        if trace.enabled {  
            traceGCSTWStart(0)  
        }  
        systemstack(stopTheWorldWithSema)  
        // The gcphase is _GCmark, it will transition to _GCmarktermination  
        // below. The important thing is that the wb remains active until  
        // all marking is complete. This includes writes made by the GC.  
        // Record that one root marking pass has completed.  
        work.markrootDone = true  
        // Disable assists and background workers. We must do  
        // this before waking blocked assists.  
        atomic.Store(&gcBlackenEnabled, 0)  
        // Wake all blocked assists. These will run when we  
        // start the world again.  
        // 唤醒所有的辅助GC  
        gcWakeAllAssists()  
        // Likewise, release the transition lock. Blocked  
        // workers and assists will run when we start the  
        // world again.  
        semrelease(&work.markDoneSema)  
        // endCycle depends on all gcWork cache stats being  
        // flushed. This is ensured by mark 2.  
        // 计算下一次gc出发的阈值  
        nextTriggerRatio := gcController.endCycle()  
        // Perform mark termination. This will restart the world.  
        // start the world，并进入完成阶段  
        gcMarkTermination(nextTriggerRatio)  
    }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.

func gcMarkTermination(nextTriggerRatio float64) {  
    // World is stopped.  
    // Start marktermination which includes enabling the write barrier.  
    atomic.Store(&gcBlackenEnabled, 0)  
    gcBlackenPromptly = false  
    // 设置GC的阶段标识  
    setGCPhase(_GCmarktermination)  
    work.heap1 = memstats.heap_live  
    startTime := nanotime()  
    mp := acquirem()  
    mp.preemptoff = "gcing"  
    _g_ := getg()  
    _g_.m.traceback = 2  
    gp := _g_.m.curg  
    // 设置当前g的状态为waiting状态  
    casgstatus(gp, _Grunning, _Gwaiting)  
    gp.waitreason = waitReasonGarbageCollection  
    // Run gc on the g0 stack. We do this so that the g stack  
    // we're currently running on will no longer change. Cuts  
    // the root set down a bit (g0 stacks are not scanned, and  
    // we don't need to scan gc's internal state).  We also  
    // need to switch to g0 so we can shrink the stack.  
    systemstack(func() {  
        // 通过g0扫描当前g的栈  
        gcMark(startTime)  
        // Must return immediately.  
        // The outer function's stack may have moved  
        // during gcMark (it shrinks stacks, including the  
        // outer function's stack), so we must not refer  
        // to any of its variables. Return back to the  
        // non-system stack to pick up the new addresses  
        // before continuing.  
    })  
    systemstack(func() {  
        workwork.heap2 = work.bytesMarked  
        if debug.gccheckmark > 0 {  
            // Run a full stop-the-world mark using checkmark bits,  
            // to check that we didn't forget to mark anything during  
            // the concurrent mark process.  
            // 如果启用了gccheckmark，则检查所有可达对象是否都有标记  
            gcResetMarkState()  
            initCheckmarks()  
            gcMark(startTime)  
            clearCheckmarks()  
        }  
        // marking is complete so we can turn the write barrier off  
        // 设置gc的阶段标识，GCoff时会关闭写屏障  
        setGCPhase(_GCoff)  
        // 开始清扫  
        gcSweep(work.mode)  
        if debug.gctrace > 1 {  
            startTime = nanotime()  
            // The g stacks have been scanned so  
            // they have gcscanvalid==true and gcworkdone==true.  
            // Reset these so that all stacks will be rescanned.  
            gcResetMarkState()  
            finishsweep_m()  
            // Still in STW but gcphase is _GCoff, reset to _GCmarktermination  
            // At this point all objects will be found during the gcMark which  
            // does a complete STW mark and object scan.  
            setGCPhase(_GCmarktermination)  
            gcMark(startTime)  
            setGCPhase(_GCoff) // marking is done, turn off wb.  
            gcSweep(work.mode)  
        }  
    })  
    _g_.m.traceback = 0  
    casgstatus(gp, _Gwaiting, _Grunning)  
    if trace.enabled {  
        traceGCDone()  
    }  
    // all done  
    mp.preemptoff = ""  
    if gcphase != _GCoff {  
        throw("gc done but gcphase != _GCoff")  
    }  
    // Update GC trigger and pacing for the next cycle.  
    // 更新下次出发gc的增长比  
    gcSetTriggerRatio(nextTriggerRatio)  
    // Update timing memstats  
    // 更新用时  
    now := nanotime()  
    sec, nsec, _ := time_now()  
    unixNow := sec*1e9 + int64(nsec)  
    work.pauseNS += now - work.pauseStart  
    work.tEnd = now  
    atomic.Store64(&memstats.last_gc_unix, uint64(unixNow)) // must be Unix time to make sense to user  
    atomic.Store64(&memstats.last_gc_nanotime, uint64(now)) // monotonic time for us  
    memstats.pause_ns[memstats.numgc%uint32(len(memstats.pause_ns))] = uint64(work.pauseNS)  
    memstats.pause_end[memstats.numgc%uint32(len(memstats.pause_end))] = uint64(unixNow)  
    memstats.pause_total_ns += uint64(work.pauseNS)  
    // Update work.totaltime.  
    sweepTermCpu := int64(work.stwprocs) * (work.tMark - work.tSweepTerm)  
    // We report idle marking time below, but omit it from the  
    // overall utilization here since it's "free".  
    markCpu := gcController.assistTime + gcController.dedicatedMarkTime + gcController.fractionalMarkTime  
    markTermCpu := int64(work.stwprocs) * (work.tEnd - work.tMarkTerm)  
    cycleCpu := sweepTermCpu + markCpu + markTermCpu  
    work.totaltime += cycleCpu  
    // Compute overall GC CPU utilization.  
    totalCpu := sched.totaltime + (now-sched.procresizetime)*int64(gomaxprocs)  
    memstats.gc_cpu_fraction = float64(work.totaltime) / float64(totalCpu)  
    // Reset sweep state.  
    // 重置清扫的状态  
    sweep.nbgsweep = 0  
    sweep.npausesweep = 0  
    // 如果是强制开启的gc，标识增加  
    if work.userForced {  
        memstats.numforcedgc++  
    }  
    // Bump GC cycle count and wake goroutines waiting on sweep.  
    // 统计执行GC的次数然后唤醒等待清扫的G  
    lock(&work.sweepWaiters.lock)  
    memstats.numgc++  
    injectglist(work.sweepWaiters.head.ptr())  
    work.sweepWaiters.head = 0  
    unlock(&work.sweepWaiters.lock)  
    // Finish the current heap profiling cycle and start a new  
    // heap profiling cycle. We do this before starting the world  
    // so events don't leak into the wrong cycle.  
    mProf_NextCycle()  
    // start the world  
    systemstack(func() { startTheWorldWithSema(true) })  
    // Flush the heap profile so we can start a new cycle next GC.  
    // This is relatively expensive, so we don't do it with the  
    // world stopped.  
    mProf_Flush()  
    // Prepare workbufs for freeing by the sweeper. We do this  
    // asynchronously because it can take non-trivial time.  
    prepareFreeWorkbufs()  
    // Free stack spans. This must be done between GC cycles.  
    systemstack(freeStackSpans)  
    // Print gctrace before dropping worldsema. As soon as we drop  
    // worldsema another cycle could start and smash the stats  
    // we're trying to print.  
    if debug.gctrace > 0 {  
        util := int(memstats.gc_cpu_fraction * 100)  
        var sbuf [24]byte  
        printlock()  
        print("gc ", memstats.numgc,  
            " @", string(itoaDiv(sbuf[:], uint64(work.tSweepTerm-runtimeInitTime)/1e6, 3)), "s ",  
            util, "%: ")  
        prev := work.tSweepTerm  
        for i, ns := range []int64{work.tMark, work.tMarkTerm, work.tEnd} {  
            if i != 0 {  
                print("+")  
            }  
            print(string(fmtNSAsMS(sbuf[:], uint64(ns-prev))))  
            prev = ns  
        }  
        print(" ms clock, ")  
        for i, ns := range []int64{sweepTermCpu, gcController.assistTime, gcController.dedicatedMarkTime + gcController.fractionalMarkTime, gcController.idleMarkTime, markTermCpu} { 
             if i == 2 || i == 3 {  
                // Separate mark time components with /.  
                print("/")  
            } else if i != 0 {  
                print("+")  
            }  
            print(string(fmtNSAsMS(sbuf[:], uint64(ns))))  
        }  
        print(" ms cpu, ",  
            work.heap0>>20, "->", work.heap1>>20, "->", work.heap2>>20, " MB, ",  
            work.heapGoal>>20, " MB goal, ",  
            work.maxprocs, " P")  
        if work.userForced {  
            print(" (forced)")  
        }  
        print("\n")  
        printunlock()  
    }  
    semrelease(&worldsema)  
    // Careful: another GC cycle may start now.  
    releasem(mp)  
    mp = nil  
    // now that gc is done, kick off finalizer thread if needed  
    // 如果不是并行GC，则让当前M开始调度  
    if !concurrentSweep {  
        // give the queued finalizers, if any, a chance to run  
        Gosched()  
    }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171.
172.
173.
174.
175.
176.
177.
178.
179.
180.
181.

func gcSweep(mode gcMode) {  
    if gcphase != _GCoff {  
        throw("gcSweep being done but phase is not GCoff")  
    }  
    lock(&mheap_.lock)  
    // sweepgen在每次GC之后都会增长2，每次GC之后sweepSpans的角色都会互换  
    mheap_.sweepgen += 2  
    mheap_.sweepdone = 0  
    if mheap_.sweepSpans[mheap_.sweepgen/2%2].index != 0 {  
        // We should have drained this list during the last  
        // sweep phase. We certainly need to start this phase  
        // with an empty swept list.  
        throw("non-empty swept list")  
    }  
    mheap_.pagesSwept = 0  
    unlock(&mheap_.lock)  
    // 如果不是并行GC，或者强制GC  
    if !_ConcurrentSweep || mode == gcForceBlockMode {  
        // Special case synchronous sweep.  
        // Record that no proportional sweeping has to happen.  
        lock(&mheap_.lock)  
        mheap_.sweepPagesPerByte = 0  
        unlock(&mheap_.lock)  
        // Sweep all spans eagerly.  
        // 清扫所有的span  
        for sweepone() != ^uintptr(0) {  
            sweep.npausesweep++  
        }  
        // Free workbufs eagerly.  
        // 释放所有的 workbufs  
        prepareFreeWorkbufs()  
        for freeSomeWbufs(false) {  
        }  
        // All "free" events for this mark/sweep cycle have  
        // now happened, so we can make this profile cycle  
        // available immediately.  
        mProf_NextCycle()  
        mProf_Flush()  
        return  
    }  
    // Background sweep.  
    lock(&sweep.lock)  
    // 唤醒后台清扫任务,也就是 bgsweep 函数，清扫流程跟上面非并行清扫差不多  
    if sweep.parked {  
        sweep.parked = false  
        ready(sweep.g, 0, true)  
    }  
    unlock(&sweep.lock)  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.

func sweepone() uintptr {  
    _g_ := getg()  
    sweepRatio := mheap_.sweepPagesPerByte // For debugging  
    // increment locks to ensure that the goroutine is not preempted  
    // in the middle of sweep thus leaving the span in an inconsistent state for next GC  
    _g_.m.locks++  
    // 检查是否已经完成了清扫  
    if atomic.Load(&mheap_.sweepdone) != 0 {  
        _g_.m.locks--  
        return ^uintptr(0)  
    }  
    // 增加清扫的worker数量  
    atomic.Xadd(&mheap_.sweepers, +1)  
    npages := ^uintptr(0)  
    sg := mheap_.sweepgen  
    for {  
        // 循环获取需要清扫的span  
        s := mheap_.sweepSpans[1-sg/2%2].pop()  
        if s == nil {  
            atomic.Store(&mheap_.sweepdone, 1)  
            break  
        }  
        if s.state != mSpanInUse {  
            // This can happen if direct sweeping already  
            // swept this span, but in that case the sweep  
            // generation should always be up-to-date.  
            if s.sweepgen != sg {  
                print("runtime: bad span s.state=", s.state, " s.sweepgen=", s.sweepgen, " sweepgen=", sg, "\n")  
                throw("non in-use span in unswept list")  
            }  
            continue  
        }  
        // sweepgen == h->sweepgen - 2, 表示这个span需要清扫  
        // sweepgen == h->sweepgen - 1, 表示这个span正在被清扫  
        // 这是里确定span的状态及尝试转换span的状态  
        if s.sweepgen != sg-2 || !atomic.Cas(&s.sweepgen, sg-2, sg-1) {  
            continue  
        }  
        npages = s.npages  
        // 单个span的清扫  
        if !s.sweep(false) {  
            // Span is still in-use, so this returned no  
            // pages to the heap and the span needs to  
            // move to the swept in-use list.  
            npages = 0  
        }  
        break  
    }  
    // Decrement the number of active sweepers and if this is the  
    // last one print trace information.  
    // 当前worker清扫任务完成，更新sweepers的数量  
    if atomic.Xadd(&mheap_.sweepers, -1) == 0 && atomic.Load(&mheap_.sweepdone) != 0 {  
        if debug.gcpacertrace > 0 {  
            print("pacer: sweep done at heap size ", memstats.heap_live>>20, "MB; allocated ", (memstats.heap_live-mheap_.sweepHeapLiveBasis)>>20, "MB during sweep; swept ", mheap_.pagesSwept, " pages at ", sweepRatio, " pages/byte\n") 
         }  
    }  
    _g_.m.locks--  
    return npages  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.

func (s *mspan) sweep(preserve bool) bool {  
    // It's critical that we enter this function with preemption disabled,  
    // GC must not start while we are in the middle of this function.  
    _g_ := getg()  
    if _g_.m.locks == 0 && _g_.m.mallocing == 0 && _g_ != _g_.m.g0 {  
        throw("MSpan_Sweep: m is not locked") 
    }  
    sweepgen := mheap_.sweepgen  
    // 只有正在清扫中状态的span才可以正常执行  
    if s.state != mSpanInUse || s.sweepgen != sweepgen-1 {  
        print("MSpan_Sweep: state=", s.state, " sweepgen=", s.sweepgen, " mheap.sweepgen=", sweepgen, "\n")  
        throw("MSpan_Sweep: bad span state")  
    }  
    if trace.enabled { 
         traceGCSweepSpan(s.npages * _PageSize)  
    }  
    // 先更新清扫的page数  
    atomic.Xadd64(&mheap_.pagesSwept, int64(s.npages))  
    spc := s.spanclass  
    size := s.elemsize  
    res := false  
    c := _g_.m.mcache  
    freeToHeap := false  
    // The allocBits indicate which unmarked objects don't need to be  
    // processed since they were free at the end of the last GC cycle  
    // and were not allocated since then.  
    // If the allocBits index is >= s.freeindex and the bit  
    // is not marked then the object remains unallocated  
    // since the last GC.  
    // This situation is analogous to being on a freelist.  
    // Unlink & free special records for any objects we're about to free.  
    // Two complications here:  
    // 1. An object can have both finalizer and profile special records.  
    //    In such case we need to queue finalizer for execution,  
    //    mark the object as live and preserve the profile special.  
    // 2. A tiny object can have several finalizers setup for different offsets.  
    //    If such object is not marked, we need to queue all finalizers at once.  
    // Both 1 and 2 are possible at the same time.  
    specialp := &s.specials  
    special := *specialp  
    // 判断在special中的对象是否存活，是否至少有一个finalizer，释放没有finalizer的对象，把有finalizer的对象组成队列  
    for special != nil {  
        // A finalizer can be set for an inner byte of an object, find object beginning.  
        objIndex := uintptr(special.offset) / size  
        p := s.base() + objIndex*size  
        mbits := s.markBitsForIndex(objIndex)  
        if !mbits.isMarked() {  
            // This object is not marked and has at least one special record.  
            // Pass 1: see if it has at least one finalizer.  
            hasFin := false  
            endOffset := p - s.base() + size  
            for tmp := special; tmp != nil && uintptr(tmp.offset) < endOffset; tmptmp = tmp.next {  
                if tmp.kind == _KindSpecialFinalizer {  
                    // Stop freeing of object if it has a finalizer.  
                    mbits.setMarkedNonAtomic()  
                    hasFin = true  
                    break  
                }  
            }  
            // Pass 2: queue all finalizers _or_ handle profile record.  
            for special != nil && uintptr(special.offset) < endOffset {  
                // Find the exact byte for which the special was setup  
                // (as opposed to object beginning).  
                p := s.base() + uintptr(special.offset)  
                if special.kind == _KindSpecialFinalizer || !hasFin {  
                    // Splice out special record.  
                    y := special  
                    specialspecial = special.next  
                    *specialspecialp = special 
                     freespecial(y, unsafe.Pointer(p), size)  
                } else {  
                    // This is profile record, but the object has finalizers (so kept alive).  
                    // Keep special record.  
                    specialp = &special.next  
                    special = *specialp  
                }  
            }  
        } else {  
            // object is still live: keep special record  
            specialp = &special.next  
            special = *specialp  
        }  
    }  
    if debug.allocfreetrace != 0 || raceenabled || msanenabled {  
        // Find all newly freed objects. This doesn't have to  
        // efficient; allocfreetrace has massive overhead.  
        mbits := s.markBitsForBase()  
        abits := s.allocBitsForIndex(0)  
        for i := uintptr(0); i < s.nelems; i++ {  
            if !mbits.isMarked() && (abits.index < s.freeindex || abits.isMarked()) {  
                x := s.base() + i*s.elemsize  
                if debug.allocfreetrace != 0 {  
                    tracefree(unsafe.Pointer(x), size)  
                }  
                if raceenabled {  
                    racefree(unsafe.Pointer(x), size)  
                }  
                if msanenabled {  
                    msanfree(unsafe.Pointer(x), size)  
                }  
            }  
            mbits.advance()  
            abits.advance()  
        }  
    }  
    // Count the number of free objects in this span.  
    // 获取需要释放的alloc对象的总数  
    nalloc := uint16(s.countAlloc())  
    // 如果sizeclass为0，却分配的总数量为0，则释放到mheap  
    if spc.sizeclass() == 0 && nalloc == 0 {  
        s.needzero = 1  
        freeToHeap = true  
    }  
    nfreed := s.allocCount - nalloc  
    if nalloc > s.allocCount {  
        print("runtime: nelems=", s.nelems, " nalloc=", nalloc, " previous allocCount=", s.allocCount, " nfreed=", nfreed, "\n")  
        throw("sweep increased allocation count")  
    }  
    s.allocCount = nalloc  
    // 判断span是否empty  
    wasempty := s.nextFreeIndex() == s.nelems  
    // 重置freeindex  
    s.freeindex = 0 // reset allocation index to start of span.  
    if trace.enabled {  
        getg().m.p.ptr().traceReclaimed += uintptr(nfreed) * s.elemsize  
    }  
    // gcmarkBits becomes the allocBits.  
    // get a fresh cleared gcmarkBits in preparation for next GC  
    // 重置 allocBits为 gcMarkBits  
    ss.allocBits = s.gcmarkBits  
    // 重置 gcMarkBits  
    s.gcmarkBits = newMarkBits(s.nelems)  
    // Initialize alloc bits cache.  
    // 更新allocCache  
    s.refillAllocCache(0)  
    // We need to set s.sweepgen = h.sweepgen only when all blocks are swept,  
    // because of the potential for a concurrent free/SetFinalizer.  
    // But we need to set it before we make the span available for allocation  
    // (return it to heap or mcentral), because allocation code assumes that a  
    // span is already swept if available for allocation.  
    if freeToHeap || nfreed == 0 {  
        // The span must be in our exclusive ownership until we update sweepgen,  
        // check for potential races.  
        if s.state != mSpanInUse || s.sweepgen != sweepgen-1 {  
            print("MSpan_Sweep: state=", s.state, " sweepgen=", s.sweepgen, " mheap.sweepgen=", sweepgen, "\n")  
            throw("MSpan_Sweep: bad span state after sweep")  
        }  
        // Serialization point.  
        // At this point the mark bits are cleared and allocation ready  
        // to go so release the span.  
        atomic.Store(&s.sweepgen, sweepgen)  
    }  
    if nfreed > 0 && spc.sizeclass() != 0 {  
        c.local_nsmallfree[spc.sizeclass()] += uintptr(nfreed)  
        // 把span释放到mcentral上  
        res = mheap_.central[spc].mcentral.freeSpan(s, preserve, wasempty)  
        // MCentral_FreeSpan updates sweepgen  
    } else if freeToHeap {  
        // 这里是大对象的span释放，与117行呼应  
        // Free large span to heap  
        // NOTE(rsc,dvyukov): The original implementation of efence  
        // in CL 22060046 used SysFree instead of SysFault, so that  
        // the operating system would eventually give the memory  
        // back to us again, so that an efence program could run  
        // longer without running out of memory. Unfortunately, 
         // calling SysFree here without any kind of adjustment of the  
        // heap data structures means that when the memory does  
        // come back to us, we have the wrong metadata for it, either in  
        // the MSpan structures or in the garbage collection bitmap.  
        // Using SysFault here means that the program will run out of  
        // memory fairly quickly in efence mode, but at least it won't  
        // have mysterious crashes due to confused memory reuse.  
        // It should be possible to switch back to SysFree if we also  
        // implement and then call some kind of MHeap_DeleteSpan.  
        if debug.efence > 0 {  
            s.limit = 0 // prevent mlookup from finding this span  
            sysFault(unsafe.Pointer(s.base()), size)  
        } else {  
            // 把sapn释放到mheap上  
            mheap_.freeSpan(s, 1)  
        }  
        c.local_nlargefree++  
        c.local_largefree += size  
        res = true  
    }  
    if !res {  
        // The span has been swept and is still in-use, so put  
        // it on the swept in-use list.  
        // 如果span未释放到mcentral或mheap，表示span仍然处于in-use状态  
        mheap_.sweepSpans[sweepgen/2%2].push(s) 
    }  
    return res  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171.
172.
173.
174.
175.
176.
177.
178.
179.
180.
181.
182.
183.
184.
185.
186.
187.
188.
189.
190.
191.
192.
193.