Golang Defer 执行顺序

于 2024-02-27 17:39:44 发布
阅读量1.1k 收藏 21
点赞数 16
分类专栏： Golang 文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26857259/article/details/136324475
版权

Golang Defer 执行顺序

1. defer的执行顺序

多个defer出现的时候，它是一个“栈”的关系，也就是先进后出。一个函数中，写在前面的defer会比写在后面的defer调用的晚。

代码示例：

func TestDefer01(t *testing.T) {
	defer func1()
	defer func2()
	defer func3()
}

func func1() {
	fmt.Println("A")
}

func func2() {
	fmt.Println("B")
}

func func3() {
	fmt.Println("C")
}

输出

=== RUN   TestDefer01
C
B
A
--- PASS: TestDefer01 (0.00s)

2. defer与return谁先谁后

结论为：return之后的语句先执行，defer后的语句后执行

func func1() {
	fmt.Println("A")
}

func func2() {
	fmt.Println("B")
}

func func3() {
	fmt.Println("C")
}

func deferFunc() int {
	fmt.Println("defer func called")
	return 0
}

func returnFunc() int {
	fmt.Println("return func called")
	return 0
}

func returnAndDefer() int {

	defer deferFunc()

	return returnFunc()
}

func TestDeferReturn01(t *testing.T) {
	returnAndDefer()
}

输出

=== RUN   TestDeferReturn01
return func called
defer func called
--- PASS: TestDeferReturn01 (0.00s)

3. 函数的返回值初始化

该知识点不属于defer本身，但是调用的场景却与defer有联系，所以也算是defer必备了解的知识点之一。

如 ： func DeferFunc1(i int) (t int) {}
其中返回值 t int ，这个 t 会在函数起始处被初始化为对应类型的零值并且作用域为整个函数。

代码示例

func DeferFunc11(i int) (t int) {

	fmt.Println("t = ", t)

	return 2
}

func TestReturnInit(t *testing.T) {
	DeferFunc11(10)
}

输出

=== RUN   TestReturnInit
t =  0
--- PASS: TestReturnInit (0.00s)

4. 有名函数返回值遇见defer情况

在没有defer的情况下，其实函数的返回就是与return一致的，但是有了defer就不一样了。

我们通过知识点2得知，先return，再defer，所以在执行完return之后，还要再执行defer里的语句，依然可以修改本应该返回的结果。

代码示例

func returnButDefer() (t int) { //t初始化0， 并且作用域为该函数全域

	defer func() {
		t = t * 10
	}()

	return 1
}

func TestReturnButDefer(t *testing.T) {
	println(returnButDefer())
}

输出

=== RUN   TestReturnButDefer
10
--- PASS: TestReturnButDefer (0.00s)

代码分析

该 returnButDefer() 本应的返回值是 1 ，但是在return之后，又被defer的匿名func函数执行，所以 t=t*10 被执行，最后 returnButDefer() 返回给上层 main() 的结果为10

5. defer遇见panic

我们知道，能够触发defer的是遇见return(或函数体到末尾)和遇见panic。

遇到panic时，遍历本协程的defer链表，并执行defer。在执行defer过程中:遇到recover则停止panic，返回recover处继续往下执行。如果没有遇到recover，遍历完本协程的defer链表后，向stderr抛出panic信息。

defer遇见panic，执行顺序

  1. 遇见panic，强行defer出栈，并且每个defer均受到异常，不捕获则转移到下一个
  2. 直到defer捕获异常，或者上层显示异常

defer 最大的功能是 panic 后依然有效
所以defer可以保证你的一些资源一定会被关闭，从而避免一些异常出现的问题。

defer遇见panic，但是并不捕获异常的情况

代码示例

func TestDeferPanic01(t *testing.T) {
	defer_call()

	fmt.Println("main 正常结束")
}

func defer_call() {
	defer func() { fmt.Println("defer: panic 之前1") }()
	defer func() { fmt.Println("defer: panic 之前2") }()

	panic("异常内容") //触发defer出栈

	defer func() { fmt.Println("defer: panic 之后，永远执行不到") }()
}

输出

=== RUN   TestDeferPanic01
defer: panic 之前2
defer: panic 之前1
--- FAIL: TestDeferPanic01 (0.00s)
panic: 异常内容 [recovered]
	panic: 异常内容
...
...
...

defer遇见panic，并捕获异常

代码示例

func deferCall02() {

	defer func() {
		fmt.Println("defer: panic 之前1, 捕获异常")
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()

	defer func() { fmt.Println("defer: panic 之前2, 不捕获") }()

	panic("异常内容") //触发defer出栈

	defer func() { fmt.Println("defer: panic 之后, 永远执行不到") }()
}

func TestDeferPanic02(t *testing.T) {
	deferCall02()

	fmt.Println("main 正常结束")
}

输出

=== RUN   TestDeferPanic02
defer: panic 之前2, 不捕获
defer: panic 之前1, 捕获异常
异常内容
main 正常结束
--- PASS: TestDeferPanic02 (0.00s)

6. defer中包含panic

代码示例

func TestDeferPanic03(t *testing.T) {

	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		} else {
			fmt.Println("fatal")
		}
	}()

	defer func() {
		panic("defer panic")
	}()

	panic("panic")
}

输出

=== RUN   TestDeferPanic03
defer panic
--- PASS: TestDeferPanic03 (0.00s)

分析

panic仅有最后一个可以被revover捕获。

触发 panic("panic") 后defer顺序出栈执行，第一个被执行的defer中 会有 panic("defer panic") 异常语句，这个异常将会覆盖掉main中的异常 panic("panic") ，最后这个异常被第二个执行的defer捕获到。

7. defer下的函数参数包含子函数

代码示例

func deferPanic04Func(index int, value int) int {
	fmt.Println("DeferPanic04Func", index)
	return index
}

func TestDeferPanic04(t *testing.T) {
	defer deferPanic04Func(1, deferPanic04Func(3, 0))
	defer deferPanic04Func(2, deferPanic04Func(4, 0))
}

输出

=== RUN   TestDeferPanic04
DeferPanic04Func 3
DeferPanic04Func 4
DeferPanic04Func 2
DeferPanic04Func 1
--- PASS: TestDeferPanic04 (0.00s)

代码分析

这里，有4个函数，他们的index序号分别为1，2，3，4。

那么这4个函数的先后执行顺序是什么呢？这里面有两个defer， 所以defer一共会压栈两次，先进栈1，后进栈2。 那么在压栈function1的时候，需要连同函数地址、函数形参一同进栈，那么为了得到function1的第二个参数的结果，所以就需要先执行function3将第二个参数算出，那么function3就被第一个执行。同理压栈function2，就需要执行function4算出function2第二个参数的值。然后函数结束，先出栈fuction2、再出栈function1.

所以顺序如下：

  1. ● defer压栈function1，压栈函数地址、形参1、形参2(调用function3) --> 打印3
  2. ● defer压栈function2，压栈函数地址、形参1、形参2(调用function4) --> 打印4
  3. ● defer出栈function2, 调用function2 --> 打印2
  4. ● defer出栈function1, 调用function1–> 打印1

8. defer面试真题

func DeferFunc1(i int) (t int) {
	t = i
	defer func() {
		t += 3
	}()
	return t
}

func DeferFunc2(i int) int {
	t := i
	defer func() {
		t += 3
	}()
	return t
}

func DeferFunc3(i int) (t int) {
	defer func() {
		t += i
	}()
	return 2
}

func DeferFunc4() (t int) {
	defer func(i int) {
		fmt.Println("DeferFunc4 i=", i)
		fmt.Println("DeferFunc4 t=", t)
	}(t)
	println("DeferFunc4 , func start .")
	t = 1
	println("DeferFunc4 , func end .")
	return 2
}

func TestQue01(t *testing.T) {
	fmt.Println("DeferFunc1 =", DeferFunc1(1))
	fmt.Println("DeferFunc2 =", DeferFunc2(1))
	fmt.Println("DeferFunc3 =", DeferFunc3(1))
	DeferFunc4()
}

输出

=== RUN   TestQue01
DeferFunc1 = 4
DeferFunc2 = 1
DeferFunc3 = 3
DeferFunc4 , func start .
DeferFunc4 , func end .
DeferFunc4 i= 0
DeferFunc4 t= 2
--- PASS: TestQue01 (0.00s)

9. 真题分析

DeferFunc1

func DeferFunc1(i int) (t int) {
    t = i
    defer func() {
        t += 3
    }()
    return t
}
  1. 将返回值t赋值为传入的i，此时t为1
  2. 执行return语句将t赋值给t（等于啥也没做）
  3. 执行defer方法，将 t + 3 = 4
  4. 函数返回 4

因为t的作用域为整个函数所以修改有效。

DeferFunc2

func DeferFunc2(i int) int {
	t := i
	defer func() {
		t += 3
	}()
	return t
}
  1. 创建变量t并赋值为1
  2. 执行return语句，注意这里是将t赋值给返回值，此时返回值为1（这个返回值并不是t）
  3. 执行defer方法，将 t + 3 = 4
  4. 函数返回返回值 1

也可以按照如下代码理解

func DeferFunc2(i int) (result int) {
    t := i
    defer func() {
        t += 3
    }()
    return t
}

上面的代码return的时候相当于将t赋值给了result，当defer修改了t的值之后，对result是不会造成影响的。

DeferFunc3

func DeferFunc3(i int) (t int) {
    defer func() {
        t += i
    }()
    return 2
}
  1. 首先执行 return 将返回值t赋值为 2
  2. 执行defer方法将 t + 1
  3. 最后返回 3

DeferFunc4

func DeferFunc4() (t int) {
	defer func(i int) {
		fmt.Println("DeferFunc4 i=", i)
		fmt.Println("DeferFunc4 t=", t)
	}(t)
	println("DeferFunc4 , func start .")
	t = 1
	println("DeferFunc4 , func end .")
	return 2
}

输出顺序

DeferFunc4 , func start .
DeferFunc4 , func end .
DeferFunc4 i= 0
DeferFunc4 t= 2
  1. 初始化返回值t为零值 0
  2. 首先执行defer的第一步，赋值defer中的func入参t为0
  3. 执行defer的第二步，将defer压栈
  4. 将t赋值为1
  5. 执行return语句，将返回值t赋值为2
  6. 执行defer的第三步，出栈并执行

因为在入栈时defer执行的func的入参已经赋值了，此时它作为的是一个形式参数，所以打印为0；相对应的因为最后已经将t的值修改为2，所以再打印一个2

参考

感谢刘丹冰老师的总结，借此留笔记，如有版权纠纷，请速联系，立即删除。

26857259
关注
  • 16
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Golang巧用defer进行错误处理的方法
12-31
本文主要跟大家介绍了Golang巧用defer进行错误处理的相关内容，分享出来供大家参考学习，下面来看看详细的介绍： 问题引入 毫无疑问，错误处理是程序的重要组成部分，有效且优雅的处理错误是大多数程序员的追求。很多程序员都有C/C++的编程背景，Golang的程序员也不例外，他们处理错误有意无意的带着C/C++的烙印。 我们看看下面的例子，就有一种似曾相识的赶脚，代码如下： func deferDemo() error { err := createResource1() if err != nil { return ERR_CREATE_RESOURCE1_FAILED } er
聊聊golang的defer的使用
01-19
序 本文主要研究一下golang的defer defer return先赋值(对于命名返回值)，然后执行defer，最后函数返回 defer函数调用的执行顺序与它们分别所属的defer语句的执行顺序相反 defer后面的表达式可以是func或者是method的调用，如果defer的函数为nil，则会panic 实例 实例1 // f returns 42 func f() (result int) { defer func() { // result is accessed after it was set to 6 by the return stateme
Golang中多个defer的执行顺序以及defer在什么情况可以修改返回值
qq_28475461的博客
12-01 263
defer，return，return value（函数返回值） 执行顺序：首先return，其次return value，最后defer。Defer 作用：defer 延迟函数，释放资源，收尾工作；如释放锁，关闭文件，关闭链接，捕获 panic。多个 defer 调用顺序是 LIFO（后入先出），defer后的操作可以理解为压入栈中。避坑指南：defer 函数紧跟在资源打开后面，否则 defer 可能得不到执行，导致内存泄露。
go语言defer的执行顺序
byteinit的专栏
02-17 232
Go 语言中，defer 语句用于在函数退出之前执行一段代码。defer 语句的执行顺序是后进先出，也就是说，最后调用的 defer 语句会先执行，第一个调用的 defer 语句会最后执行。defer 语句可以用于清理资源、记录日志等。如果在使用 file 过程中发生错误，defer 语句仍然会执行，确保文件被正确关闭。
GoLang之defer底层系列一(v 1.12)
weixin_52690231的博客
05-10 367
GoLang之defer底层系列一(v 1.12)
defer 的执行顺序
myselfMa的博客
01-30 657
defer 的执行顺序 和 返回值的问题
golang学习--关于defer的执行顺序
cbmljs的博客
12-03 2647
实例一、 package main import ( "fmt" ) func main() { defer_call() } func defer_call() { defer func() { fmt.Println("打印前") }() defer func() { fmt.Println("打印中") }() defer func() { ...
defer语句调用顺序
weixin_51920241的博客
05-17 185
defer关键字,压栈形式，先入后出，后入先出 示例1，main.go package main import "fmt" func main() { //写入defer关键字,压栈形式 defer fmt.Println("main end1")//先入后出 defer fmt.Println("main end2")//后入先出 fmt.Println("main::hello go 1") fmt.Println("main::hello go 2") } 知
Go基础知识----defer源码和多个defer执行顺序
u013915286的博客
09-08 1010
etrh
Golang中defer、return、返回值之间执行顺序的坑
txj236的专栏
06-23 7470
Go语言中延迟函数defer充当着 cry...catch 的重任，使用起来也非常简便，然而在实际应用中，很多gopher并没有真正搞明白defer、return和返回值之间的执行顺序，从而掉进坑中，今天我们就来揭开它的神秘面纱！ 先来运行下面两段代码： A. 无名返回值的情况 package main import ( "fmt" ) func main() { fmt.P
golang中defer的使用规则详解
09-21
大家应该都知道在golang当中，defer代码块会在函数调用链表中增加一个函数调用。下面这篇文章主要给大家介绍了关于golang中defer的使用规则，文中介绍的非常详细，对大家具有一定的参考学习价值，需要的朋友们下面来...
golang中defer的关键特性示例详解
09-21
defer是golang语言中的关键字，用于资源的释放，会在函数返回之前进行调用。下面这篇文章主要给大家介绍了关于golang中defer的关键特性，文中通过示例代码介绍的非常详细，对大家具有一定的参考学习价值，需要的朋友...
Golang defer和return执行顺序
最新发布
什么都不会
02-19 431
首先，先了解一下 return 返回值的运行机制：return 并非原子操作，共分为两步操作。其次，defer 的执行顺序是先进后出 FILO，也就是先执行最后一个 defer，最后执行第一个 defer。
Golang 中return和defer执行先后顺序
YPLee_8的博客
09-04 838
Golang语言中函数的return不是原子操作，而是分为了两步：返回值赋值；真正函数返回
golang中的defer使用方式及实战技巧
bactcolor的博客
07-07 911
用好defer，会大大提高我们的代码可读性和稳健性，但是不合理的使用也可能会出现灾难性的结果，在平时的编码过程中，我们需要特别注意defer的各种特性，这样才能写出优秀的代码。
Golang中defer的三个实战要点
咖啡色的羊驼
08-25 4806
前言 Golang中的defer是使用频次比较高的，能创造出延迟生效特效的一种方式。 defer也有自己的矫情，需要注意的。 本文将从通过代码的方式来说明defer的三点矫情。 1.defer的生效顺序 2.defer与return,函数返回值之间的顺序 3.defer定义和执行两个步骤，做的事情。 正文 1.defer的生效顺序 先说结论：defer的执行顺序是倒序执行（同入栈...
defer链的执行顺序
小豆角的博客
04-22 302
defer先进后出，协程遇到panic时，遍历本协程的defer链表，并执行defer。 在defer执行过程中遇到recover则停止panic,返回recover处继续往下执行，如果没有recover，遍历完本协程的defer链之后，向stderr抛出panic信息，从执行顺序看，先进后出的顺序执行。 关注：defer的执行顺序，执行时参数的值，以及参数的执行顺序。之行时候参数的值斗志值拷...
三个例子了解defer执行顺序
ChesterSZ的博客
05-10 250
三个例子了解defer执行顺序 1.return先给返回值赋值 2.接着defer开始执行一些收尾工作 3.真正的返回 func f1() (r int) { t := 1 defer func() { t = t + 5 fmt.Printf(" t is %v\n", t) }() return t } r = t 把t的值（1）给变量r -> 因为这里的返回值是有名返回的 执行defer，t = 6 注意，这里并不影响返回值r 返回1 func f2() (r int) {
golang defer函数执行顺序
12-21
golang中的defer函数按照后进先出（LIFO）的顺序执行。也就是说，最后一个defer函数会最先执行，而第一个defer函数会最后执行。 下面是一个示例代码来说明defer函数的执行顺序： ```go package main import "fmt" func main() { defer fmt.Println("defer 1") defer fmt.Println("defer 2") defer fmt.Println("defer 3") fmt.Println("Hello, World!") } ``` 输出结果为： ``` Hello, World! defer 3 defer 2 defer 1 ``` 在这个示例中，"Hello, World!"会首先被打印出来，然后是最后一个defer函数"defer 3"，接着是"defer 2"，最后是"defer 1"。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值