golang内存释放

Posted 考拉苑

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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进行释放和重新分配的。


以上是关于golang内存释放的主要内容,如果未能解决你的问题,请参考以下文章

【golang】内存逃逸常见情况和避免方式

golang中内存管理分配

golang中内存管理分配

golang如何打印内存内容

(十一)golang 内存分析

golang内存扩容