defer

实现与go关键字的实现类似，调用的是runtime.deferproc

核心思想

在defer出现的地方插入了指令CALL runtime.deferproc，在函数返回的地方插入了CALL runtime.deferreturn。goroutine的控制结构中，有一张表记录defer，调用runtime.deferproc时会将需要defer的表达式记录在表中，而在调用runtime.deferreturn的时候，则会依次从defer表中“出栈”并执行

如果有多个defer，调用顺序类似栈，越后面的defer表达式越先被调用

defer链

defer信息会注册到链表，当前执行的 goroutine 持有这个链表的头指针，每个 goroutine 都有一个对应的结构体struct G，其中有一个字段指向这个defer链表头

type g struct {    // Stack parameters.    // stack describes the actual stack memory: [stack.lo, stack.hi).    // stackguard0 is the stack pointer compared in the Go stack growth prologue.    // It is stack.lo+StackGuard normally, but can be StackPreempt to trigger a preemption.    // stackguard1 is the stack pointer compared in the C stack growth prologue.    // It is stack.lo+StackGuard on g0 and gsignal stacks.    // It is ~0 on other goroutine stacks, to trigger a call to morestackc (and crash).    stack       stack   // offset known to runtime/cgo    stackguard0 uintptr // offset known to liblink    stackguard1 uintptr // offset known to liblink    _panic       *_panic // innermost panic - offset known to liblink    // _defer 这个字段指向defer链表头    _defer       *_defer // innermost defer    ...}

新注册的defer会添加到链表头，所以感觉像是栈那样先进后出的调用

源码分析

deferproc一共有两个参数，第一个是参数和返回值的大小，第二个是指向funcval的指针

// Create a new deferred function fn with siz bytes of arguments.// The compiler turns a defer statement into a call to this.//go:nosplitfunc deferproc(siz int32, fn *funcval) { // arguments of fn follow fn    // 获取当前goroutine    gp := getg()    if gp.m.curg != gp {        // go code on the system stack can't defer        throw("defer on system stack")    }    // the arguments of fn are in a perilous state. The stack map    // for deferproc does not describe them. So we can't let garbage    // collection or stack copying trigger until we've copied them out    // to somewhere safe. The memmove below does that.    // Until the copy completes, we can only call nosplit routines.    // 获取调用者指针    sp := getcallersp()    // 通过偏移获得参数    argp := uintptr(unsafe.Pointer(&fn)) + unsafe.Sizeof(fn)    callerpc := getcallerpc()    // 创建defer结构体    d := newdefer(siz)    if d._panic != nil {        throw("deferproc: d.panic != nil after newdefer")    }    // 初始化    d.link = gp._defer    gp._defer = d    d.fn = fn    d.pc = callerpc    d.sp = sp    switch siz {    case 0:        // Do nothing.    case sys.PtrSize:        *(*uintptr)(deferArgs(d)) = *(*uintptr)(unsafe.Pointer(argp))    default:        memmove(deferArgs(d), unsafe.Pointer(argp), uintptr(siz))    }    // deferproc returns 0 normally.    // a deferred func that stops a panic    // makes the deferproc return 1.    // the code the compiler generates always    // checks the return value and jumps to the    // end of the function if deferproc returns != 0.    return0()    // No code can go here - the C return register has    // been set and must not be clobbered.}

// 以下是_defer结构体// A _defer holds an entry on the list of deferred calls.// If you add a field here, add code to clear it in freedefer and deferProcStack// This struct must match the code in cmd/compile/internal/gc/reflect.go:deferstruct// and cmd/compile/internal/gc/ssa.go:(*state).call.// Some defers will be allocated on the stack and some on the heap.// All defers are logically part of the stack, so write barriers to// initialize them are not required. All defers must be manually scanned,// and for heap defers, marked.type _defer struct {    // siz 记录defer的参数和返回值共占多少字节    // 会直接分配在_defer后面，在注册时保存参数，在执行完成时拷贝到调用者参数和返回值空间    siz     int32 // includes both arguments and results    // started 标记是否已经执行    started bool    // heap go1.13优化，标识是否为堆分配    heap    bool    // openDefer indicates that this _defer is for a frame with open-coded    // defers. We have only one defer record for the entire frame (which may    // currently have 0, 1, or more defers active).    // openDefer 是否是open defer，通过这些信息可以找到未注册到链表的defer函数    openDefer bool    // sp 记录调用者栈指针，可以通过它判断自己注册的defer是否已经执行完了    sp        uintptr  // sp at time of defer    // pc deferproc的返回地址    pc        uintptr  // pc at time of defer    // fn 要注册的funcval    fn        *funcval // can be nil for open-coded defers    // _panic 指向当前的panic，表示这个defer是由这个panic触发的    _panic    *_panic  // panic that is running defer    // link 链到前一个注册的defer结构体    link      *_defer    // If openDefer is true, the fields below record values about the stack    // frame and associated function that has the open-coded defer(s). sp    // above will be the sp for the frame, and pc will be address of the    // deferreturn call in the function.    // 通过这些信息可以找到未注册到链表的defer函数    fd   unsafe.Pointer // funcdata for the function associated with the frame    varp uintptr        // value of varp for the stack frame    // framepc is the current pc associated with the stack frame. Together,    // with sp above (which is the sp associated with the stack frame),    // framepc/sp can be used as pc/sp pair to continue a stack trace via    // gentraceback().    framepc uintptr}

defer将参数注册的时候拷贝到堆上，执行时再（将参数和返回值）拷贝回栈上

go会分配不同规格的_defer pool，执行时从空闲_defer中取一个出来用，没有合适的再进行堆分配。用完以后再放回空闲_defer pool。以避免频繁的堆分配和回收

优化

go1.12中defer存在的问题

defer信息主要存储在堆上，要在堆和栈上来回拷贝返回值和参数很慢

defer结构体通过链表链起来，而链表的操作也很慢

go1.13中defer的优化

减少了defer信息的堆分配。再通过deferprocStack将整个defer注册到defer链表中

将一般情况的defer信息存储在函数栈帧的局部变量区域

显示循环或者是隐式循环的defer还是需要用到go1.12中defer信息的堆分配

官方给出的性能提升是30%

go1.14中defer的优化

在编译阶段插入代码，把defer函数的执行逻辑展开在所属函数内，避免创建defer结构体，而且不需要注册到defer链表。称为 open coded defer

与1.13一样不适用于循环中的defer

性能几乎提升了一个数量级

open coded defer 中发生panic 或 调用runtime.Goexit()，后面未注册到的defer函数无法执行到，需要栈扫描。defer结构体中就多添加了一些字段，借助这些字段可以找到未注册到链表中的defer函数

结果就是defer变快了，但是panic变慢了

defer添加了局部变量去判断是否需要执行，需要执行的话就将标识df对应的位上或一下，如果是有条件的defer，需要根据具体条件去或df

deferprocStack

// deferprocStack queues a new deferred function with a defer record on the stack.// The defer record must have its siz and fn fields initialized.// All other fields can contain junk.// The defer record must be immediately followed in memory by// the arguments of the defer.// Nosplit because the arguments on the stack won't be scanned// until the defer record is spliced into the gp._defer list.//go:nosplitfunc deferprocStack(d *_defer) {    // 获得当前 goroutine    gp := getg()    if gp.m.curg != gp {        // go code on the system stack can't defer        throw("defer on system stack")    }    // siz and fn are already set.    // The other fields are junk on entry to deferprocStack and    // are initialized here.    // 初始化 _defer 信息    d.started = false    d.heap = false    d.openDefer = false    d.sp = getcallersp()    d.pc = getcallerpc()    d.framepc = 0    d.varp = 0    // The lines below implement:    //   d.panic = nil    //   d.fd = nil    //   d.link = gp._defer    //   gp._defer = d    // But without write barriers. The first three are writes to    // the stack so they don't need a write barrier, and furthermore    // are to uninitialized memory, so they must not use a write barrier.    // The fourth write does not require a write barrier because we    // explicitly mark all the defer structures, so we don't need to    // keep track of pointers to them with a write barrier.    *(*uintptr)(unsafe.Pointer(&d._panic)) = 0    *(*uintptr)(unsafe.Pointer(&d.fd)) = 0    *(*uintptr)(unsafe.Pointer(&d.link)) = uintptr(unsafe.Pointer(gp._defer))    *(*uintptr)(unsafe.Pointer(&gp._defer)) = uintptr(unsafe.Pointer(d))    return0()    // No code can go here - the C return register has    // been set and must not be clobbered.}

参考

幼麟实验室

go语言设计与实现

原文：https://juejin.cn/post/7101887123539623944