go语言对linux内存释放,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进行释放和重新分配的。

内存释放