Golang有关defer延迟函数的讨论与研究

延迟函数defer是Golang的一个语法糖,逻辑上defer是与普通函数适配的。所以在使用defer时,应该对应到一个函数中,而不是一个for循环语句内或一个代码块中,因为这样做是危险和无意义的。

import (
	"fmt"
	"sync"
)

func main() {

	/* 问题一:defer nil函数 */
	func(){
		var run func() = nil
		defer run()

		fmt.Println("runs")
	}()
	// 匿名函数执行结束后,defer函数被执行,因为run()为nil,而出现panic

	/* 问题二 在循环中使用defer */
	func() {
		for {
			wg := sync.WaitGroup{}
			wg.Add(1)
			// do something

			defer wg.Done()
		}
	}()
	// defer延迟函数会在该匿名函数结束后运行,而不是每次的for循环结束后。
	// 于是这些延迟函数会在每次循环中不停地堆积到延迟调用栈,最终导致不可预知的问题

	/* 问题二的解决方案1 */
	func() {
		for {
			wg := sync.WaitGroup{}
			wg.Add(1)
			// do something
			wg.Done()
		}
	}()
	// 这里需要注意,不使用defer,直接在for循环的每一次的末尾进行结束

	/* 问题二的解决方案2 */
	func() {
		for {
			func() {
				wg := sync.WaitGroup{}
				wg.Add(1)
				// do something
				defer wg.Done()
			}()
		}
	}()
	// for循环中嵌套匿名函数,这样延迟函数defer会在每次内部的匿名函数结束后执行

	/* 问题三 延迟调用含有闭包的函数 */
	{
		db := &database{}
		defer db.connect()
		fmt.Println("query db...")
		/* Output:
			query db...
			connect
		 */
	} // connect()函数执行结束后,其执行域被保存起来,但内部的闭包不会执行

	/* 问题三的解决方案1 */
	func() {
		db := &database{}
		close := db.connect()
		defer close()

		fmt.Println("query db...")
	}()
	// 将db.database()返回了一个函数,再对该函数使用defer,就可以在匿名函数结束后实际执行

	/* 问题三的解决方案2 */
	func() {
		db := &database{}
		defer db.connect()()
	}()
	// 这里与之前的解决方案没有本质区别。第一个括号是执行connect函数内部的方法,
	// 第二个括号是执行返回的闭包

}

type database struct {}

func (db *database) connect() (disconnect func()) {
	fmt.Println("connect")

	return func() {
		fmt.Println("disconnect")
	}
}
	/* 问题四:在执行块中使用defer */
func main() {
	{
		defer func() {
			fmt.Println("block: defer runs.")
		}()

		fmt.Println("block: ends")
	}
	fmt.Println("main: ends")
}
/* Output:
block: ends
main: ends
block: defer runs
*/
// 延迟是相对于一个函数而非一个代码块
func main() {
	func() {
		defer func() {
			fmt.Println("func: defer runs")
		}()
		fmt.Println("func: ends")
	}()
	fmt.Println("main: edns")
}
/* Output:
func: ends
func: defer runs
main: edns
*/
// 延迟函数在匿名函数结束后便执行,而不是等到main函数结束defer才执行
	/* 问题五:延迟方法的坑 */
type Car struct {
	model string
}

func (c Car) PrintModel() {
	fmt.Println(c.model)
}
func (c *Car) PrintModel1() {
	fmt.Println(c.model)
}

func main() {
	c := Car{model: "DeLorean DMC-12"}

	defer c.PrintModel()
	//defer c.PrintModel1()

	c.model = "Chevrolet Impala"
}
/*
	当defer调用的是PrintModel()时,输出结果是:DeLorean DMC-12
	当defer调用的是PrintModel1()时,输出结果是:Chevrolet Impala

	当以值为接收者的方法被defer修饰时,接收者会在声明时被拷贝,之后的修改都不会影响到这次拷贝的值
	而当以指针对象作为接收者的方法被defer修饰时,生成的新的指针变量的指向的地址与原对象c的指向地址相同,因此任何修改都作用于同一个对象中。
*/

将defer置于for循环中,每一次循环的defer函数都会保存在Defers stack中,所以结果是反向打印出来的。

	/* 问题六 */
func main() {
	for i:=0;i<4;i++ {
		defer fmt.Println(i)
	}
}
/*Output:
3
2
1
0
*/

下面的例子中,输出的结果是Hello的原因是,defer函数虽然是在所属函数执行完后才会执行,但是m.print()却是按照代码顺序立即执行出结果了,所以defer保存的就是Hello,故最后输出的结果是Hello

	/* 问题七 */
type message struct {
	content string
}
func (p *message) set(c string) {
	p.content = c
}
func (p *message) print() string {
	return p.content
}

func main() {
	func() {
		m := &message{content: "Hello"}
		defer fmt.Print(m.print())
		m.set("World")
		// deferred func runs
	}()
}
/*Output:
Hello
*/

变量i被初始化之后其值0会保存在某一个地址内,而循环结束后defer才会执行完毕,而defer准备去执行的时候,变量i的值是3,所以结果是打印三次3

	/* 问题八 */
func main() {
	for i := 0; i < 3; i++ {
		defer func() {
			fmt.Println(i)
		}()
	}
}
/*Output:
3
3
3
*/

为了想实现打印出2 1 0,有如下解决方案。
如此,go runtime会创建不同的变量i(i已经作为一个实参传入,那么实际上是会被复制的),并且保存预期正确的值。

func main() {
	for i := 0; i < 3; i++ {
		defer func(i int) {
			fmt.Println(i)
		}(i)
	}
}
/*Output:
2
1
0
*/

下面的例子,道理类似。将i赋给一个新的同名变量i,所以在每次循环时,都会初始化一个同名i的变量,所以执行三次defer函数时,都不会使用同一个值。

func main() {
	for i := 0; i < 3; i++ {
		i := i
		defer func() {
			fmt.Println(i)
		}()
	}
}
/*Output:
2
1
0
*/

这个例子能得到预期的结果,原因与之前例子打印出Hello的原因类似,defer后直接使用了打印语句,其实结果已经得到,只是并没有执行打印到控制台。当main函数结束后,defer会把之前得到的结果(结果保存在Defers Stack中)逐一弹出。

func main() {
	for i := 0; i < 3; i++ {
		defer fmt.Println(i)
	}

}
/*Output:
2
1
0
*/

首先需要提及的一个知识点是named result values,它可以让你将需要返回的结果值当作声明的变量来使用,并且你可以仅仅返回一个赤裸裸的return
然后看一下下面的例子,release()函数返回的结果是nil,因为defer函数的return是不会影响到正常的返回值。而如果强行想改变,那么需要考虑正常返回的变量和defer函数中返回的变量是同一个地址的变量。那么应用到命名结果值,在release1()函数中,defer延迟函数里,err的值被赋值为“error”,所以在返回时如果err变量不为空(为空当然会返回nil),就会返回err的值,如此defer延迟函数里的赋值就生效了。

	/* 问题九 */
func release() error {
	defer func() error {
		return errors.New("error")
	}()
	return nil
}

func release1() (err error) {
	defer func() {
		err = errors.New("error")
	}()
	return nil
}

func main() {
	fmt.Println(release())
	fmt.Println(release1())
}
/*Output:

error
*/

参考文章的示例,有所改动,并且内容并非完全翻译,都是笔者自己的话,所以不作为译文。

参考文章:
5 Gotchas of Defer in Go — Part I
5 More Gotchas of Defer in Go — Part II

你可能感兴趣的:(GoLang,golang,defer,延迟函数)