专栏首页程序员财富自由之路Go 中 defer 关键字原理
原创

Go 中 defer 关键字原理

defer 是什么?

defer 修饰的函数是一个延迟函数,在包含它的函数返回时运行。

defer 执行时机

A "defer" statement invokes a function whose execution is deferred to the moment the surrounding function returns, either because the surrounding function executed a return statement, reached the end of its function body, or because the corresponding goroutine is panicking

defer 触发时机是:

  1. 函数执行到函数体末端
  2. 函数执行return语句
  3. 当前协程panic

defer 实现原理

defer 数据结构源码在 src/runtime/runtime2.go

在这里插入图片描述

type _defer struct {
   siz     int32 // 由deferproc第一个参数传入,参数和结果的内存大小
   started bool // 标识defer函数是否已经开始执行
   heap    bool // 堆分配、栈分配
   openDefer bool //表示当前 defer 是否经过开放编码的优化
   sp        uintptr  // 栈指针程序计数器,注册defer函数的函数栈指针
   pc        uintptr  // 调用方程序计数器,deferproc函数返回后要继续执行的指令地址
   fn        *funcval // 由deferproc的第二个参数传入,也就是被注册的defer函数
   _panic    *_panic  // 是触发defer函数执行的panic指针,正常流程执行defer时它就是nil
   link      *_defer //结构体是延迟调用链表上的一个元素,所有的结构体都会通过 link 字段串联成链表。
}

defer 执行机制

在中间代码生成阶段, 有三种不同的机制处理 defer 关键字

  • 堆上分配(Go 版本1.1-1.12)默认兜底方案
  • 栈分配(Go版本 1.13 )相比堆分配能够减少 30%堆额外开销。
  • 开放编码(Go 版本 1.14) 额外开销可以忽略不计。

堆上分配

  1. defer 语句堆位置插入 runtime.deferproc, 在被执行时,延迟调用会被保存为一个 _defer 记录,并将被延迟调用的入口地址与参数复制保存,存入 Gorountine 得调用链表中。
  2. 在函数返回之前的位置插入 runtime.deferreturn,当被执行时,会将延迟调用从 Goroutine 链表中取出并执行,多个延迟调用则以 jmpdefer 尾递归调用方式连续执行

runtime.deferproc 负责注册, runtime.deferreturn 负责执行。

在这里插入图片描述

derfer 关键字最重要的三个函数

  1. deferproc。在每遇到一个defer关键字时,实际上都会转换为deferproc函数,deferproc函数的作用是将defer函数存入链表中。(go关键字是使用newproc函数,它两的实现有着不少相似之处)
  2. deferreturn。在return指令前调用,从链表中取出defer函数并执行。
  3. deferprocStack。go1.13后对defer做的优化,通过利用栈空间提高效率。

call 函数

cmd/compile/internal/gc.state.call 会负责为所有函数和方法调用生成中间代码:

  1. 获取需要执行的函数名,代码制作和函数调用的接收方
  2. 需要获取栈地址并将函数或者方法的参数写入栈中
  3. 使用 cmd/compile/internal/gc.state.newValue1A 函数生成函数调用的中间代码
  4. 如果当前调用的函数是 defer, 那么会单独生成相关的结束代码块。
  5. 获取函数的返回值,并结束当前调用。
// Calls the function n using the specified call type.
// Returns the address of the return value (or nil if none).
func (s *state) call(n *Node, k callKind) *ssa.Value {
    var call *ssa.Value
    if k == callDeferStack {
        // 在栈上初始化 defer 结构体
        call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, deferprocStack, s.mem())
        ...
    } else {
        ...
        switch {
        case k == callDefer:
            call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, deferproc, s.mem())
            ...
        }
        call.AuxInt = stksize
    }
    s.vars[&memVar] = call
    ...
}

deferproc 函数

runtime.deferproc 的功能时注册延迟函数,会为 defer 创建一个新的 runtime._defer的结构体、设置它的函数指针 fn、程序计数器 pc 和 栈制作 sp 并将相关的函数参数拷贝到相邻的内存空间。

  • deferproc 函数有两个参数, 第一个是被注册的 defer 函数的参数返回值占多少字节。第二个参数是一个 runtime.funcval 结构体的指针
  • runtime.newdefer通过 runtime.mallocgc 在堆上创建一个新的结构体,并添加到link字段上形成链表。
  • 最后调用的 runtime.return0 是唯一一个不会触发延迟调用的函数,它可以避免递归 runtime.deferreturn 的递归调用。
func deferproc(siz int32, fn *funcval) { 
    // 这里的g就是gorouutine,详看golang的调度模型
    // 只有用户使用的goroutine可以应用defer
    if getg().m.curg != getg() {
        throw("defer on system stack")
    }
    sp := getcallersp() // 调用deferproc之前的rsp寄存器的值
    argp := uintptr(unsafe.Pointer(&fn)) + unsafe.Sizeof(fn)
    callerpc := getcallerpc() // deferproc函数的返回地址,也就是执行完defer后应当跳回哪段代码上
    d := newdefer(siz)
    if d._panic != nil {
        throw("deferproc: d.panic != nil after newdefer")
    }
    d.fn = fn
    d.pc = callerpc
    d.sp = sp
    // 对defer函数参数进行处理
    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))
    }
    return0()
}

先通过 newdefer 获取一个 defer 关键字的插入顺序是从后向前的,而 defer 关键字执行是从前向后的,后调用的 defer 会优先执行。

newdefer追加新等延迟调用

deferreturn 函数

runtime.deferreturn 是触发延迟函数链表的执行,会从 Goroutine_defer 链表中取出最前面的 runtime._defer 并调用 runtime.jmpdefer 传入需要执行的函数和参数。

  • runtime.jmpdefer 是一个用汇编语言实现的运行时函数,它的主要工作是跳转到 defer 所在的代码段并在执行结束之后跳转回 runtime.deferreturn。
  • runtime.deferreturn 会多次判断当前 Goroutine 的 _defer 链表中是否有未执行的结构体,该函数只有在所有延迟函数都执行后才会返回
  • 最后调用的 runtime.return0 是唯一一个不会触发延迟调用的函数,它可以避免递归 runtime.deferreturn 的递归调用。
func deferreturn(arg0 uintptr) {
    gp := getg()
    d := gp._defer
    if d == nil {
        // 结束条件1,没有defer函数了,也就是所有defer函数都执行完成了
        // 还记得defer的链式结构吗,其实就是一个递归函数不断调用
        // 为nil的话就代表这条链遍历完成了
        return
    }
    sp := getcallersp()
    if d.sp != sp {
        // 结束条件2,如果保存在_defer对象中的sp值与调用deferretuen时的栈顶位置不一样,直接返回
        // 因为sp不一样表示d代表的是在其他函数中通过defer注册的延迟调用函数,比如:
        // a()->b()->c()它们都通过defer注册了延迟函数,那么当c()执行完时只能执行在c中注册的函数
        return
    }
    switch d.siz {
    case 0:
        // Do nothing.
    case sys.PtrSize:
        *(*uintptr)(unsafe.Pointer(&arg0)) = *(*uintptr)(deferArgs(d))
    default:
        memmove(unsafe.Pointer(&arg0), deferArgs(d), uintptr(d.siz))
    }
    fn := d.fn
    d.fn = nil
    gp._defer = d.link
    freedefer(d)
    jmpdefer(fn, uintptr(unsafe.Pointer(&arg0)))
}

包含如下几个步骤:

  1. 判断执行条件
  2. 参数拷贝
  3. 释放_defer对象
  4. 执行函数

值得一提的是,defer具有即时传值的特点,defer也同样满足闭包和匿名函数的特性。

以代码为例子,讲解 defer 注册和执行流程

// 源程序
func A1(a int) {
    fmt.Println(a)
}
func A() {
    a, b := 1, 2
    defer A1(a)
    
    a = a + b
    fmt.Println(a, b)
}

//函数A编译后的伪指令
func A() {
    a, b := 1, 2
    runtime.deferproc(8, A1,1)    // siz=8, A1=延迟函数入口, 1=A1函数入参
      
    a = a + b
    fmt.Println(a, b)//3,2

    runtime.deferreturn()//执行defer链表
    return
}
  1. 函数A定义局部变量a=1,b=2,存储在A函数的栈中
  1. deferproc函数注册defer函数A1时,
  • func deferproc(siz int32, fn *funcval)
  • siz:A1没有返回值,64位下一个整型参数占用8字节。
  • fn:A1函数入口地址,addr1

deferproc函数调用时,编译器会在它自己的两个参数后面,开辟一段空间,用于存放defer函数A1的返回值和参数。这一段空间会在注册defer时,直接拷贝到_defer结构体的后面。

在这里插入图片描述

  1. 在堆上分配存储空间,并存放_defer结构体
  • A1的参数加返回值共占8字节
  • defer函数尚未执行,所以started=false
  • sp就是调用者A的栈指针
  • pc就是deferproc函数的返回地址return addr
  • 被注册的function value为A1
  • defer结构体后面的8字节用来保存传递给A1的参数。 然后这个_defer结构体就被添加到defer链表头,deferproc注册结束。

频繁的堆分配势必影响性能,所以Go语言会预分配不同规格的deferpool,执行时从空闲_defer中取一个出来用。没有空闲的或者没有大小合适的,再进行堆分配。用完以后,再放回空闲_defer池。这样可以避免频繁的堆分配与回收。

在这里插入图片描述

  1. deferreturn执行defer链表:从当前goroutine找到链表头上的这个_defer结构体,通过_defer.fn找到defer函数的funcval结构体,进而拿到函数A1的入口地址。接下来就可以调用A1了。 调用A1时,会把_defer后面的参数与返回值整个拷贝到A1的调用者栈上。然后A1开始执行,输入参数值a=1。

欢迎关注公众号:程序员财富自由之路

参考资料

  • https://draveness.me/golang/docs/part2-foundation/ch05-keyword/golang-defer/#fn:1
  • https://sanyuesha.com/2017/07/23/go-defer/
  • https://zhuanlan.zhihu.com/p/261153919

原创声明,本文系作者授权云+社区发表,未经许可,不得转载。

如有侵权,请联系 yunjia_community@tencent.com 删除。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Go语言defer关键字

    会呼吸的Coder
  • Go 中 Defer 原理分析

    runtime.deferproc 负责注册, runtime.deferreturn 负责执行。

    王小明_HIT
  • go defer 关键字的需要注意的问题

    不是说好的defer 关键字 的意思是总会执行的吗?结果是defer 关键字并没有执行。

    地球流浪猫
  • (十八)golang--defer关键字

    在函数中,程序员经常需要创建资源(比如,数据库连接,文件句柄,锁等),为了在函数执行完毕后,及时释放资源,go设计者提供defer(延时机制)

    西西嘛呦
  • <Go语言学习笔记>【异常处理】

    通常 panic 和 recover 是用来处理异常问题的。我们来综述下,他们各自的特点:

    秦穆之
  • golang defer关键字的使用

    在golang当中,defer代码块会在函数调用链表中增加一个函数调用。这个函数调用不是普通的函数调用,而是会在函数正常返回,也就是return之后添加一个函数...

    开发架构二三事
  • 2020-11-19:go中,defer原理是什么?

    福大大架构师每日一题
  • defer, panic和recover用法【Golang 入门系列十四】

    以前讲过golang 的基本语法。但是,只是讲了一些基础的语法,感兴趣的可以看看以前的文章,https://www.cnblogs.com/zhangweizh...

    架构师精进
  • Go语言错误处理

    错误指的是可能出现问题的地方出现了问题,比如打开一个文件时可能失败,这种情况在人们的意料之中。

    Steve Wang
  • 深入Go的错误处理机制(一)使用

    程序运行过程中不可避免的发生各种错误,要想让自己的程序保持较高的健壮性,那么异常,错误处理是需要考虑周全的,每个编程语言提供了一套自己的异常错误处理机制,在Go...

    阿伟
  • Go语言入门——进阶语法篇(四)

    Go语言没有类似Java或Python那种try...catch...机制处理异常,Go的哲学是与众不同的,Go的设计者认为主流的异常处理机制是一种被过度滥用的...

    arcticfox
  • Go语言错误与异常处理机制

    1 Error接口 Go语言中的error类型实际上是抽象了Error()方法的error接口

    李海彬
  • golang教程

    这里有两个关键点。 - 其一是defer关键字。defer语句的含义是不管程序是否出现异常,均 在函数退出时自动执行相关代码。 - 其二是Go语言的函数允许返回...

    陨石坠灭
  • golang教程

    这里有两个关键点。 - 其一是defer关键字。defer语句的含义是不管程序是否出现异常,均 在函数退出时自动执行相关代码。 - 其二是Go语言的函数允许返回...

    陨石坠灭
  • Golang语言--细节汇总

    slice和数组在声明时的区别:声明数组时,方括号内写明了数组的长度或使用...自动 计算长度,而声明slice时,方括号内没有任何字符。 对于slice有几个...

    李海彬
  • Gopher每日刷题 题目解析

    Go语言的defer(延迟执行)语句,是在函数结束前执行,而如果在函数中有多个defer语句时,则调用的顺序是先进后出的顺序, 类似入栈出栈。

    李海彬
  • Go 语言错误及异常处理篇(二):defer 语句

    Go 语言中的类没有构造函数和析构函数的概念,处理错误和异常时也没有提供 try...catch...finally 之类的语法,那当我们想要在某个资源使用完毕...

    学院君
  • 我的Go语言初体验

    只要了解这些底层的根本问题,你才会有持续的动力深入学习,而不是盲目跟风和三分钟热度。

    phoenix.xiao
  • go-函数

    函数的参数和返回值都是可选的,例如我们可以实现一个既不需要参数也没有返回值的函数:

    新人小试

扫码关注云+社区

领取腾讯云代金券