finalizer是与对象关联的一个函数,通过runtime.SetFinalizer 来设置,它在对象被GC的时候,这个finalizer会被调用,以完成对象生命中最后一程。由于finalizer的存在,导致了对象在三色标记中,不可能被标为白色对象,也就是垃圾,所以,这个对象的生命也会得以延续一个GC周期。正如defer一样,我们也可以通过 Finalizer 完成一些类似于资源释放的操作

1. 结构概览

1.1. heap

type mspan struct {
 // 当前span上所有对象的special串成链表
 // special中有个offset,就是数据对象在span上的offset,通过offset,将数据对象和special关联起来
 specials *special // linked list of special records sorted by offset.
}

1.2. special

type special struct {
 next *special // linked list in span
 // 数据对象在span上的offset
 offset uint16 // span offset of object
 kind byte // kind of special
}

1.3. specialfinalizer

type specialfinalizer struct {
 special special
 fn *funcval // May be a heap pointer.
 // return的数据的大小
 nret uintptr
 // 第一个参数的类型
 fint *_type // May be a heap pointer, but always live.
 // 与finalizer关联的数据对象的指针类型
 ot *ptrtype // May be a heap pointer, but always live.
}

1.4. finalizer

type finalizer struct {
 fn *funcval // function to call (may be a heap pointer)
 arg unsafe.Pointer // ptr to object (may be a heap pointer)
 nret uintptr // bytes of return values from fn
 fint *_type // type of first argument of fn
 ot *ptrtype // type of ptr to object (may be a heap pointer)
}

1.5. 全局变量

var finlock mutex // protects the following variables
// 运行finalizer的g,只有一个g,不用的时候休眠,需要的时候再唤醒
var fing *g // goroutine that runs finalizers
// finalizer的全局队列,这里是已经设置的finalizer串成的链表
var finq *finblock // list of finalizers that are to be executed
// 已经释放的finblock的链表,用finc缓存起来,以后需要使用的时候可以直接取走,避免再走一遍内存分配了
var finc *finblock // cache of free blocks
var finptrmask [_FinBlockSize / sys.PtrSize / 8]byte
var fingwait bool // fing的标志位,通过 fingwait和fingwake,来确定是否需要唤醒fing
var fingwake bool
// 所有的blocks串成的链表
var allfin *finblock // list of all blocks

2. 源码分析

2.1. 创建finalizer

2.1.1. main

func main() {
 // i 就是后面说的 数据对象
 var i = 3
 // 这里的func 就是后面一直说的 finalizer
 runtime.SetFinalizer(&i, func(i *int) {
 fmt.Println(i, *i, "set finalizer")
 })
 time.Sleep(time.Second * 5)
}

2.1.2. SetFinalizer

根据 数据对象 ,生成一个special对象,并绑定到 数据对象 所在的span,串联到span.specials上,并且确保fing的存在

func SetFinalizer(obj interface{}, finalizer interface{}) {
 if debug.sbrk != 0 {
 // debug.sbrk never frees memory, so no finalizers run
 // (and we don't have the data structures to record them).
 return
 }
 e := efaceOf(&obj)
 etyp := e._type
 // ---- 省略数据校验的逻辑 ---
 ot := (*ptrtype)(unsafe.Pointer(etyp))
 // find the containing object
 // 在内存中找不到分配的地址时 base==0,setFinalizer 是在内存回收的时候调用,没有分配就不会回收
 base, _, _ := findObject(uintptr(e.data), 0, 0)
 f := efaceOf(&finalizer)
 ftyp := f._type
 // 如果 finalizer type == nil,尝试移除(没有的话,就不需要移除了)
 if ftyp == nil {
 // switch to system stack and remove finalizer
 systemstack(func() {
 removefinalizer(e.data)
 })
 return
 }
 // --- 对finalizer参数数量及类型进行校验 --
 if ftyp.kind&kindMask != kindFunc {
 throw("runtime.SetFinalizer: second argument is " + ftyp.string() + ", not a function")
 }
 ft := (*functype)(unsafe.Pointer(ftyp))
 if ft.dotdotdot() {
 throw("runtime.SetFinalizer: cannot pass " + etyp.string() + " to finalizer " + ftyp.string() + " because dotdotdot")
 }
 if ft.inCount != 1 {
 throw("runtime.SetFinalizer: cannot pass " + etyp.string() + " to finalizer " + ftyp.string())
 }
 fint := ft.in()[0]
 switch {
 case fint == etyp:
 // ok - same type
 goto okarg
 case fint.kind&kindMask == kindPtr:
 if (fint.uncommon() == nil || etyp.uncommon() == nil) && (*ptrtype)(unsafe.Pointer(fint)).elem == ot.elem {
 // ok - not same type, but both pointers,
 // one or the other is unnamed, and same element type, so assignable.
 goto okarg
 }
 case fint.kind&kindMask == kindInterface:
 ityp := (*interfacetype)(unsafe.Pointer(fint))
 if len(ityp.mhdr) == 0 {
 // ok - satisfies empty interface
 goto okarg
 }
 if _, ok := assertE2I2(ityp, *efaceOf(&obj)); ok {
 goto okarg
 }
 }
 throw("runtime.SetFinalizer: cannot pass " + etyp.string() + " to finalizer " + ftyp.string())
okarg:
 // compute size needed for return parameters
 // 计算返回参数的大小并进行对齐
 nret := uintptr(0)
 for _, t := range ft.out() {
 nret = round(nret, uintptr(t.align)) + uintptr(t.size)
 }
 nret = round(nret, sys.PtrSize)
 // make sure we have a finalizer goroutine
 // 确保 finalizer 有一个 goroutine
 createfing()
 systemstack(func() {
 // 却换到g0,添加finalizer,并且不能重复设置
 if !addfinalizer(e.data, (*funcval)(f.data), nret, fint, ot) {
 throw("runtime.SetFinalizer: finalizer already set")
 }
 })
}

这里逻辑没什么复杂的,只是在参数、类型的判断等上面,比较的麻烦

2.1.3. removefinalizer

通过removespecial,找到数据对象p所对应的special对象,如果找到的话,释放mheap上对应的内存

func removefinalizer(p unsafe.Pointer) {
 // 根据数据p找到对应的special对象
 s := (*specialfinalizer)(unsafe.Pointer(removespecial(p, _KindSpecialFinalizer)))
 if s == nil {
 return // there wasn't a finalizer to remove
 }
 lock(&mheap_.speciallock)
 // 释放找到的special所对应的内存
 mheap_.specialfinalizeralloc.free(unsafe.Pointer(s))
 unlock(&mheap_.speciallock)
}

这里的函数,虽然叫removefinalizer, 但是这里暂时跟finalizer结构体没有关系,都是在跟special结构体打交道,后面的addfinalizer也是一样的

2.1.4. removespecial

遍历数据所在的span的specials,如果找到了指定数据p的special的话,就从specials中移除,并返回

func removespecial(p unsafe.Pointer, kind uint8) *special {
 // 找到数据p所在的span
 span := spanOfHeap(uintptr(p))
 if span == nil {
 throw("removespecial on invalid pointer")
 }
 // Ensure that the span is swept.
 // Sweeping accesses the specials list w/o locks, so we have
 // to synchronize with it. And it's just much safer.
 mp := acquirem()
 // 保证span被清扫过了
 span.ensureSwept()
 // 获取数据p的偏移量,根据偏移量去寻找p对应的special
 offset := uintptr(p) - span.base()
 lock(&span.speciallock)
 t := &span.specials
 // 遍历span.specials这个链表
 for {
 s := *t
 if s == nil {
 break
 }
 // This function is used for finalizers only, so we don't check for
 // "interior" specials (p must be exactly equal to s->offset).
 if offset == uintptr(s.offset) && kind == s.kind {
 // 找到了,修改指针,将当前找到的special移除
 *t = s.next
 unlock(&span.speciallock)
 releasem(mp)
 return s
 }
 t = &s.next
 }
 unlock(&span.speciallock)
 releasem(mp)
 // 没有找到,就返回nil
 return nil
}

2.1.5. addfinalizer

正好跟removefinalizer相反,这个就是根据数据对象p,创建对应的special,然后添加到span.specials链表上面

func addfinalizer(p unsafe.Pointer, f *funcval, nret uintptr, fint *_type, ot *ptrtype) bool {
 lock(&mheap_.speciallock)
 // 分配出来一块内存供finalizer使用
 s := (*specialfinalizer)(mheap_.specialfinalizeralloc.alloc())
 unlock(&mheap_.speciallock)
 s.special.kind = _KindSpecialFinalizer
 s.fn = f
 s.nret = nret
 s.fint = fint
 s.ot = ot
 if addspecial(p, &s.special) {
 return true
 }
 // There was an old finalizer
 // 没有添加成功,是因为p已经有了一个special对象了
 lock(&mheap_.speciallock)
 mheap_.specialfinalizeralloc.free(unsafe.Pointer(s))
 unlock(&mheap_.speciallock)
 return false
}

2.1.6. addspecial

这里是添加special的主逻辑

func addspecial(p unsafe.Pointer, s *special) bool {
 span := spanOfHeap(uintptr(p))
 if span == nil {
 throw("addspecial on invalid pointer")
 }
 // 同 removerspecial一样,确保这个span已经清扫过了
 mp := acquirem()
 span.ensureSwept()
 offset := uintptr(p) - span.base()
 kind := s.kind
 lock(&span.speciallock)
 // Find splice point, check for existing record.
 t := &span.specials
 for {
 x := *t
 if x == nil {
 break
 }
 if offset == uintptr(x.offset) && kind == x.kind {
 // 已经存在了,不能在增加了,一个数据对象,只能绑定一个finalizer
 unlock(&span.speciallock)
 releasem(mp)
 return false // already exists
 }
 if offset < uintptr(x.offset) || (offset == uintptr(x.offset) && kind < x.kind) {
 break
 }
 t = &x.next
 }
 // Splice in record, fill in offset.
 // 添加到 specials 队列尾
 s.offset = uint16(offset)
 s.next = *t
 *t = s
 unlock(&span.speciallock)
 releasem(mp)
 return true
}

2.1.7. createfing

这个函数是保证,创建了finalizer之后,有一个goroutine去运行,这里只运行一次,这个goroutine会由全局变量 fing 记录

func createfing() {
 // start the finalizer goroutine exactly once
 // 进创建一个goroutine,进行时刻监控运行
 if fingCreate == 0 && atomic.Cas(&fingCreate, 0, 1) {
 // 开启一个goroutine运行
 go runfinq()
 }
}

2.2. 执行finalizer

在上面的 createfing 的会尝试创建一个goroutine去执行,接下来就分析一下执行流程吧

func runfinq() {
 var (
 frame unsafe.Pointer
 framecap uintptr
 )
 for {
 lock(&finlock)
 // 获取finq 全局队列,并清空全局队列
 fb := finq
 finq = nil
 if fb == nil {
 // 如果全局队列为空,休眠当前g,等待被唤醒
 gp := getg()
 fing = gp
 // 设置fing的状态标志位
 fingwait = true
 goparkunlock(&finlock, waitReasonFinalizerWait, traceEvGoBlock, 1)
 continue
 }
 unlock(&finlock)
 // 循环执行runq链表里的fin数组
 for fb != nil {
 for i := fb.cnt; i > 0; i-- {
 f := &fb.fin[i-1]
 // 获取存储当前finalizer的返回数据的大小,如果比之前大,则分配
 framesz := unsafe.Sizeof((interface{})(nil)) + f.nret
 if framecap < framesz {
 // The frame does not contain pointers interesting for GC,
 // all not yet finalized objects are stored in finq.
 // If we do not mark it as FlagNoScan,
 // the last finalized object is not collected.
 frame = mallocgc(framesz, nil, true)
 framecap = framesz
 }
 if f.fint == nil {
 throw("missing type in runfinq")
 }
 // frame is effectively uninitialized
 // memory. That means we have to clear
 // it before writing to it to avoid
 // confusing the write barrier.
 // 清空frame内存存储
 *(*[2]uintptr)(frame) = [2]uintptr{}
 switch f.fint.kind & kindMask {
 case kindPtr:
 // direct use of pointer
 *(*unsafe.Pointer)(frame) = f.arg
 case kindInterface:
 ityp := (*interfacetype)(unsafe.Pointer(f.fint))
 // set up with empty interface
 (*eface)(frame)._type = &f.ot.typ
 (*eface)(frame).data = f.arg
 if len(ityp.mhdr) != 0 {
 // convert to interface with methods
 // this conversion is guaranteed to succeed - we checked in SetFinalizer
 *(*iface)(frame) = assertE2I(ityp, *(*eface)(frame))
 }
 default:
 throw("bad kind in runfinq")
 }
 // 调用finalizer函数
 fingRunning = true
 reflectcall(nil, unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz))
 fingRunning = false
 // Drop finalizer queue heap references
 // before hiding them from markroot.
 // This also ensures these will be
 // clear if we reuse the finalizer.
 // 清空finalizer的属性
 f.fn = nil
 f.arg = nil
 f.ot = nil
 atomic.Store(&fb.cnt, i-1)
 }
 // 将已经完成的finalizer放入finc以作缓存,避免再次分配内存
 next := fb.next
 lock(&finlock)
 fb.next = finc
 finc = fb
 unlock(&finlock)
 fb = next
 }
 }
}

看完上面的流程的时候,突然发现有点懵逼

1. 全局队列finq中是什么时候被插入数据 finalizer的?
2. g如果休眠了,那怎么被唤醒呢?

先针对第一个问题分析:

插入队列的操作,要追溯到我们之前分析的GC 深入理解Go-垃圾回收机制 了,在sweep 中有下面一段函数

2.2.1. sweep

func (s *mspan) sweep(preserve bool) bool {
 ....
 specialp := &s.specials
 special := *specialp
 for special != nil {
 ....
 if special.kind == _KindSpecialFinalizer || !hasFin {
 // Splice out special record.
 y := special
 special = special.next
 *specialp = special
 // 加入全局finq队列的入口就在这里了
 freespecial(y, unsafe.Pointer(p), size)
 }
 ....
 }
 ....
}

2.2.2. freespecial

在gc的时候,不仅要把special对应的内存释放掉,而且把specials整理创建对应dinalizer对象,并插入到 finq队列里面

func freespecial(s *special, p unsafe.Pointer, size uintptr) {
 switch s.kind {
 case _KindSpecialFinalizer:
 // 把这个finalizer加入到全局队列
 sf := (*specialfinalizer)(unsafe.Pointer(s))
 queuefinalizer(p, sf.fn, sf.nret, sf.fint, sf.ot)
 lock(&mheap_.speciallock)
 mheap_.specialfinalizeralloc.free(unsafe.Pointer(sf))
 unlock(&mheap_.speciallock)
 // 下面两种情况不在分析范围内,省略
 case _KindSpecialProfile:
 sp := (*specialprofile)(unsafe.Pointer(s))
 mProf_Free(sp.b, size)
 lock(&mheap_.speciallock)
 mheap_.specialprofilealloc.free(unsafe.Pointer(sp))
 unlock(&mheap_.speciallock)
 default:
 throw("bad special kind")
 panic("not reached")
 }
}

2.2.3. queuefinalizer

func queuefinalizer(p unsafe.Pointer, fn *funcval, nret uintptr, fint *_type, ot *ptrtype) {
 lock(&finlock)
 // 如果finq为空或finq的内部数组已经满了,则从finc或重新分配 来获取block并插入到finq的链表头
 if finq == nil || finq.cnt == uint32(len(finq.fin)) {
 if finc == nil {
 finc = (*finblock)(persistentalloc(_FinBlockSize, 0, &memstats.gc_sys))
 finc.alllink = allfin
 allfin = finc
 if finptrmask[0] == 0 {
 // Build pointer mask for Finalizer array in block.
 // Check assumptions made in finalizer1 array above.
 if (unsafe.Sizeof(finalizer{}) != 5*sys.PtrSize ||
 unsafe.Offsetof(finalizer{}.fn) != 0 ||
 unsafe.Offsetof(finalizer{}.arg) != sys.PtrSize ||
 unsafe.Offsetof(finalizer{}.nret) != 2*sys.PtrSize ||
 unsafe.Offsetof(finalizer{}.fint) != 3*sys.PtrSize ||
 unsafe.Offsetof(finalizer{}.ot) != 4*sys.PtrSize) {
 throw("finalizer out of sync")
 }
 for i := range finptrmask {
 finptrmask[i] = finalizer1[i%len(finalizer1)]
 }
 }
 }
 // 从finc中移除并获取链表头
 block := finc
 finc = block.next
 // 将从finc获取到的链表挂载到finq的队列头,finq指向新的block
 block.next = finq
 finq = block
 }
 // 根据finq.cnt获取索引对应的block
 f := &finq.fin[finq.cnt]
 atomic.Xadd(&finq.cnt, +1) // Sync with markroots
 // 设置相关属性
 f.fn = fn
 f.nret = nret
 f.fint = fint
 f.ot = ot
 f.arg = p
 // 设置唤醒标志
 fingwake = true
 unlock(&finlock)
}

至此,也就明白了,runq全局队列是怎么被填充的了

那么,第二个问题,当fing被休眠后,怎么被唤醒呢?

这里就需要追溯到,深入理解Go-goroutine的实现及Scheduler分析 这篇文章了

2.2.4. findrunnable

在 findrunnable 中有一段代码如下:

func findrunnable() (gp *g, inheritTime bool) {
 // 通过状态位判断是否需要唤醒 fing, 通过wakefing来判断并返回fing
 if fingwait && fingwake {
 if gp := wakefing(); gp != nil {
 // 唤醒g,并从休眠出继续执行
 ready(gp, 0, true)
 }
 }
}

2.2.5. wakefing

这里不仅会对状态位 fingwait fingwake做二次判断,而且,如果状态位符合唤醒要求的话,需要重置两个状态位

func wakefing() *g {
 var res *g
 lock(&finlock)
 if fingwait && fingwake {
 fingwait = false
 fingwake = false
 res = fing
 }
 unlock(&finlock)
 return res
}

3. 参考文档

• 《Go语言学习笔记》--雨痕

本文来自:Segmentfault

感谢作者:tyloafer

查看原文:深入理解Go-runtime.SetFinalizer原理剖析

• 编辑
• 预览