defer深度实践：一个关于defer的故事

迈不过友情╰ 2023-01-16 11:19 140阅读 0赞

##  筚路蓝缕，以启山林。抚有蛮夷，以属华夏。不鸣则已，一鸣惊人。                                                                                                             ——《左传\`宣公十二年》     ##

一个关于defer的故事，纯干货分享。

> 作用：defer常用来释放连接、关闭资源、捕获panic、延时执行一些代码等；
> 
> 特点总结：
> 
> 1，先写的defer后执行，后写的先执行，panic后的不执行
> 
> 2，defer recover和panic同时存在时，代码走到panic后开始走所有defer；
> 
> 3，main线中defer recover()时不能捕获其它goroutine中的panic, 但可捕获到main线自己(甚至函数内部)的panic；
> 
> 4，其它goroutine内部panic后，main线的defer并不会执行。
> 
> defer是老生常谈的点，使用不当可能造成问题，以平时的实践为基础，我们一起来探究一些地方。

**目录**

一个面熟的代码

作用域

defer的执行形态及其影响

要defer的目标

1，函数为nil时

2，要defer的是链式调用

3，要修改返回值

--------------------

# 一个面熟的代码 #

先来看看一段代码

defer fmt.Println("A")
    	defer func() {
    		if err := recover(); err != nil {
    			fmt.Println("err:", err)
    		}
    	}()
    	defer fmt.Println("B")
    	defer fmt.Println("C")
    	panic("D")   // 如果defer中有recover进行捕获，则程序中不会再panic。
    	defer fmt.Println("E")
    	/*
    	C
    	B
    	err: D
    	A
    	*/

# 作用域 #

以简单情形看：

func loopF1() {
    	for i := 1; i <= 5; {
    		defer fmt.Println(i) // Possible resource leak, 'defer' is called in a 'for' loop
    		i++
    	}
    }

如上，第一种defer在循环未结束之前都没有执行(未回收内存资源)，只有循环结束后才会开始执行，执行完后释放内存，如果循环次数非常大则这里造成的问题可想而知；

对此，改良方式如下：

func loopF2() {
    	for i := 1; i <= 5; i++ {
    		func() {
    			defer fmt.Println(i)
    		}()
    	}
    }

我们让defer的执行单个循环进行一次，每次循环结束本次defer即结束；区别就是defer所在的作用域。

相比之下，第二种更不容易出错。

实际举例来看

如：创建大量文件，每循环一次则完成一次defer close，这里加defer的目的就是让单次循环结束后执行defer，但事实并不是

func writeFiles1(str []string) error {
    	for i, s := range str {
    		f, err := os.Create("./panic_t/" + strconv.Itoa(i+1) + ".txt")
    		if err != nil {
    			return err
    		}
    
            fmt.Println("create success")
    		defer f.Close()
    
    		_, err = f.WriteString(s)
    		if err != nil {
    			return err
    		}
    
    		err = f.Sync()
    		if err != nil {
    			return err
    		}
    	}
    
    	return nil
    }

这只会在循环结束后才一 一close, 打开的资源太多而没有及时清理极其容易出问题，正如提示的那样：Possible resource leak, 'defer' is called in a 'for' loop.  改良如下：

func writeFiles2(str []string) error {
    	for i, s := range str {
    		if err := func() error {
    			f, err := os.Create("./panic_t/" + strconv.Itoa(i+1) + ".txt")
    			if err != nil {
    				return err
    			}
    			fmt.Println("create success")
    			defer f.Close()
    
    			_, err = f.WriteString(s)
    			if err != nil {
    				return err
    			}
    
    			return f.Sync()
    		}(); err != nil {
    			return err
    		}
    	}
    
    	return nil
    }

# defer的执行形态及其影响 #

1，defer  xxx

2,  defer func() \{ xxx \}()

到底有没有区别，我们看一段代码：

a := 1
    	defer fmt.Println(a) // 1
    	a++
    	fmt.Println(a) // 2

当代码走到defer这一行时，由于使用了defer所以打印并不会立即执行，而是压入到堆栈中，此时括号中的a=1 已经确定，此后代码中虽然修改了该变量值，但对已经defer的函数没有影响，切片来看也是一样的：

arr := []string{"A", "B", "C"}
    	defer fmt.Println(arr) // [A B C]
    	arr = append(arr, "D")
    	fmt.Println(arr) // [A B C D]

但是

a := 1
    	defer fmt.Println("a3=", a) // 1
    	defer func() {  // 继续打印
    		fmt.Println("a2=", a) // 2
    	}()
    	a++
    	fmt.Println("a1=", a) // 2

基于闭包的情况下，a2=2而不是打印1，这里涉及到闭包相关的要点。原因是闭包=函数+引用环境，a是闭包所捕获的变量而非闭包内部的局部变量，闭包捕获的(外部)变量相当于引用传递。

# 要defer的目标 #

### 1，函数为nil时 ###

defer fmt.Println("B")
    	var f func()
    	//f()
    	fmt.Println("C")
    	defer f()    // panic: runtime error: invalid memory address or nil pointer dereference
    	fmt.Println("A:", f == nil) // A: true

函数为nil时，defer中会panic，这没什么说的。再如闭包变量覆盖：

f := func() {
    		fmt.Println("A")
    	}
    	defer f() // A
    	f = func() {
    		//panic("hhh")
    		fmt.Println("B")
    	}
    	defer f() // B

### 2，要defer的是多层调用 ###

type T string
    
    func (t *T) fun(n string) *T {
    	fmt.Print(n)
    	return t
    }
    
    // ACDB
    func main() {
    	var t T
    	defer t.fun("A").fun("B")
    	t.fun("C").fun("D")
    }

执行fun("A")后，fun("B")被推入延迟调用堆栈并开始执行t.fun("C").fun("D")。

### 3，要修改返回值 ###

func testModify(n int) (num int) {
    	defer func() {
    		num *= 2
    	}()
    	return n + 1
    }
    
    	n := testModify(1)
    	fmt.Println(n) // 4

再如修改要返回的切片：

func f2() (arr []string) {
    	defer func() {
    		arr = append(arr, "D")
    	}()
    	return []string{"A", "B", "C"}
    }
    
    // [A B C D]

注意：只能修改有定义返回值名称的情况，匿名返回值时不能修改：

func testModify(n int) int {
    	n += 1
    	defer func() {
    		n *= 2
    	}()
    	return n
    }
    
    func main() {
    	n := testModify(1)
    	fmt.Println(n) // 2
    }

因为匿名返回值函数是在return执行时被声明。

如果觉得本文对你有帮助，可以动动手指哦！

如果有什么建议欢迎留意提出~