清扫

  1. func gcSweep(mode gcMode) {
  2.     ...
  3.     //阻塞式
  4.     if !_ConcurrentSweep || mode == gcForceBlockMode {
  5.         // Special case synchronous sweep.
  6.         ...
  7.         // Sweep all spans eagerly.
  8.         for sweepone() != ^uintptr(0) {
  9.             sweep.npausesweep++
  10.         }
  11.         // Do an additional mProf_GC, because all 'free' events are now real as well.
  12.         mProf_GC()
  13.         mProf_GC()
  14.         return
  15.     }
  17.     // 并行式
  18.     // Background sweep.
  19.     lock(&sweep.lock)
  20.     if sweep.parked {
  21.         sweep.parked = false
  22.         ready(sweep.g, 0, true)
  23.     }
  24.     unlock(&sweep.lock)
  25. }

并行式清扫，在 GC 初始化的时候就会启动 bgsweep()，然后在后台一直循环

  1. func bgsweep(c chan int) {
  2.     sweep.g = getg()
  4.     lock(&sweep.lock)
  5.     sweep.parked = true
  6.     c <- 1
  7.     goparkunlock(&sweep.lock, "GC sweep wait", traceEvGoBlock, 1)
  9.     for {
  10.         for gosweepone() != ^uintptr(0) {
  11.             sweep.nbgsweep++
  12.             Gosched()
  13.         }
  14.         lock(&sweep.lock)
  15.         if !gosweepdone() {
  16.             // This can happen if a GC runs between
  17.             // gosweepone returning ^0 above
  18.             // and the lock being acquired.
  19.             unlock(&sweep.lock)
  20.             continue
  21.         }
  22.         sweep.parked = true
  23.         goparkunlock(&sweep.lock, "GC sweep wait", traceEvGoBlock, 1)
  24.     }
  25. }
  27. func gosweepone() uintptr {
  28.     var ret uintptr
  29.     systemstack(func() {
  30.         ret = sweepone()
  31.     })
  32.     return ret
  33. }

不管是阻塞式还是并行式，都是通过 sweepone()函数来做清扫工作的.内存管理都是基于 span 的，mheap 是一个全局的变量，所有分配的对象都会记录在 mheap 中。在标记的时候，我们只要找到对对象对应的 span 进行标记，清扫的时候扫描 span，没有标记的 span 就可以回收了。

  1. // sweeps one span
  2. // returns number of pages returned to heap, or ^uintptr(0) if there is nothing to sweep
  3. func sweepone() uintptr {
  4.     ...
  5.     for {
  6.         s := mheap_.sweepSpans[1-sg/2%2].pop()
  7.         ...
  8.         if !s.sweep(false) {
  9.             // Span is still in-use, so this returned no
  10.             // pages to the heap and the span needs to
  11.             // move to the swept in-use list.
  12.             npages = 0
  13.         }
  14.     }
  15. }
  17. // Sweep frees or collects finalizers for blocks not marked in the mark phase.
  18. // It clears the mark bits in preparation for the next GC round.
  19. // Returns true if the span was returned to heap.
  20. // If preserve=true, don't return it to heap nor relink in MCentral lists;
  21. // caller takes care of it.
  22. func (s *mspan) sweep(preserve bool) bool {
  23.     ...
  24. }