天天看點
傳回

聽說，99% 的 Go 程式員都被 defer 坑過

原文連結： 聽說，99% 的 Go 程式員都被 defer 坑過

先聲明：我被坑過。

之前寫 Go 專欄時，寫過一篇文章：Go 專欄｜錯誤處理：defer，panic 和 recover。有小夥伴留言說：道理都懂，但還是不知道怎麼用，而且還總出現莫名奇妙的問題。

出問題就對了，這個小東西壞的很，一不留神就出錯。

是以，面對這種情況，我們今天就不講道理了。直接把我珍藏多年的代碼一把梭，憑借多年踩坑經曆和寫 BUG 經驗，我要站着把這個坑邁過去。

一、

先來一個簡單的例子熱熱身：

package main

import (
    "fmt"
)

func main() {
    defer func() {
        fmt.Println("first")
    }()

    defer func() {
        fmt.Println("second")
    }()

    fmt.Println("done")
}

輸出：

done
second
first

這個比較簡單，

defer

語句的執行順序是按調用

defer

語句的倒序執行。

二、

看看這段代碼有什麼問題？

for _, filename := range filenames {
    f, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer f.Close()
}

這段代碼其實很危險，很可能會用盡所有檔案描述符。因為

defer

語句不到函數的最後一刻是不會執行的，也就是說檔案始終得不到關閉。是以切記，一定不要在

for

循環中使用

defer

語句。

那怎麼優化呢？可以将循環體單獨寫一個函數，這樣每次循環的時候都會調用關閉函數。

如下：

for _, filename := range filenames {
    if err := doFile(filename); err != nil {
        return err
    }
}

func doFile(filename string) error {
    f, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer f.Close()
}

三、

看看這三個函數的輸出結果是什麼？

package main

import (
	"fmt"
)

func a() (r int) {
	defer func() {
		r++
	}()
	return 0
}

func b() (r int) {
	t := 5
	defer func() {
		t = t + 5
	}()
	return t
}

func c() (r int) {
	defer func(r int) {
		r = r + 5
	}(r)
	return 1
}

func main() {
	fmt.Println("a = ", a())
	fmt.Println("b = ", b())
	fmt.Println("c = ", c())
}

公布答案：

a =  1
b =  5
c =  1

你答對了嗎？

說實話剛開始看到這個結果時，我是相當費解，完全不知道怎麼回事。

但可以看到，這三個函數都有一個共同特點，它們都有一個命名傳回值，并且都在函數中引用了這個傳回值。

引用的方式分兩種：分别是閉包和函數參數。

先看

a()

函數：

閉包通過

r++

修改了外部變量，傳回值變成了 1。

相當于：

func aa() (r int) {
	r = 0
	// 在 return 之前，執行 defer 函數
	func() {
		r++
	}()
	return
}

再看

b()

閉包内修改的隻是局部變量

t

，而外部變量

t

不受影響，是以還是傳回 5。

func bb() (r int) {
	t := 5
	// 指派
	r = t
	// 在 return 之前，執行 defer 函數
	// defer 函數沒有對傳回值 r 進行修改，隻是修改了變量 t
	func() {
		t = t + 5
	}()
	return
}

最後是

c

參數傳遞是值拷貝，實參不受影響，是以還是傳回 1。

func cc() (r int) {
	// 指派
	r = 1
	// 這裡修改的 r 是函數形參的值
	// 值拷貝，不影響實參值
	func(r int) {
		r = r + 5
	}(r)
	return
}

那麼，為了避免寫出這麼令人意外的代碼，最好在定義函數時就不要使用命名傳回值。或者如果使用了，就不要在

defer

中引用。

再看下面兩個例子：

func d() int {
	r := 0
	defer func() {
		r++
	}()
	return r
}

func e() int {
	r := 0
	defer func(i int) {
		i++
	}(r)
	return 0
}
           
d =  0
e =  0

傳回值符合預期，再也不用絞盡腦汁猜了。

四、

defer

表達式的函數如果在

panic

後面，則這個函數無法被執行。

func main() {
    panic("a")
    defer func() {
        fmt.Println("b")
    }()
}

輸出如下，

b

沒有列印出來。

panic: a

goroutine 1 [running]:
main.main()
	xxx.go:87 +0x4ce
exit status 2

而如果

defer

在前，則可以執行。

func main() {
	defer func() {
		fmt.Println("b")
	}()
	panic("a")
}
           
b
panic: a

goroutine 1 [running]:
main.main()
    xxx.go:90 +0x4e7
exit status 2

五、

看看下面這段代碼的執行順序：

func G() {
	defer func() {
		fmt.Println("c")
	}()

	F()
	fmt.Println("繼續執行")
}

func F() {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("捕獲異常:", err)
		}
		fmt.Println("b")
	}()
	panic("a")
}

func main() {
	G()
}

順序如下：

  1. 調用

    G()

     函數；

  2. F()

  3. F()

     中遇到

    panic

     ，立刻終止，不執行

    panic

     之後的代碼；
  4. 執行

    F()

     中

    defer

     函數，遇到

    recover

     捕獲錯誤，繼續執行

    defer

     中代碼，然後傳回；

  5. G()

     函數後續代碼，最後執行

    G()

    defer

     函數。 
捕獲異常: a
b
繼續執行
c
           
func G() {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("捕獲異常:", err)
		}
		fmt.Println("c")
	}()

	F()
	fmt.Println("繼續執行")
}

func F() {
	defer func() {
		fmt.Println("b")
	}()
	panic("a")
}

func main() {
	G()
}

  1. G()

  2. F()

  3. F()

    panic

    panic

  4. F()

    defer

     函數，由于沒有

    recover

     ，則将

    panic

     抛到

    G()

     中；

  5. G()

     收到

    panic

     則不會執行後續代碼，直接執行

    defer

  6. defer

     中捕獲

    F()

     抛出的異常

    a

     ，然後繼續執行，最後退出。 
b
捕獲異常: a
c

六、

func G() {
	defer func() {
		fmt.Println("c")
	}()

	F()
	fmt.Println("繼續執行")
}

func F() {
	defer func() {
		fmt.Println("b")
	}()
	panic("a")
}

func main() {
	G()
}

  1. G()

  2. F()

  3. F()

    panic

    panic

  4. F()

    defer

    recover

    panic

    G()

  5. G()

    panic

    defer
  6. 由于沒有

    recover

     ，直接抛出

    F()

     抛過來的異常

    a

     ，然後退出。 
b
c
panic: a

goroutine 1 [running]:
main.F()
	xxx.go:90 +0x5b
main.G()
	xxx.go:82 +0x48
main.main()
	xxx.go:107 +0x4a5
exit status 2

七、

func G() {
	defer func() {
		// goroutine 外進行 recover
		if err := recover(); err != nil {
			fmt.Println("捕獲異常:", err)
		}
		fmt.Println("c")
	}()

	// 建立 goroutine 調用 F 函數
	go F()
	time.Sleep(time.Second)
}

func F() {
	defer func() {
		fmt.Println("b")
	}()
	// goroutine 内部抛出panic
	panic("a")
}

func main() {
	G()
}

  1. G()
  2. 通過 goroutine 調用

    F()

  3. F()

    panic

    panic

  4. F()

    defer

    recover

    panic

    G()
  5. 由于 goroutine 内部沒有進行

    recover

     ，則 goroutine 外部函數，也就是

    G()

     函數是沒辦法捕獲的，程式直接崩潰退出。 
b
panic: a

goroutine 6 [running]:
main.F()
	xxx.go:96 +0x5b
created by main.G
	xxx.go:87 +0x57
exit status 2

八、

最後再說一個

recover

的傳回值問題：

defer func() {
	if err := recover(); err != nil {
		fmt.Println("捕獲異常:", err.Error())
	}
}()
panic("a")

recover

傳回的是

interface {}

類型，而不是

error

類型，是以這樣使用的話會報錯：

err.Error undefined (type interface {} is interface with no methods)

可以這樣來轉換一下：

defer func() {
	if err := recover(); err != nil {
		fmt.Println("捕獲異常:", fmt.Errorf("%v", err).Error())
	}
}()
panic("a")

或者直接列印結果：

defer func() {
	if err := recover(); err != nil {
		fmt.Println("捕獲異常:", err)
	}
}()
panic("a")
           
捕獲異常: a

以上就是本文的全部内容，其實寫過其他的語言的同學都知道，關閉檔案句柄，釋放鎖等操作是很容易忘的。而 Go 語言通過

defer

很好地解決了這個問題，但在使用過程中還是要小心。

本文總結了一些容踩坑的點，希望能夠幫助大家少寫 BUG，如果大家覺得有用的話，歡迎點贊和轉發。

文章中的腦圖和源碼都上傳到了 GitHub，有需要的同學可自行下載下傳。

源碼位址：

  • https://github.com/yongxinz/gopher/tree/main/sc

推薦閱讀：

  • gRPC，爆贊
  • 使用 grpcurl 通過指令行通路 gRPC 服務
  • 推薦三個實用的 Go 開發工具
  • 被 Docker 日志坑慘了

參考：

  • 《Go 語言核心程式設計》
  • https://www.jianshu.com/p/63e3d57f285f
recover panic defer go
上一篇: Go gRPC進階-逾時設定（六）
下一篇: 使用 grpcurl 通過指令行通路 gRPC 服務

繼續閱讀