您好,登录后才能下订单哦!
今天小编给大家分享一下Golang的关键字defer如何使用的相关知识点,内容详细,逻辑清晰,相信大部分人都还太了解这方面的知识,所以分享这篇文章给大家参考一下,希望大家阅读完这篇文章后有所收获,下面我们一起来了解一下吧。
在defer出现的地方插入了指令CALL runtime.deferproc,在函数返回的地方插入了CALL runtime.deferreturn。goroutine的控制结构中,有一张表记录defer,调用runtime.deferproc时会将需要defer的表达式记录在表中,而在调用runtime.deferreturn的时候,则会依次从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:nosplit func 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:nosplit func 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. }
以上就是“Golang的关键字defer如何使用”这篇文章的所有内容,感谢各位的阅读!相信大家阅读完这篇文章都有很大的收获,小编每天都会为大家更新不同的知识,如果还想学习更多的知识,请关注亿速云行业资讯频道。
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。