上一篇文章咱们次要介绍了三色标记法与写屏障技术，基于这些根底，本篇文章将重点介绍垃圾回收的整个解决流程（开启 - 标记 - 标记完结 - 清理），包含标记协程主流程，经典的 startTheworld/stopTheworld 问题，辅助标记是什么，清理过程等等。
垃圾回收概述
Go 语言将垃圾回收分为三个阶段：标记（三色标记扫描），标记终止（此时业务逻辑暂停，会再次扫描），未启动（可能也会执行清理工作）；定义如下：
_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垃圾回收过程的启动函数为 gcStart，该函数次要逻辑如下：
- 首先查看上一次垃圾回收是否还有 mspan 未被清理，如果有还须要执行清理工作；
- 垃圾回收器的初始化是不能同时进行的，这里通过锁解决并发问题；
- 垃圾回收过程也是通过创立协程实现的，只是这些协程和一般的用户协程有所不同罢了；
- 垃圾回收的某些初始化工作，是不能与用户协程并发执行的，所以在初始化过程中还须要暂停用户协程（也就是传说中的 STW）；
func gcStart(trigger gcTrigger) {
// 如果还有 mspan 未被清理，执行清理工作
for trigger.test() && sweepone() != ^uintptr(0) {sweep.nbgsweep++}
// 启动垃圾回收过程须要加锁
semacquire(&work.startSema) //startSema protects the transition from "off" to mark or mark termination.
// 有这把锁能力 stopTheworld
semacquire(&worldsema) //Holding worldsema grants an M the right to try to stop the world.
// 创立垃圾回收主协程
gcBgMarkStartWorkers()
//STW
systemstack(stopTheWorldWithSema)
// 设置垃圾回收阶段
setGCPhase(_GCmark)
// 预处理须要标记的根对象
gcMarkRootPrepare()
// 设置标识位（很多中央有用到这个标识判断是否在标记）atomic.Store(&gcBlackenEnabled, 1)
// 复原用户协程
systemstack(func() {now = startTheWorldWithSema(trace.enabled)
})
semrelease(&worldsema)
semrelease(&work.startSema)
}
gcStart 函数这就执行完结了？标记过程呢？没看到对应的逻辑啊。想想标记过程必定是漫长的，如果由 gcStart 函数同步调用，那可是会阻塞函数调用方的。留神上述主流程创立了垃圾回收主协程，就是这些协程执行的标记过程。
func gcBgMarkStartWorkers() {
// 与 P 数目保持一致
for gcBgMarkWorkerCount < gomaxprocs {go gcBgMarkWorker()
}
}
func gcBgMarkWorker() {
for {
// Go to sleep until woken by
// gcController.findRunnableGCWorker.
gopark(......)
{
// gopark 协程换出之前，会将该协程注册到公共 pool
// Release this G to the pool.
gcBgMarkWorkerPool.push(......)
}
decnwait := atomic.Xadd(&work.nwait, -1)
systemstack(func() {
// 标记扫描
gcDrain(......)
})
incnwait := atomic.Xadd(&work.nwait, +1)
// 如果该协程是最初一个执行完一轮标记工作，并且没有标记工作须要解决，则标记过程完结
if incnwait == work.nproc && !gcMarkWorkAvailable(nil) {gcMarkDone() // 最终调用到 gcMarkTermination，垃圾回收状态转换为_GCmarktermination、_GCoff
}
}
}这里咱们须要关注两点：1）标记扫描主函数是 gcDrain，该函数次要执行了咱们上一篇文章介绍的三色标记过程，这里就不再赘述。2）垃圾回收协程是一个 for 循环，不过循环开始都是通过 gopark 协程让出 CPU，该协程在什么时候被调度呢？与用户协程一样吗？留神到正文是这么说的，协程始终休眠直到被 ”gcController.findRunnableGCWorker” 唤醒。要了解这一过程，只能去看看 Go 语言调度器了：
func schedule() {
if gp == nil && gcBlackenEnabled != 0 {gp = gcController.findRunnableGCWorker(_g_.m.p.ptr())
}
}到这里，垃圾回收的启动过程以及工作协程的主逻辑咱们根本有个大抵解了，当然有一些细节目前还未具体介绍，如 STW，如 gcDrain，如标记完结阶段（有趣味能够本人学习钻研）等等。
startTheworld/stopTheworld
上一篇文章咱们提到因为用户协程与垃圾回收工作协程并发执行，所以须要写屏障，这就能够了吗？当然不是，垃圾回收的某些初始化工作，是不能与用户协程并发执行的，所以在初始化过程中还须要暂停用户协程，这就是所谓的 stopTheworld。如何暂停用户协程呢？
思考一下，线程 M 调度协程 G 是须要绑定逻辑处理器 P 的，那如果没有可用的逻辑解决 P 当然也就无奈调度用户协程了？逻辑处理器 P 能够分为三种：1）闲暇，没有被任何线程 M 绑定，这种间接更新其状态即可；2）零碎调用中，阐明已被线程 M 绑定，并且正在执行零碎调用，同样的间接更新状态即可（系统调度返回后，检测逻辑处理器 P 的状态不对，线程 M 会休眠）；3）运行中，也就是已被线程 M 绑定，并且正在调度用户协程，这种是须要告诉其暂停用户协程的，如何告诉呢？还记得介绍 Go 语言调度器提到的抢占式调度吗？合作式抢占调度与基于信号的抢占式调度。对，就是通过这两种计划实现的（与 Go 版本无关）。
stopTheWorldWithSema 函数的实现逻辑如下：
func stopTheWorldWithSema() {
// 调度器锁
lock(&sched.lock)
// 期待暂停的 P 数目
sched.stopwait = gomaxprocs
// 标识 GC 期待运行
atomic.Store(&sched.gcwaiting, 1)
// 告诉所有运行中的 P 暂停用户协程（抢占式调度：合作式或基于信号实现）preemptall()
// 暂停以后 P
_g_.m.p.ptr().status = _Pgcstop // Pgcstop is only diagnostic.
sched.stopwait--
for _, p := range allp {
s := p.status
// 暂停零碎调用中的 P
if s == _Psyscall && atomic.Cas(&p.status, s, _Pgcstop) {
p.syscalltick++
sched.stopwait--
}
}
// 暂停闲暇 P
for {p := pidleget()
if p == nil {break}
p.status = _Pgcstop
sched.stopwait--
}
wait := sched.stopwait > 0
unlock(&sched.lock)
// 如果还有 P 没有暂停，循环阻塞期待
if wait {
for {
// wait for 100us, then try to re-preempt in case of any races
if notetsleep(&sched.stopnote, 100*1000) {noteclear(&sched.stopnote)
break
}
preemptall()}
}
}这里貌似还有一个问题：sched.stopwait 保护着须要暂停 P 的数目，P 处于运行状态的时候，是基于信号告诉用户协程暂停的，告诉的后果是不确定的，所以这里才会循环阻塞期待；只是用户协程暂停时，怎么更新 sched.stopwait 呢？想想用户协程让出 CPU 之后，该执行什么逻辑呢？当然是调度器了！
func schedule() {
// 如果期待 gc，则暂停 M
if sched.gcwaiting != 0 {gcstopm()
goto top
}
}
func gcstopm() {
sched.stopwait--
// 如果所有 P 都暂停了，告诉
if sched.stopwait == 0 {notewakeup(&sched.stopnote)
}
}原来是这么暂停用户协程的，看来还是须要对 Go 调度器有较深理解。startTheworld 就是一个反过程，这里就不在赘述了。
辅助标记
辅助标记什么意思呢？谁辅助，辅助谁呢？咱们曾经晓得，Go 语言启动了多个协程用户解决标记扫描工作，思考一下，与此同时，用户协程还在失常分配内存，如果内存调配过快呢？甚至超过了标记扫描的速度呢？为了解决这个问题，Go 语言是这么做的：如果某些用户协程分配内存过快，则须要帮忙执行一些标记扫描工作，并且甚至还会暂停其调度。
在内存调配入口函数 mallocgc 很容易找到这段逻辑：
func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
// 只有垃圾回收过程才会走到辅助标记
if gcBlackenEnabled != 0 {assistG = getg()
assistG.gcAssistBytes -= int64(size)
// 小于 0，阐明有欠债，须要帮忙辅助标记
if assistG.gcAssistBytes < 0 {gcAssistAlloc(assistG)
}
}
}怎么掂量是否内存调配过快呢？垃圾回收协程执行了多少标记扫描工作（相当于工作挣钱，全局保护了一个现金池），相应的用户协程就能申请肯定比例的内存（用户协程花钱）；用户协程申请了内存（买货色付钱），有了欠债，怎么办，先从全局现金池借呗，如果不够怎么办（申请内存过多），不够了再帮忙挣钱呗！
func gcAssistAlloc(gp *g) {
retry:
// 申请了内存（买货色），就须要付钱，assistWorkPerByte 定义了之间的比例关系
assistWorkPerByte := gcController.assistWorkPerByte.Load()
assistBytesPerWork := gcController.assistBytesPerWork.Load()
// 计算该用户协程须要付多少钱
debtBytes := -gp.gcAssistBytes
scanWork := int64(assistWorkPerByte * float64(debtBytes))
// 全局现金池，须要先借钱
bgScanCredit := atomic.Loadint64(&gcController.bgScanCredit)
// 相当于借的钱
stolen := int64(0)
if bgScanCredit > 0 {
// 全局现金池不够，不足以还债
if bgScanCredit < scanWork {
stolen = bgScanCredit
// 债必定还没还完
gp.gcAssistBytes += 1 + int64(assistBytesPerWork*float64(stolen))
} else {
// 能够还完债
stolen = scanWork
gp.gcAssistBytes += debtBytes
}
// 借钱了，全局扣除
atomic.Xaddint64(&gcController.bgScanCredit, -stolen)
// 用户协程还剩了这些债权
scanWork -= stolen
if scanWork == 0 {
// We were able to steal all of the credit we needed.
return
}
}
// 辅助标记（挣钱还债）systemstack(func() {gcAssistAlloc1(gp, scanWork)
})
// 还有欠债
if gp.gcAssistBytes < 0 {
// 被抢占了，让出 CPU；一旦复原执行，再次借钱
if gp.preempt {Gosched()
goto retry
}
// 阻塞
if !gcParkAssist() {goto retry}
}
}辅助标记过程与垃圾回收协程根本相似，通过 gcDrainN 函数实现；一旦辅助标记也没有还清债权，则阻塞用户协程，这里是将其增加到全局队列 work.assistQueue（不能放到 P 协程队列，不然还会被调度）。什么时候再复原该用户协程的执行呢？当然是垃圾回收协程做了更多的工作之后，发现有用户协程因为申请内存过快被阻塞，解除的。
// 垃圾回收标记扫描主逻辑
func gcDrain(gcw *gcWork, flags gcDrainFlags) {
if gcw.heapScanWork > 0 {
if flushBgCredit {
//gcFlushBgCredit 函数更新全局现金池，复原阻塞的用户协程
gcFlushBgCredit(gcw.heapScanWork - initScanWork)
}
gcw.heapScanWork = 0
}
}清理
清理不是很简略吗？之前介绍过，mspan.allocBits 记录内存闲暇与否，0 示意闲暇，1 示意已调配；mspan.gcmarkBits 用户标记彩色和红色对象，0 示意红色也就是须要回收的对象，1 示意彩色对象，在三色标记实现之后，只须要 allocBits=gcmarkBits 就能够了（参考 sweepone 函数实现）。
首先清理是一个异步过程，并不是说三色标记实现之后，就清理所有的 mspan。分配内存的时候，从 mcentral 获取 mspan 的时候，如果没有清理则执行清理工作，清理之后如果有闲暇内存则返回；另外，垃圾回收启动的时候，也须要清理上一次标记后的所有 mspan。
怎么标记 mspan 有没有被清理呢？Go 语言应用字段 sweepgen 示意，这是一个整型，通过与全局的 mheap_.sweepgen 比拟，以此判断该 mspan 是否已被清理，判断形式如下：
// if sweepgen == h->sweepgen - 2, the span needs sweeping
// if sweepgen == h->sweepgen - 1, the span is currently being swept
// if sweepgen == h->sweepgen, the span is swept and ready to use
// if sweepgen == h->sweepgen + 1, the span was cached before sweep began and is still cached, and needs sweeping
// if sweepgen == h->sweepgen + 3, the span was swept and then cached and is still cached
// h->sweepgen is incremented by 2 after every GCsweep 就是清理的意思，gen 是第几代的缩写（generation）。正文说 h ->sweepgen 没开启一轮 GC，自增 2；假如初始 h ->sweepgen 等于 X，mspan.sweepgen 也等于 X（新申请的 mspan.sweepgen 间接赋值为 h ->sweepgen），依据下面形容，该 mspan 曾经清理能够应用；开启新一轮 GC 后，h->sweepgen 等于 X +2，满足第一个条件，阐明该 mspan 须要被清理。设计的还是十分奇妙的，不然还须要设法保护每一个 mspan 的清理状。
清理 mspan 是有可能并发执行的，用户协程申请内存时就有可能执行清理工作，所以清理 mspan 也是须要加锁的（基于 cas），上面是获取待清理 mspan 逻辑：
func (l *sweepLocker) tryAcquire(s *mspan) (sweepLocked, bool) {
// 状态非待清理
if atomic.Load(&s.sweepgen) != l.sweepGen-2 {return sweepLocked{}, false
}
// 设置状态为清理中
if !atomic.Cas(&s.sweepgen, l.sweepGen-2, l.sweepGen-1) {return sweepLocked{}, false
}
return sweepLocked{s}, true
}
// 获取 mspan 执行清理的过程
if s, ok := sl.tryAcquire(s); ok {if s.sweep(false)
}另外，如果 mspan 被缓存在 mcache 应用状况下，mspan.sweepgen 满足的是第四以及第五个条件；当 mspan 无可用内存调配时，会从 mcache 缓存删除，此时也会批改 mspan.sweepgen；另外在垃圾回收标记终止阶段，也会删除所有逻辑处理器 P 的 mcache（同样会批改 mspan.sweepgen）。所以不必放心缓存的 mspan 无奈被清理。
最初，还记得 mcentral 的构造定义吗（如下）？partial 与 full 都是一个数组，数组长度为 2，都是一个数组索引的 mspan 曾经被清理，另一个数组索引的 mspan 还未被清理。那到底 partial[0] 是已被清理的，还是 partial[1] 是已被清理的呢？答案是不肯定。
type mcentral struct {
spanclass spanClass
//partial 存储有闲暇内存的 mspan
partial [2]spanSet // list of spans with a free object
//full 存储的 mspan 没有闲暇内存
full [2]spanSet // list of spans with no free objects
}咱们看看 Go 语言是如何获取已被清理和未清理的 mspan：
func (c *mcentral) partialUnswept(sweepgen uint32) *spanSet {return &c.partial[1-sweepgen/2%2]
}
func (c *mcentral) partialSwept(sweepgen uint32) *spanSet {return &c.partial[sweepgen/2%2]
}sweepgen 每次自增 2，只能是偶数；如 2、4、6、8，然而除以 2 之后，就有可能是奇数了，如 1、2、3、4。假如以后 sweepgen 等于 10，依据下面代码的计算形式，则本轮已清理的 mspan 都在 partial[1]，未清理的都在 partial[0]，开启下一轮之前，须要清理所有的 mspan，清理后的 mspan 都在 partial[1]；新一轮 GC 开启，h->sweepgen 自增 2 等于 12，依据下面代码的计算形式，已清理的 mspan 都在 partial[0]，未清理的都在 partial[1]（刚好 partial[1] 数组的 mspan 在新一轮 GC 标记扫描后，是须要被清理的）。
同样的，因为 h ->sweepgen 自增 2，已清理的 mspan 和未清理的 mspan，在数组 partial 和 full 的索引是轮询的，防止了每次开启 GC 后，还须要迁徙 mcentral 的所有 mspan。
总结
本篇文章次要介绍了垃圾回收的根本流程，包含垃圾回收工作协程的创立与调度，经典的 startTheworld/stopTheworld 问题，辅助标记是什么，清理过程（重点推敲 sweepgen 的设计思路）等等。更多细节还须要读者一直学习钻研。