SetFinalizer设置一个finalizer关联到一个对象obj，当垃圾回收准备回收obj的时候，它会断开这个连接，并在单独的goroutine中执行finalizer(obj),这将让obj再次可用，但是不会再关联finalizer,
在SetFinalizer中:

1. 先检查元素,如果类型为nil,或者不为指针，元素值为nil 都会报错
2. 查找对象的heap地址
3. 如果是函数类型为nil,则移除removefinalizer
4. 检测参数类型,并给计算返回值size
5. createfing()确保finalizer goroutine正在运行
6. 添加finalizer

func SetFinalizer(obj interface{}, finalizer interface{}) {
    e := efaceOf(&obj)
    etyp := e._type
    if etyp == nil {
        throw("runtime.SetFinalizer: first argument is nil")
    }
    if etyp.kind&kindMask != kindPtr {
        throw("runtime.SetFinalizer: first argument is " + etyp.string() + ", not pointer")
    }
    ot := (*ptrtype)(unsafe.Pointer(etyp))
    if ot.elem == nil {
        throw("nil elem type!")
    }
    // find the containing object
    base, _, _ := findObject(uintptr(e.data), 0, 0)
    f := efaceOf(&finalizer)
    ftyp := f._type
    if ftyp == nil {
    // switch to system stack and remove finalizer
        systemstack(func() {
            removefinalizer(e.data)
        })
        return
    }
    fint := ft.in()[0]
    // make sure we have a finalizer goroutine
    createfing()

    systemstack(func() {
        if !addfinalizer(e.data, (*funcval)(f.data), nret, fint, ot) {
            throw("runtime.SetFinalizer: finalizer already set")
        }
    })
}

从mheap.specialfinalizeralloc中申请一块内存,然后调用addspecial,如果成功则返回，失败则free掉刚才申请的内存
在addspecial ，根据p指针找到对应的span,轮训找到是否有相同offset和kind的数据存在，如果存在则finalizer函数已经存在，否则将其加入到span.specials中去(这里有根据offset排序)

// Adds a finalizer to the object p. Returns true if it succeeded.
func addfinalizer(p unsafe.Pointer, f *funcval, nret uintptr, fint *_type, ot *ptrtype) bool {
    lock(&mheap_.speciallock)
    s := (*specialfinalizer)(mheap_.specialfinalizeralloc.alloc())
    unlock(&mheap_.speciallock)
    if addspecial(p, &s.special) {
        return true
    }
    // There was an old finalizer
    lock(&mheap_.speciallock)
    mheap_.specialfinalizeralloc.free(unsafe.Pointer(s))
    unlock(&mheap_.speciallock)
    return false
}
func addspecial(p unsafe.Pointer, s *special) bool {
    span := spanOfHeap(uintptr(p))
    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 {
            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.
    s.offset = uint16(offset)
    s.next = *t
    *t = s
    unlock(&span.speciallock)
    releasem(mp)

    return true
}

清理

sweep函数中，如果span有special record,先检查是否有finalizer, 如果没有的话则调用freespecial,将其加入到finq
var finq *finblock // list of finalizers that are to be executed

func (s *mspan) sweep(preserve bool) bool {
// The allocBits indicate which unmarked objects don't need to be
    // processed since they were free at the end of the last GC cycle
    // and were not allocated since then.
    // If the allocBits index is >= s.freeindex and the bit
    // is not marked then the object remains unallocated
    // since the last GC.
    // This situation is analogous to being on a freelist.

    // Unlink & free special records for any objects we're about to free.
    // Two complications here:
    // 1. An object can have both finalizer and profile special records.
    //    In such case we need to queue finalizer for execution,
    //    mark the object as live and preserve the profile special.
    // 2. A tiny object can have several finalizers setup for different offsets.
    //    If such object is not marked, we need to queue all finalizers at once.
    // Both 1 and 2 are possible at the same time.
    specialp := &s.specials
    special := *specialp
    for special != nil {
        // A finalizer can be set for an inner byte of an object, find object beginning.
        objIndex := uintptr(special.offset) / size
        p := s.base() + objIndex*size
        mbits := s.markBitsForIndex(objIndex)
        if !mbits.isMarked() {
            // This object is not marked and has at least one special record.
            // Pass 1: see if it has at least one finalizer.
            hasFin := false
            endOffset := p - s.base() + size
            for tmp := special; tmp != nil && uintptr(tmp.offset) < endOffset; tmp = tmp.next {
                if tmp.kind == _KindSpecialFinalizer {
                    // Stop freeing of object if it has a finalizer.
                    mbits.setMarkedNonAtomic()
                    hasFin = true
                    break
                }
            }
            // Pass 2: queue all finalizers _or_ handle profile record.
            for special != nil && uintptr(special.offset) < endOffset {
                // Find the exact byte for which the special was setup
                // (as opposed to object beginning).
                p := s.base() + uintptr(special.offset)
                if special.kind == _KindSpecialFinalizer || !hasFin {
                    // Splice out special record.
                    y := special
                    special = special.next
                    *specialp = special
                    freespecial(y, unsafe.Pointer(p), size)
                } else {
                    // This is profile record, but the object has finalizers (so kept alive).
                    // Keep special record.
                    specialp = &special.next
                    special = *specialp
                }
            }
        } else {
            // object is still live: keep special record
            specialp = &special.next
            special = *specialp
        }
    }

}

执行

在createfing中新建了一个goroutine处理这个队列, 获取finq队列中的数据
如果队列为空，则休眠, findrunable会检查唤醒,
否则循环，调用reflectcall(nil, unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz))执行fin函数

```func createfing() {
    // start the finalizer goroutine exactly once
    if fingCreate == 0 && atomic.Cas(&fingCreate, 0, 1) {
        go runfinq()
    }
}
// This is the goroutine that runs all of the finalizers
func runfinq() {
    var (
        frame    unsafe.Pointer
        framecap uintptr
    )

    for {
        lock(&finlock)
        fb := finq
        finq = nil
        if fb == nil {
            gp := getg()
            fing = gp
            fingwait = true
            goparkunlock(&finlock, waitReasonFinalizerWait, traceEvGoBlock, 1)
            continue
        }
        unlock(&finlock)
        if raceenabled {
            racefingo()
        }
        for fb != nil {
            for i := fb.cnt; i > 0; i-- {
                f := &fb.fin[i-1]

                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.
                *(*[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")
                }
                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.
                f.fn = nil
                f.arg = nil
                f.ot = nil
                atomic.Store(&fb.cnt, i-1)
            }
            next := fb.next
            lock(&finlock)
            fb.next = finc
            finc = fb
            unlock(&finlock)
            fb = next
        }
    }
}