golang内存释放

一、前言

一般在golang运行完成初始化时，会创建专门的goroutine用于后台监控、定期任务，这其中也涉及到了强制垃圾回收、内存释放等任务。

// 主goroutine.
func main() {
    // ...

        // m0: 系统主线程
        // g0：主goroutine
        // m0、g0是比较特殊的 仅用于main goroutine的父goroutine 
    g.m.g0.racectx = 0

    if sys.PtrSize == 8 {  // 64bits 系统
        maxstacksize = 1000000000
    } else {   // 32bits系统
        maxstacksize = 250000000
    }

    // 新建M(物理线程)
    mainStarted = true

    if GOARCH != "wasm" { // 没有线程在wasm 没必要进行系统监控的
        systemstack(func() {
            newm(sysmon, nil)
        })
    }

     
        // 在初始化时将main goroutine与系统主线程锁定
    lockOSThread()

    if g.m != &m0 {
        throw("runtime.main not on m0")
    }

    runtime_init() // 初始化
    if nanotime() == 0 {
        throw("nanotime returning zero")
    }
        // ...
}

从上面的源码可以看到在运行初始化期间通过newm(sysmon，nil)来开启一些系统监控。接下来看看sysmon的源码

// 通常该方法执行时没有关联的P(上下文环境) 以至于写屏蔽的是不允许的
// 一般来说golang中goroutine都会有与之关联的P记录上下文
func sysmon() {
    // ...
    
        // 当一块堆内存块在一次垃圾回收后5分钟没有被使用 则会被归还操作系统
    scavengelimit := int64(5 * 60 * 1e9) // 堆内存归还给操作系统时限: 5分钟

    if debug.scavenge > 0 {
        // Scavenge-a-lot for testing.
        forcegcperiod = 10 * 1e6
        scavengelimit = 20 * 1e6
    }

    lastscavenge := nanotime()   // 最后执行时间
    nscavenge := 0                      // 执行次数统计

    lasttrace := int64(0)  // 最近一次追踪
    idle := 0 // 记录没有唤醒的次数
    delay := uint32(0)
    for {
        if idle == 0 { // 默认延迟20us
            delay = 20
        } else if idle > 50 { // 当超过1ms 延迟时间加倍 *2
            delay *= 2
        }
              // 延迟最大=10ms(当延迟时间超过了10ms) 
        if delay > 10*1000 {  
            delay = 10 * 1000
        }
        usleep(delay) // 延迟delay执行GC    
        now := nanotime()
        // ...
        
        // 是否需要强制GC
        if t := (gcTrigger{kind: gcTriggerTime, now: now});
                   t.test() && atomic.Load(&forcegc.idle) != 0 {
            lock(&forcegc.lock)
            forcegc.idle = 0
            forcegc.g.schedlink = 0
            injectglist(forcegc.g)
            unlock(&forcegc.lock)
        }
        // 检查并释放物理内存 
        if lastscavenge+scavengelimit/2 < now {
            mheap_.scavenge(int32(nscavenge), uint64(now), uint64(scavengelimit))
            lastscavenge = now
            nscavenge++
        }
        // ......
    }
}

二、闲置内存

在进行内存释放时，其实针对的是闲置内存(被堆heap管理、尚未被中间部件mcentral或大对象使用的内存块)，而这些内存有可能长时间不使用，那么就应该释放掉其占有的物理内存，节约系统资源。在golang本身对内存管理对象使用两个计数器：unusedsince闲置起始时间 npreleased释放归还os的页数

type  mspan struct{
  unusedsince int64  // 首次被发现当前span状态=mspanfree
  npreleased   uintptr // 归还给os的页数
}

其中内存块获取和归还操作时内存管理对象的计数器会被重置

// 根据指定大小分配空间，新分配的span会从freelist被移除代表该span已被使用
// 但是该span状态仍是=mspanfree(这一点需要注意)
func (h *mheap) allocSpanLocked(npage uintptr, stat *uint64) *mspan{
  // ......省略代码
  HaveSpan:
    // 刚被分配的span 状态=mspanfree
    if s.state != _MSpanFree {
        throw("MHeap_AllocLocked - MSpan not free")
    }
    if s.npages < npage {
        throw("MHeap_AllocLocked - bad npages")
    }
    if s.npreleased > 0 {
               // 已使用空间span
        sysUsed(unsafe.Pointer(s.base()), s.npages<<_PageShift) 
               // 内存统计：堆heap释放的内存
        memstats.heap_released -= uint64(s.npreleased << _PageShift)
        s.npreleased = 0
    }
        if s.npages > npage { // 申请的空间span页数 低于该空间的页数 需要进行裁剪
        // 进行多余空间裁剪 并归还给heap堆
        t := (*mspan)(h.spanalloc.alloc())
                // 更新裁剪的span
        t.init(s.base()+npage<<_PageShift, s.npages-npage)
        s.npages = npage
        p := (t.base() - h.arena_start) >> _PageShift
        if p > 0 {
            h.spans[p-1] = s
        }
        h.spans[p] = t
        h.spans[p+t.npages-1] = t
        t.needzero = s.needzero
        s.state = _MSpanManual // 防止与s结合
        t.state = _MSpanManual
        h.freeSpanLocked(t, false, false, s.unusedsince)
        s.state = _MSpanFree
    }
    s.unusedsince = 0
    
   // ......省略代码
}

// s：需要属于busy list或者没有任何引用
func (h *mheap) freeSpanLocked(s *mspan, acctinuse, acctidle bool, unusedsince int64){
  // ......省略代码

  // 标记最新未被使用的空间span
  // GC则会根据这些信息将一些页归还给OS
   s.unusedsince = unusedsince
   if unusedsince == 0 {
    s.unusedsince = nanotime()
   }
   s.npreleased = 0

  // ......省略代码 
}

在归还操作过程中，可能存在局部释放的情况：当内存空间释放了对应的物理内存，假设此时npreleased == npages，不过一旦该内存块与其他内存块进行合并，就会导致npreleased < npages.

2.1 释放

在内存分配过程中：<128页的可用内存是放置在free链表数组中，而>=128页的可用内存则是通过树堆freelarge来存储的，也就是说释放操作其实针对的就是这两个列表。

// 释放指定内存块
// 一旦仍持有堆heap锁 无论是malloc操作还是发生panic都不会产生
// 主要因为这是mheap接口的non-mallocgc入口
// now：超时判断的基准时间(首次被标记为垃圾的内存块的时间会与该时间进行比较)
// limit： now - unusedsince与该超时阈值比较 超过都可释放(默认时间5分钟)
func (h *mheap) scavenge(k int32, now, limit uint64) {
    // ......省略代码
    var sumreleased uintptr
    for i := 0; i < len(h.free); i++ {
        sumreleased += scavengelist(&h.free[i], now, limit)
    }
    sumreleased += scavengetreap(h.freelarge.treap, now, limit)
    unlock(&h.lock)
    gp.m.mallocing--

        // 输出统计结果
    if debug.gctrace > 0 {
        if sumreleased > 0 {
            print("scvg", k, ": ", sumreleased>>20, " MB released\n")
        }
        // ......省略代码
    }
}

真正的比较操作，确认符合释放要求的内存块

func scavengelist(list *mSpanList, now, limit uint64) uintptr {
    if list.isEmpty() { // 跳过空链表
        return 0
    }

    var sumreleased uintptr
        // 遍历链表内所有的span
    for s := list.first; s != nil; s = s.next {
                // 忽略不符合释放条件的: 已被释放的、闲置时间小于limit的
        if (now-uint64(s.unusedsince)) <= limit || s.npreleased == s.npages {
            continue
        }
              
                // 统计要释放的空间
        start := s.base()
        end := start + s.npages<<_PageShift
                // 物理页大小 过大，超过指定的系统页大小
                // 需要保证释放范围end-start在物理页内存块范围内
                //  否则可能超过所需要释放的范围 超出我们实际需要的释放空间
        if physPageSize > _PageSize {
            start = (start + physPageSize - 1) &^ (physPageSize - 1)
            end &^= physPageSize - 1
            if end <= start { // 忽略持续整个物理页的span
                continue
            }
        }
        len := end - start

                // 要释放的空间大小
        released := len - (s.npreleased << _PageShift)
        if physPageSize > _PageSize && released == 0 {
            continue
        }
        memstats.heap_released += uint64(released)
        sumreleased += released
                
                // 释放计数
        s.npreleased = len >> _PageShift
                // 释放物理内存(整块内存)
        sysUnused(unsafe.Pointer(start), len)
    }
    return sumreleased
}

而释放树堆freelarge里面的内存块，基本操作一致。到此那些内存可被释放？如何释放其物理内存等基本上有所了解，具体的释放因操作系统不同而异。

Unix类似的系统基本上都是通过madvise来建议内核解除物理内存映射，这样在保留虚拟内存的情况下，达到释放物理内存的目的。当这些内存被使用时，有内存来自动补齐对应所需的物理内存。

windows则不支持类似的机制，直接通过对应的系统API进行释放和重新分配的。

内存释放