脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 脚本专栏 → Golang → Go语言延迟函数defer

Go语言中的延迟函数defer示例详解

 更新时间：2017年10月30日 11:43:47   作者：henrylee2cn  
众所周知golang的defer优雅又简洁， 是golang的亮点之一。所以下面这篇文章主要给大家介绍了关于Go语言中延迟函数defer的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴，下面随着小编来一起学习学习吧。

前言

大家都知道go语言的defer功能很强大，对于资源管理非常方便，但是如果没用好，也会有陷阱哦。Go 语言中延迟函数 defer 充当着 try...catch 的重任，使用起来也非常简便，然而在实际应用中，很多 gopher 并没有真正搞明白 defer、return、返回值、panic 之间的执行顺序，从而掉进坑中，今天我们就来揭开它的神秘面纱！话不多说了，来一起看看详细的介绍吧。

先来运行下面两段代码：

A. 匿名返回值的情况

package main

import (
 "fmt"
)

func main() {
 fmt.Println("a return:", a()) // 打印结果为 a return: 0
}

func a() int {
 var i int
 defer func() {
  i++
  fmt.Println("a defer2:", i) // 打印结果为 a defer2: 2
 }()
 defer func() {
  i++
  fmt.Println("a defer1:", i) // 打印结果为 a defer1: 1
 }()
 return i
}

B. 有名返回值的情况

package main

import (
 "fmt"
)

func main() {
 fmt.Println("b return:", b()) // 打印结果为 b return: 2
}

func b() (i int) {
 defer func() {
  i++
  fmt.Println("b defer2:", i) // 打印结果为 b defer2: 2
 }()
 defer func() {
  i++
  fmt.Println("b defer1:", i) // 打印结果为 b defer1: 1
 }()
 return i // 或者直接 return 效果相同
}

先来假设出结论（这是正确结论），帮助大家理解原因：

  • 多个 defer 的执行顺序为“后进先出/先进后出”；
  • 所有函数在执行 RET 返回指令之前，都会先检查是否存在 defer 语句，若存在则先逆序调用 defer 语句进行收尾工作再退出返回；
  • 匿名返回值是在 return 执行时被声明，有名返回值则是在函数声明的同时被声明，因此在 defer 语句中只能访问有名返回值，而不能直接访问匿名返回值；
  • return 其实应该包含前后两个步骤：第一步是给返回值赋值（若为有名返回值则直接赋值，若为匿名返回值则先声明再赋值）；第二步是调用 RET 返回指令并传入返回值，而 RET 则会检查 defer 是否存在，若存在就先逆序插播 defer 语句，最后 RET 携带返回值退出函数；

因此，‍‍defer、return、返回值三者的执行顺序应该是：return最先给返回值赋值；接着 defer 开始执行一些收尾工作；最后 RET 指令携带返回值退出函数。

如何解释两种结果的不同：

上面两段代码的返回结果之所以不同，其实从上面的结论中已经很好理解了。

  • a()int 函数的返回值没有被提前声名，其值来自于其他变量的赋值，而 defer 中修改的也是其他变量（其实该 defer 根本无法直接访问到返回值），因此函数退出时返回值并没有被修改。
  • b()(i int) 函数的返回值被提前声名，这使得 defer 可以访问该返回值，因此在 return 赋值返回值 i 之后，defer 调用返回值 i 并进行了修改，最后致使 return 调用 RET 退出函数后的返回值才会是 defer 修改过的值。

C. 下面我们再来看第三个例子，验证上面的结论：

package main

import (
 "fmt"
)

func main() {
 c:=c()
 fmt.Println("c return:", *c, c) // 打印结果为 c return: 2 0xc082008340
}

func c() *int {
 var i int
 defer func() {
  i++
  fmt.Println("c defer2:", i, &i) // 打印结果为 c defer2: 2 0xc082008340
 }()
 defer func() {
  i++
  fmt.Println("c defer1:", i, &i) // 打印结果为 c defer1: 1 0xc082008340
 }()
 return &i
}

虽然 c()int 的返回值没有被提前声明，但是由于 c()int 的返回值是指针变量，那么在 return 将变量 i 的地址赋给返回值后，defer 再次修改了 i 在内存中的实际值，因此 return 调用 RET 退出函数时返回值虽然依旧是原来的指针地址，但是其指向的内存实际值已经被成功修改了。

即，我们假设的结论是正确的！

D. 补充一条，defer声明时会先计算确定参数的值，defer推迟执行的仅是其函数体。

package main

import (
 "fmt"
 "time"
)

func main() {
 defer P(time.Now())
 time.Sleep(5e9)
 fmt.Println("main ", time.Now())
}

func P(t time.Time) {
 fmt.Println("defer", t)
 fmt.Println("P ", time.Now())
}

// 输出结果：
// main 2017-08-01 14:59:47.547597041 +0800 CST
// defer 2017-08-01 14:59:42.545136374 +0800 CST
// P  2017-08-01 14:59:47.548833586 +0800 CST

E. defer 的作用域

  1. defer 只对当前协程有效（main 可以看作是主协程）；
  2. 当任意一条（主）协程发生 panic 时，会执行当前协程中 panic 之前已声明的 defer；
  3. 在发生 panic 的（主）协程中，如果没有一个 defer 调用 recover()进行恢复，则会在执行完最后一个已声明的 defer 后，引发整个进程崩溃；
  4. 主动调用 os.Exit(int) 退出进程时，defer 将不再被执行。
package main

import (
 "errors"
 "fmt"
 "time"
 // "os"
)

func main() {
 e := errors.New("error")
 fmt.Println(e)
 // （3）panic(e) // defer 不会执行
 // （4）os.Exit(1) // defer 不会执行
 defer fmt.Println("defer")
 // （1）go func() { panic(e) }() // 会导致 defer 不会执行
 // （2）panic(e) // defer 会执行
 time.Sleep(1e9)
 fmt.Println("over.")
 // （5）os.Exit(1) // defer 不会执行
}

F. defer 表达式的调用顺序是按照先进后出的方式执行

defer 表达式会被放入一个类似于栈( stack )的结构，所以调用的顺序是先进后出/后进先出的。

下面这段代码输出的结果是 4321 而不是 1234 。

package main

import (
 "fmt"
)

func main() {
 defer fmt.Print(1)
 defer fmt.Print(2)
 defer fmt.Print(3)
 defer fmt.Print(4)
}

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对脚本之家的支持。

您可能感兴趣的文章:

相关文章

  • 基于Go和Gin的环境配置方法

    基于Go和Gin的环境配置方法

    今天小编就为大家分享一篇基于Go和Gin的环境配置方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2019-07-07
  • go-zero 组件布隆过滤器使用示例详解

    go-zero 组件布隆过滤器使用示例详解

    这篇文章主要为大家介绍了go-zero组件介绍之布隆过滤器使用示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2023-05-05
  • Go重写http请求重定向的方法

    Go重写http请求重定向的方法

    当使用Go语言进行 HTTP 请求时,默认情况下,http.Client 会自动处理服务器返回的重定向响应（3xx 状态码）,本文将详细介绍如何在 Go 中实现禁止 HTTP 请求的重定向、限制重定向次数以及添加自定义重定向策略,需要的朋友可以参考下
    2024-08-08
  • Go语言入门之函数的定义与使用

    Go语言入门之函数的定义与使用

    函数是一段代码的片段，包含连续的执行语句，它可以将零个或多个输入参数映射到零个或多个参数输出。本文将通过示例和大家详细聊聊Go语言中函数的定义与使用，感兴趣的可以了解一下
    2022-11-11
  • GOLANG版的冒泡排序和快速排序分享

    GOLANG版的冒泡排序和快速排序分享

    这篇文章主要介绍了GOLANG版的冒泡排序和快速排序分享,需要的朋友可以参考下
    2015-03-03
  • GO语言实现AES-CFB加密的操作方法

    GO语言实现AES-CFB加密的操作方法

    本文介绍了如何用Go语言实现AES-CFB加密和解密,首先,定义一个属于encrypt包的文件,使用AES算法、CFB模式和Base64编码等功能,在加密函数中,接收明文和密钥,生成一个AES块密码和一个随机的初始化向量,实现明文的加密
    2024-10-10
  • Go-家庭收支记账软件项目实现

    Go-家庭收支记账软件项目实现

    这篇文章主要介绍了Go-家庭收支记账软件项目实现，本文章内容详细，具有很好的参考价值，希望对大家有所帮助，需要的朋友可以参考下
    2023-01-01
  • Go 分布式链路追踪实现原理解析

    Go 分布式链路追踪实现原理解析

    分布式链路追踪作为解决分布式应用可观测问题的重要技术，愈发成为分布式应用不可缺少的基础设施，本文将详细介绍分布式链路的核心概念、架构原理和相关开源标准协议，并分享我们在实现无侵入 Go 采集 Sdk 方面的一些实践,需要的朋友可以参考下
    2022-06-06
  • 深入解析Go语言中crypto/subtle加密库

    深入解析Go语言中crypto/subtle加密库

    本文主要介绍了深入解析Go语言中crypto/subtle加密库,详细介绍crypto/subtle加密库主要函数的用途、工作原理及实际应用,具有一定的参考价值,感兴趣的可以了解一下
    2024-02-02
  • 深入了解GoLang中的工厂设计模式

    深入了解GoLang中的工厂设计模式

    这篇文章主要介绍了深入了解GoLang中的工厂设计模式，工厂模式是一种常用的设计模式，它属于创建型模式，它的主要目的是封装对象的创建过程，将对象的创建过程与对象的使用过程分离，从而提高代码的可维护性和可扩展性，需要详细了解可以参考下文
    2023-05-05

最新评论