更多关于延迟函数调用的知识点

延迟调用函数已经在前面介绍过了。 限于当时对Go的了解程度，很多延迟调用函数相关的细节和用例并没有在之前的文章中提及。 这些细节和用例将在本文中列出。

很多有返回值的内置函数是不能被延迟调用的

在Go中，自定义函数的调用的返回结果都可以被舍弃。 但是，大多数内置函数（除了copy和recover）的调用的返回结果都不可以舍弃（至少对于标准编译器1.16来说是如此）。 另一方面，我们已经了解到延迟函数调用的所有返回结果必须都舍弃掉。 所以，很多内置函数是不能被延迟调用的。

幸运的是，在实践中，延迟调用内置函数的需求很少见。 根据我的经验，只有append函数有时可能会需要被延迟调用。 对于这种情形，我们可以延迟调用一个调用了append函数的匿名函数来满足这个需求。

  1. package main
  3. import "fmt"
  5. func main() {
  6.     s := []string{"a", "b", "c", "d"}
  7.     defer fmt.Println(s) // [a x y d]
  8.     // defer append(s[:1], "x", "y") // 编译错误
  9.     defer func() {
  10.         _ = append(s[:1], "x", "y")
  11.     }()
  12. }

延迟调用的函数值的估值时刻

一个被延迟调用的函数值是在其调用被推入延迟调用堆栈之前被估值的。 例如，下面这个例子将输出false。

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var f = func () {
  7.         fmt.Println(false)
  8.     }
  9.     defer f()
  10.     f = func () {
  11.         fmt.Println(true)
  12.     }
  13. }

一个被延迟调用的函数值可能是一个nil函数值。这种情形将导致一个恐慌。 对于这种情形，恐慌产生在此延迟调用被执行而不是被推入延迟调用堆栈的时候。 一个例子：

  1. package main
  3. import "fmt"
  5. func main() {
  6.     defer fmt.Println("此行可以被执行到")
  7.     var f func() // f == nil
  8.     defer f()    // 将产生一个恐慌
  9.     fmt.Println("此行可以被执行到")
  10.     f = func() {} // 此行不会阻止恐慌产生
  11. }

延迟方法调用的属主实参的估值时刻

前面的文章曾经解释过：一个延迟调用的实参也是在此调用被推入延迟调用堆栈之前估值的。 方法的属主实参也不例外。比如，下面这个程序将打印出1342。

  1. package main
  3. type T int
  5. func (t T) M(n int) T {
  6.   print(n)
  7.   return t
  8. }
  10. func main() {
  11.     var t T
  12.     // t.M(1)是方法调用M(2)的属主实参，因此它
  13.     // 将在M(2)调用被推入延迟调用堆栈之前被估值。
  14.     defer t.M(1).M(2)
  15.     t.M(3).M(4)
  16. }

延迟调用使得代码更简洁和鲁棒

一个例子：

  1. import "os"
  3. func withoutDefers(filepath string, head, body []byte) error {
  4.     f, err := os.Open(filepath)
  5.     if err != nil {
  6.         return err
  7.     }
  9.     _, err = f.Seek(16, 0)
  10.     if err != nil {
  11.         f.Close()
  12.         return err
  13.     }
  15.     _, err = f.Write(head)
  16.     if err != nil {
  17.         f.Close()
  18.         return err
  19.     }
  21.     _, err = f.Write(body)
  22.     if err != nil {
  23.         f.Close()
  24.         return err
  25.     }
  27.     err = f.Sync()
  28.     f.Close()
  29.     return err
  30. }
  32. func withDefers(filepath string, head, body []byte) error {
  33.     f, err := os.Open(filepath)
  34.     if err != nil {
  35.         return err
  36.     }
  37.     defer f.Close()
  39.     _, err = f.Seek(16, 0)
  40.     if err != nil {
  41.         return err
  42.     }
  44.     _, err = f.Write(head)
  45.     if err != nil {
  46.         return err
  47.     }
  49.     _, err = f.Write(body)
  50.     if err != nil {
  51.         return err
  52.     }
  54.     return f.Sync()
  55. }

上面哪个函数看上去更简洁？显然，第二个使用了延迟调用的函数，虽然只是简洁了些许。 另外第二个函数将导致更少的bug，因为第一个函数中含有太多的f.Close()调用，从而有较高的几率漏掉其中一个。

下面是另外一个延迟调用使得代码更鲁棒的例子。 如果doSomething函数产生一个恐慌，则函数f2在退出时将导致互斥锁未解锁。 所以函数f1更鲁棒。

  1. var m sync.Mutex
  3. func f1() {
  4.     m.Lock()
  5.     defer m.Unlock()
  6.     doSomething()
  7. }
  9. func f2() {
  10.     m.Lock()
  11.     doSomething()
  12.     m.Unlock()
  13. }

延迟调用可能会导致性能损失

延迟调用并非没有缺点。对于早于1.13版本的官方标准编译器来说，延迟调用将导致一些性能损失。 从Go官方工具链1.13版本开始，官方标准编译器对一些常见的延迟调用场景做了很大的优化。 因此，一般我们不必太在意延迟调用导致的性能损失。感谢Dan Scales实现了此优化。

延迟调用导致的暂时性内存泄露

一个较大的延迟调用堆栈可能会消耗很多内存，而且延迟调用堆栈中尚未执行的延迟调用可能会导致某些资源未被及时释放。 比如，如果下面的例子中的函数需要处理大量的文件，则在此函数推出之前，将有大量的文件句柄得不到释放。

  1. func writeManyFiles(files []File) error {
  2.     for _, file := range files {
  3.         f, err := os.Open(file.path)
  4.         if err != nil {
  5.             return err
  6.         }
  7.         defer f.Close()
  9.         _, err = f.WriteString(file.content)
  10.         if err != nil {
  11.             return err
  12.         }
  14.         err = f.Sync()
  15.         if err != nil {
  16.             return err
  17.         }
  18.     }
  20.     return nil
  21. }

对于这种情形，我们应该使用一个匿名函数将需要及时执行延迟的调用包裹起来。比如，上面的函数可以改进为如下：

  1. func writeManyFiles(files []File) error {
  2.     for _, file := range files {
  3.         if err := func() error {
  4.             f, err := os.Open(file.path)
  5.             if err != nil {
  6.                 return err
  7.             }
  8.             defer f.Close() // 将在此循环步步尾执行
  10.             _, err = f.WriteString(file.content)
  11.             if err != nil {
  12.                 return err
  13.             }
  15.             return f.Sync()
  16.         }(); err != nil {
  17.             return err
  18.         }
  19.     }
  21.     return nil
  22. }