writePointer(slot, ptr): // ⚠️:slot现在指向的还是旧对象
    shade(ptr) //shade函数尝试改变指针的颜色-->改变ptr的颜色
    *slot = ptr

writePointer(slot, ptr) // ⚠️:slot现在指向的还是旧对象
  shade(*slot) //shade函数尝试改变指针的颜色-->改变(*slot)的颜色--->注意这个是*slot(旧对象),slot保存着它原先的保存的地址。
  *slot = ptr

 writePointer(slot, ptr): // ⚠️:slot现在指向的还是旧的对象
     shade(*slot) //旧对象标记为灰色。
     if current stack is grey: // The insertion part of the barrier is necessary while the calling goroutine's stack is grey.
         shade(ptr)
     *slot = ptr

type gcWork struct {
    wbuf1, wbuf2 *workbuf
    // ...
}
type workbuf struct {
    workbufhdr
    // obj是uintptr数组，用来存储扫描过程中发现的指针。
    obj [(_WorkbufSize - unsafe.Sizeof(workbufhdr{})) / goarch.PtrSize]uintptr
}
const _WorkbufSize = 2048 // 数组obj的容量为253。
    type workbufhdr struct {
      node lfnode 
      // nobj记录obj数组已使用的个数；当nobj==0表示缓存区为空，当nobj==缓存区长度时表示已满。
      nobj int
    }
            type lfnode struct {
                next    uint64
                pushcnt uint
            }

func greyobject(obj, base, off uintptr, span *mspan, gcw *gcWork, objIndex uintptr) {
  mbits := span.markBitsForIndex(objIndex)
  //...

  // If marked we have nothing to do.
  if mbits.isMarked() {
    return
  }
  // 在其所属的 mspan 中，将对应位置的 gcMark bitmap 位置为 1
  mbits.setMarked()

  // Mark span.
  arena, pageIdx, pageMask := pageIndexOf(span.base())
  if arena.pageMarks[pageIdx]&pageMask == 0 {
    atomic.Or8(&arena.pageMarks[pageIdx], pageMask)
  }

  // If this is a noscan object, fast-track it to black nstead of greying it.
  if span.spanclass.noscan() {
    gcw.bytesMarked += uint64(span.elemsize)
    return
  }

  //...

  // Queue the obj for scanning.
  // 将对象添加到当前 p 的本地队列
  if !gcw.putFast(obj) {
    gcw.put(obj)
  }
}

func gcStart(trigger gcTrigger) {
  //...
  //并发地处理剩余的未清扫/正在清扫的span(完成上一个垃圾收集的收尾工作)。
     // 如果我们是在后台模式下调用的，这种情况不应该发生，因为比例清扫应该刚刚完成了所有清扫工作，
     // 但四舍五入误差等可能会留下一些未清扫的 span。
     // 在强制模式下，这是必要的，因为GC可以在清扫周期的任何点被强制触发。
  for trigger.test() && sweepone() != ^uintptr(0) {
    sweep.nbgsweep++
  }

  //...
  //加锁
  semacquire(&worldsema)

  //启动与P的个数相同的标记协程
  gcBgMarkStartWorkers()

  //...
  //1.切换到g0后执行Stop the world操作
  systemstack(stopTheWorldWithSema)
  //2.在我们开始并发扫描之前完成清扫。
  systemstack(func() {
    finishsweep_m()
  })

  //...

  //3.限制标记协程占用CPU时间片的比例为趋近25%
  gcController.startCycle(now, int(gomaxprocs))

  //4.进入并发标记阶段并启用写屏障。
  setGCPhase(_GCmark)

  //...

  //5.标记所有活动的tinyalloc块。
    //因为我们正在从这些块中分配内存，所以它们需要像其他分配一样被标记为黑色。另一种选择是在每次从tiny块分配时将其变黑，这会减慢tiny分配器的速度。
  gcMarkTinyAllocs()

  atomic.Store(&gcBlackenEnabled, 1)

  //6.切换至g0，重新start the world
  systemstack(func() {
    now = startTheWorldWithSema(trace.enabled)
    //...
  })
  //...
  semrelease(&worldsema)
  //...
}

func gcBgMarkStartWorkers() {
  for gcBgMarkWorkerCount < gomaxprocs {
    go gcBgMarkWorker()

    notetsleepg(&work.bgMarkReady, -1)
    noteclear(&work.bgMarkReady)

    gcBgMarkWorkerCount++
  }
}

func gcBgMarkWorker() {
    gp := getg()
    node := new(gcBgMarkWorkerNode)
    gp.m.preemptoff = ""
    node.gp.set(gp)
    node.m.set(acquirem())
    // 唤醒外部的 for 循环
    notewakeup(&work.bgMarkReady)
    
    for {
        // 当前 g 阻塞至此，直到 gcController.findRunnableGCWorker 方法被调用，会将当前 g 唤醒
        gopark(func(g *g, nodep unsafe.Pointer) bool {
            node := (*gcBgMarkWorkerNode)(nodep)
            // ...
            // 将当前 g 包装成一个 node 添加到 gcBgMarkWorkerPool 中
            gcBgMarkWorkerPool.push(&node.node)
            return true
        }, unsafe.Pointer(node), waitReasonGCWorkerIdle, traceEvGoBlock, 0)
        // ...
    }
}

func (c *gcControllerState) startCycle(markStartTime int64, procs int) {
    //...

    // 计算后台标记利用率目标。总的来说，这可能不会完全准确。
    // 我们四舍五入专用工作线程的数量(+0.5，然后强转换为整形)，使利用率尽可能接近 25%。
    // 对于小的 GOMAXPROCS，这会引入太多误差，因此在这种情况下我们添加分数工作线程。
    totalUtilizationGoal := float64(procs) * gcBackgroundUtilization
    c.dedicatedMarkWorkersNeeded = int64(totalUtilizationGoal + 0.5)
    utilError := float64(c.dedicatedMarkWorkersNeeded)/totalUtilizationGoal - 1
    const maxUtilError = 0.3
    if utilError < -maxUtilError || utilError > maxUtilError {
        // 四舍五入使我们偏离目标超过 30%。对于 gcBackgroundUtilization 为 25%，
        // 这发生在 GOMAXPROCS<=3 或 GOMAXPROCS=6 时。启用分数工作线程进行补偿。
        if float64(c.dedicatedMarkWorkersNeeded) > totalUtilizationGoal {
            // 专用工作线程太多。
            c.dedicatedMarkWorkersNeeded--
        }
        // 计算出每个 P 需要额外执行标记任务的时间片比例
        c.fractionalUtilizationGoal = (totalUtilizationGoal - float64(c.dedicatedMarkWorkersNeeded)) / float64(procs)
    } else {
        c.fractionalUtilizationGoal = 0
    }

    //...

}

type P struct {
    //...
    gcFractionalMarkTime int64 // Nanoseconds in fractional mark worker (atomic)

    // gcMarkWorkerMode 是下一个标记工作线程运行的模式。
    // 也就是说，这用于与由 gcController.findRunnableGCWorker 选定用于立即执行的工作 Goroutine 进行通信。
    // 当调度其他 Goroutine 时，这个字段必须设置为 gcMarkWorkerNotWorker。
    gcMarkWorkerMode gcMarkWorkerMode

    // gcMarkWorkerStartTime 是最近一次标记工作线程开始运行的 nanotime() 时间。
    gcMarkWorkerStartTime int64
    //...
}

type gcControllerState struct{
  //...
  // markStartTime 是后台标记工作线程开始的绝对时间，以纳秒为单位。
  markStartTime int64
  //...
}

func gcMarkTinyAllocs() {
  assertWorldStopped()

  for _, p := range allp {
    c := p.mcache
    if c == nil || c.tiny == 0 {
      continue
    }
    _, span, objIndex := findObject(c.tiny, 0, 0)
    gcw := &p.gcw
    greyobject(c.tiny, 0, 0, span, gcw, objIndex)
  }
}

func schedule() {
//...
  // 获取一个标记协程
	if gp == nil && gcBlackenEnabled != 0 {
		gp = gcController.findRunnableGCWorker(_g_.m.p.ptr())
		if gp != nil {
			tryWakeP = true
		}
	}
//...
  // 调度执行标记协程
  execute(gp, inheritTime)
}

    func (c *gcControllerState) findRunnableGCWorker(_p_ *p) *g {
    //...
    	node := (*gcBgMarkWorkerNode)(gcBgMarkWorkerPool.pop())
    	if node == nil {
    		return nil
    	}
    //...
    	gp := node.gp.ptr()
    	casgstatus(gp, _Gwaiting, _Grunnable)
    //...
    	return gp
    }

func gcStart(trigger gcTrigger) {
  //...
  //启动与P的个数相同的标记协程
  gcBgMarkStartWorkers()
  //...
}
    func gcBgMarkStartWorkers() {
      for gcBgMarkWorkerCount < gomaxprocs {
        go gcBgMarkWorker()
      //...
      }
    }
        func gcBgMarkWorker() {
            // 将当前g包装成一个node，后续放入后台标记协程池(gcBgMarkWorkerPool)中
            gp := getg()
            node := new(gcBgMarkWorkerNode)
            gp.m.preemptoff = ""
            node.gp.set(gp)
            node.m.set(acquirem())

            for {
                gopark(func(g *g, nodep unsafe.Pointer) bool {
                    node := (*gcBgMarkWorkerNode)(nodep)
                    // ...
                    // 添加后台标记协程池(gcBgMarkWorkerPool)中
                    gcBgMarkWorkerPool.push(&node.node)
                    return true
                }, unsafe.Pointer(node), waitReasonGCWorkerIdle, traceEvGoBlock, 0)
                // ...
            }
        }

func gcBgMarkWorker() {
// 1.预生成标记协程一节已讨论
//...

	for {
// 1.预生成标记协程一节已讨论
//...
    systemstack(func() {
        // 将我们的 goroutine 标记为可抢占状态，以便其堆栈可以被扫描。
        // 这让两个标记工作者可以相互扫描（否则，它们将死锁）。
        // 我们不能修改 G 堆栈上的任何内容。然而，标记工作者的堆栈收缩是禁用的，
        // 因此读取 G 堆栈是安全的。
        casgstatus(gp, _Grunning, _Gwaiting)
        switch pp.gcMarkWorkerMode {
        default:
            throw("gcBgMarkWorker: unexpected gcMarkWorkerMode")
        case gcMarkWorkerDedicatedMode:
            // 先按照可抢占模式执行标记协程，倘若被抢占，则将抢占协程添加到全局队列中，之后再以不可抢占模式执行标记协程。
            gcDrain(&pp.gcw, gcDrainUntilPreempt|gcDrainFlushBgCredit)
            if gp.preempt {
                // 我们被抢占了。这是一个有用的信号，可以将所有g
                // 从运行队列中踢出，以便它可以在其他地方运行。
                if drainQ, n := runqdrain(pp); n > 0 {
                    lock(&sched.lock)
                    globrunqputbatch(&drainQ, int32(n))
                    unlock(&sched.lock)
                }
            }
            // 重新进入，这次没有抢占。
            gcDrain(&pp.gcw, gcDrainFlushBgCredit)
        case gcMarkWorkerFractionalMode:
            gcDrain(&pp.gcw, gcDrainFractional|gcDrainUntilPreempt|gcDrainFlushBgCredit)
        case gcMarkWorkerIdleMode:
            gcDrain(&pp.gcw, gcDrainIdle|gcDrainUntilPreempt|gcDrainFlushBgCredit)
        }
        casgstatus(gp, _Gwaiting, _Grunning)
    })
 //...
	}
}

func gcDrain(gcw *gcWork, flags gcDrainFlags) {
//...
  // 1. 在空闲模式（gcDrainIdle）和分时模式（gcDrainFractional）下，会提前设好检查函数（pollWork 和 pollFractionalWorkerExit）在执行下一个自我抢占检查之前的扫描工作量。

  // 2. 标记根对象
    //...
      markroot(gcw, job, flushBgCredit)
    //...

  // 3. for循环标记堆对象，直到达到退出条件
  for !(gp.preempt && (preemptible || atomic.Load(&sched.gcwaiting) != 0)) {
    // 尽量保持全局队列上有可用的工作。我们过去常常检查是否有等待的工作者，
    // 但最好是保持工作可用，而不是让工作者等待。在最坏的情况下，我们将进行
    // O(log(_WorkbufSize)) 不必要的平衡。
    if work.full == 0 {
      gcw.balance()
    }

    // 4. 循环从gcw缓存队列中取出灰色对象，执行scanObject方法进行扫描标记
		b := gcw.tryGetFast()
		if b == 0 {
			b = gcw.tryGet()
			if b == 0 {
				// 刷新写屏障缓冲区；这可能会创建更多的工作。
				wbBufFlush(nil, 0)
				b = gcw.tryGet()
			}
		}
		if b == 0 {
			// 无法获得工作。
			break
		}
		scanobject(b, gcw)

		// 如果我们在本地积累了足够的背景扫描工作信誉，则将其刷新到全局账户中，
		// 以便变异体辅助可以从中提取。
		if gcw.heapScanWork >= gcCreditSlack {
//...
			if checkWork <= 0 {
				checkWork += drainCheckThreshold
				if check != nil && check() {
					break
				}
			}
		}
	}
//...
}

func gcDrain(gcw *gcWork, flags gcDrainFlags) {
//...
  // 1. 在空闲模式（gcDrainIdle）和分时模式（gcDrainFractional）下，会提前设好检查函数（pollWork 和 pollFractionalWorkerExit）在执行下一个自我抢占检查之前的扫描工作量。
	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
		}
	}
//...
}
    func pollWork() bool {
        if sched.runqsize != 0 {
            return true
        }
        p := getg().m.p.ptr()
        if !runqempty(p) {
            return true
        }
        if netpollinited() && atomic.Load(&netpollWaiters) > 0 && sched.lastpoll != 0 {
            if list := netpoll(0); !list.empty() {
                injectglist(&list)
                return true
            }
        }
        return false
    }

func pollFractionalWorkerExit() bool {
    now := nanotime()
    delta := now - gcController.markStartTime
    if delta <= 0 {
        return true
    }
    p := getg().m.p.ptr()
    selfTime := p.gcFractionalMarkTime + (now - p.gcMarkWorkerStartTime)
   
    return float64(selfTime)/float64(delta) > 1.2*gcController.fractionalUtilizationGoal
}

func gcDrain(gcw *gcWork, flags gcDrainFlags) {
//...
  // 1. 在空闲模式（gcDrainIdle）和分时模式（gcDrainFractional）下，会提前设好检查函数（pollWork 和 pollFractionalWorkerExit）在执行下一个自我抢占检查之前的扫描工作量。
  // 2. 标记根对象
  if work.markrootNext < work.markrootJobs {
    // 如果我们是可抢占的或者有人想要STW，则停止。
    for !(gp.preempt && (preemptible || atomic.Load(&sched.gcwaiting) != 0)) {
      //...
      markroot(gcw, job, flushBgCredit)
      if check != nil && check() {
        goto done
      }
    }
  }
//...
}

func markroot(gcw *gcWork, i uint32, flushBgCredit bool) int64 {
//...
    switch {
    //1. 处理已初始化的全局变量
    case work.baseData <= i && i < work.baseBSS:
          //...
            workDone += markrootBlock(datap.data, datap.edata-datap.data, datap.gcdatamask.bytedata, gcw, int(i-work.baseData))
          //...
    //2. 处理未初始化的全局变量
    case work.baseBSS <= i && i < work.baseSpans:
          //...
            workDone += markrootBlock(datap.bss, datap.ebss-datap.bss, datap.gcbssmask.bytedata, gcw, int(i-work.baseBSS))
          //...
    //3. 处理finalizer队列
    case i == fixedRootFinalizers:
          //...
            scanblock(uintptr(unsafe.Pointer(&fb.fin[0])), cnt*unsafe.Sizeof(fb.fin[0]), &finptrmask[0], gcw, nil)
          //...
    //4. 释放已终止的g的栈
    case i == fixedRootFreeGStacks:
        systemstack(markrootFreeGStacks)
    //5. 扫描mspan中的special
    case work.baseSpans <= i && i < work.baseStacks:
        markrootSpans(gcw, int(i-work.baseSpans))
    default:
        // ...
        // 获取需要扫描的g
        gp := work.stackRoots[i-work.baseStacks]
        // ...
        // 切回到 g0执行工作，扫描 g 的栈
        systemstack(func() {
            // ...
    //6. 栈扫描
            workDone += scanstack(gp, gcw)
           // ...
        })
    }
    // ...
    return workDone
}

func markrootBlock(b0, n0 uintptr, ptrmask0 *uint8, gcw *gcWork, shard int) int64 {
//...
  scanblock(b, n, ptrmask, gcw, nil)
//...
}

func scanstack(gp *g, gcw *gcWork) int64 {
  // ...
  scanframe := func(frame *stkframe, unused unsafe.Pointer) bool {
    scanframeworker(frame, &state, gcw)
    return true
  }
  // ...
}
    func scanframeworker(frame *stkframe, state *stackScanState, gcw *gcWork) {
        // ...
        // 扫描局部变量
        if locals.n > 0 {
            //...
            scanblock(frame.varp-size, size, locals.bytedata, gcw, state)
        }
        // 扫描函数参数
        if args.n > 0 {
            scanblock(frame.argp, uintptr(args.n)*goarch.PtrSize, args.bytedata, gcw, state)
        }
        // ...
    }

func scanblock(b0, n0 uintptr, ptrmask *uint8, gcw *gcWork, stk *stackScanState) {
	// 使用原始参数的本地副本，便于调试时查看原始块的基址和范围
	b := b0
	n := n0
	for i := uintptr(0); i < n; {
		// 获取下一个字的位图
		bits := uint32(*addb(ptrmask, i/(goarch.PtrSize*8)))
		if bits == 0 {
			i += goarch.PtrSize * 8
			continue
		}
		for j := 0; j < 8 && i < n; j++ {
			if bits&1 != 0 {
				// 与 scanobject 中的工作相同；参见那里的注释
				p := *(*uintptr)(unsafe.Pointer(b + i))
				if p != 0 {
					if obj, span, objIndex := findObject(p, b, i); obj != 0 {
						greyobject(obj, b, i, span, gcw, objIndex)
            //...
				}
			}
			bits >>= 1
			i += goarch.PtrSize
		}
	}
}

func gcDrain(gcw *gcWork, flags gcDrainFlags) {
//...
  // 1. 在空闲模式（gcDrainIdle）和分时模式（gcDrainFractional）下，会提前设好检查函数（pollWork 和 pollFractionalWorkerExit）在执行下一个自我抢占检查之前的扫描工作量。
  // 2. 标记根对象
  // 3. for循环标记堆对象，直到达到退出条件
  for !(gp.preempt && (preemptible || atomic.Load(&sched.gcwaiting) != 0)) {
    //...
  // 4. 循环从gcw缓存队列中取出灰色对象，执行scanObject方法进行扫描标记
      //...
        // 刷新写屏障缓冲区；这可能会创建更多的工作。
          wbBufFlush(nil, 0)
      scanobject(b, gcw)
      // 如果我们在本地积累了足够的背景扫描工作信誉，则将其刷新到全局账户中，
      //...

func scanobject(b uintptr, gcw *gcWork) {
//...
    // 找到 b 的位图信息和 b 处对象的大小。
    //
    // b 要么是对象的开始，要么指向对象片段的开始，
    // 在这种情况下，我们会在下面计算扫描的大小。
    hbits := heapBitsForAddr(b)
    s := spanOfUnchecked(b)
    n := s.elemsize
//...
    var i uintptr
    for i = 0; i < n; i, hbits = i+goarch.PtrSize, hbits.next() {
        // 加载一次位图信息。
        bits := hbits.bits()
        if bits&bitScan == 0 {
            break // 这个对象中没有更多指针
        }
        if bits&bitPointer == 0 {
            continue // 不是指针
        }

        obj := *(*uintptr)(unsafe.Pointer(b + i))

        // 此时我们已经提取了下一个可能的指针。
        // 快速筛选出空指针和指向当前对象的指针。
        if obj != 0 && obj-b >= n {
            // 检查 obj 是否指向 Go 堆中，如果是，则标记对象。
            // 注意，如果 obj 指向一个刚分配的堆对象，findObject 可能会失败，
            // 因为与增加堆空间的操作存在竞争。在这种情况下，我们知道对象刚刚分配，因此会在分配时标记对象。
            if obj, span, objIndex := findObject(obj, b, i); obj != 0 {
                greyobject(obj, b, i, span, gcw, objIndex)
            }
        }
    }
//...
}

// 在垃圾回收期间分配黑色对象。
// 所有槽位都持有 nil，因此不需要扫描。
func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
        // ...
        if gcphase != _GCoff {
            gcmarknewobject(span, uintptr(x), size, scanSize)
        }
        // ...
}

func gcmarknewobject(span *mspan, obj, size, scanSize uintptr) {
//...
	// 标记对象。
	objIndex := span.objIndex(obj)
	span.markBitsForIndex(objIndex).setMarked()

	// 标记跨度。
	arena, pageIdx, pageMask := pageIndexOf(span.base())
  //pageMarks指示哪些跨度（spans）上有任何已标记的对象。
  // 像pageInUse 一样，只有每个跨度的第一个页面对应的位被使用。
	if arena.pageMarks[pageIdx]&pageMask == 0 {
		atomic.Or8(&arena.pageMarks[pageIdx], pageMask)
	}

	gcw := &getg().m.p.ptr().gcw
	gcw.bytesMarked += uint64(size)
//...
}

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
    // ...
    var assistG *g
    if gcBlackenEnabled != 0 {       
        assistG = getg()
        if assistG.m.curg != nil {
            assistG = assistG.m.curg
        }
        // 每个 g 会有资产
        assistG.gcAssistBytes -= int64(size)

        if assistG.gcAssistBytes < 0 {           
            gcAssistAlloc(assistG)
        }
    }
}
  func gcAssistAlloc(gp *g) {
      // Step 1: 确定负债额度
      debtBytes := -gp.gcAssistBytes

      // Step 2: 计算预期需要扫描的大小
      scanWork := debtBytes * assistWorkPerByte

      // Step 3: 检查预期扫描工作量是否低于最小扫描工作量
      if scanWork < gcOverAssistWork {
          scanWork = gcOverAssistWork
      }

      // 后续代码：执行实际的扫描工作
      // ...
  }

if gp.gcAssistBytes < 0 {
    debtBytes := -gp.gcAssistBytes
}

scanWork := debtBytes * assistWorkPerByte

if scanWork < gcOverAssistWork {
    scanWork = gcOverAssistWork
}

func gcAssistAlloc(gp *g) {
//...
    // Step 4: 尝试从全局的可用资产中偷取信用额度
    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 {
            return
        }
    }
//...
}

func gcBgMarkWorker() {
// 1.预生成标记协程一节已讨论
//...
  for {
// 1.预生成标记协程一节已讨论
//...
// 2.标记协程
//...
// 3.标记终止
    if incnwait == work.nproc && !gcMarkWorkAvailable(nil) {
        // ...
        gcMarkDone()
    }
  }
}

func gcMarkDone() {
    // 确保只有一个线程在运行
    semacquire(&work.markDoneSema)
top:
    // 重新检查过渡条件
    //...
    // 获取 worldsema 信号量
    semacquire(&worldsema)
    // 刷新所有本地缓冲区并收集flushedWork标志
    //...
    systemstack(func() {
        gp := getg().m.curg
        casgstatus(gp, _Grunning, _Gwaiting)
        forEachP(func(_p_ *p) {
            wbBufFlush1(_p_)
            _p_.gcw.dispose()
            if _p_.gcw.flushedWork {
                atomic.Xadd(&gcMarkDoneFlushed, 1)
                _p_.gcw.flushedWork = false
            }
        })
        casgstatus(gp, _Gwaiting, _Grunning)
    })
    // 重新检查过渡条件
    if (gcMarkDoneFlushed != 0) {
        semrelease(&worldsema)
        goto top
    }
    // 进入标记终止阶段
    //...
//第二次STW
    systemstack(stopTheWorldWithSema)
    // 检查是否有残留工作需要处理，如果有，返回，重新STW
    //...
    // 禁用GC助力和后台工作线程
    atomic.Store(&gcBlackenEnabled, 0)
    // 唤醒所有被阻塞的线程
    gcWakeAllAssists()
    //...
    // 允许用户goroutine重新执行
    schedEnableUser(true)
    // 结束GC周期并进行标记终止
    //...
    gcMarkTermination(nextTriggerRatio)
}

func gcMarkTermination() {
  //1.设置GC标志为:标记终止
  setGCPhase(_GCmarktermination)
  //...
  systemstack(func() {
     //...
  //2.设置GC标志为:标记关闭
      setGCPhase(_GCoff)  
  //3.唤醒后台清扫协程,开始进行标记清扫
      gcSweep(work.mode)
  })
  //4.提交下一轮GC的内存阈值
  systemstack(gcControllerCommit)
  //...
// 第二次STW后【start the world】
  systemstack(func() { startTheWorldWithSema(true) })
  //...
}

func gcSweep(mode gcMode) {
//...

  // Background sweep.
  lock(&sweep.lock)
  if sweep.parked {
    weep.parked = false
    ready(sweep.g, 0, true)
  }
  unlock(&sweep.lock)
}

func main() {
    // ...
    gcenable()
    // ...
}
func gcenable() {
    // ...
    go bgsweep(c)
    <-c
    // ...
}

func bgsweep(c chan int) {
// 1. 获取g对象存入sweep中
  sweep.g = getg()
  lockInit(&sweep.lock, lockRankSweep)
  lock(&sweep.lock)
  sweep.parked = true
  c <- 1
// 2. 进行休眠
  goparkunlock(&sweep.lock, waitReasonGCSweepWait, traceEvGoBlock, 1)
// 3. 唤醒后继续执行
  for {
    // 3.1. 进行循环中持续清扫对象
    for sweepone() != ^uintptr(0) {
      sweep.nbgsweep++
    // 3.2. 每轮完成一个mspan的清扫工作后调用Gosched方法,主动让渡P的执行权
      Gosched()
    }
    //...
  }
}

func sweepone() uintptr {
    // ...
    sl := sweep.active.begin()
    // ...
    for {
        // 查找到一个待清扫的 mspan
        s := mheap_.nextSpanForSweep()
        // ...
        if s, ok := sl.tryAcquire(s); ok {
            npages = s.npages
            // 对一个mspan进行清扫!!!
            if s.sweep(false) {
                // 增加信用值
                mheap_.reclaimCredit.Add(npages)
            } else {
                npages = 0
            }
            break
        }
    }
    sweep.active.end(sl)
    // ...
    return npages
}
func (sl *sweepLocked) sweep(preserve bool) bool {
    //...

    s.allocCount = nalloc
    s.freeindex = 0 // 设置指向下一个空闲对象的索引为0
    s.freeIndexForScan = 0
    //...

    // gcmarkBits赋给allocBits
    // 生成新的gcmarkBits，为下一次GC做准备
    s.allocBits = s.gcmarkBits
    s.gcmarkBits = newMarkBits(s.nelems)

    // Initialize alloc bits cache.
    s.refillAllocCache(0)
    // ...
}