许多内置的带有返回值的函数无法进行延迟调用
在go语言中，调用自定义函数的结果值可以全部不存在(丢弃)。但是，对于具有非空白返回结果列表的内置函数，他们的调用的结果不可以抛弃，copy和recover例外。 换句话说，延迟执行函数的结果必须被抛弃，所以许多内置函数无法被延迟。
幸运的是，在实践中，很有偶需要延迟执行内置函数的地方。据我所知，只有append函数可能需要被延迟执行。这种情况下，我们可以把append包装到一个延迟执行函数里。
package main
import "fmt"
func main() {
s := []string{"a", "b", "c", "d"}
defer fmt.Println(s) // [a x y d]
// defer append(s[:1], "x", "y") // error
defer func() {
_ = append(s[:1], "x", "y")
}()
}
延迟函数值的时刻
延迟函数调用中的被调用函数可以是零函数值。对于这种情况，恐慌将在准备延迟调用被推入当前goroutine的延迟调用栈之前发生。
package main
import "fmt"
func main() {
defer fmt.Println("reachable")
var f func() // f is nil by default
defer f() // panic here
// The following lines are dead code.
fmt.Println("not reachable")
f = func() {}
}
在将延迟调用推入当前goroutine的延迟调用堆栈之前，还会计算延迟函数调用的参数
延迟调用使得代码清晰，并且bug少
import "os"
func withoutDefers(filepath string, head, body []byte) error {
f, err := os.Open(filepath)
if err != nil {
return err
}
_, err = f.Seek(16, 0)
if err != nil {
f.Close()
return err
}
_, err = f.Write(head)
if err != nil {
f.Close()
return err
}
_, err = f.Write(body)
if err != nil {
f.Close()
return err
}
err = f.Sync()
f.Close()
return err
}
func withDefers(filepath string, head, body []byte) error {
f, err := os.Open(filepath)
if err != nil {
return err
}
defer f.Close()
_, err = f.Seek(16, 0)
if err != nil {
return err
}
_, err = f.Write(head)
if err != nil {
return err
}
_, err = f.Write(body)
if err != nil {
return err
}
return f.Sync()
}
延迟函数调用导致的性能损失
使用延迟函数调用并不总是好的。到目前为止(Go 1.12)，对于官方Go编译器，延迟函数调用将在运行时导致一些性能损失.
例如，在以下示例中，CounterB和IncreaseB方法比CounterA和IncreaseA方法更有效。
import "sync"
type T struct {
mu sync.Mutex
n int64
}
func (t *T) CounterA() int64 {
t.mu.Lock()
defer t.mu.Unlock()
return t.n
}
func (t *T) CounterB() (count int64) {
t.mu.Lock()
count = t.n
t.mu.Unlock()
return
}
func (t *T) IncreaseA() {
t.mu.Lock()
defer t.mu.Unlock()
t.n++
}
func (t *T) IncreaseB() {
t.mu.Lock()
t.n++ // this line will not panic for sure
t.mu.Unlock()
}
在B版本的函数中，我们应该保证Lock和Unlock调用之间的代码永远不会出现恐慌。通常，建议在实践中使用A版本功能。当我们真正关心所涉及功能的性能时，我们应该只采用B版本。
延迟函数调用导致的资源泄漏
非常大的延迟调用堆栈也可能消耗大量内存，并且未执行的延迟调用可能会阻止某些资源及时释放。例如，如果在调用以下函数时需要处理许多文件，则在函数退出之前将不会释放大量文件处理程序。
func writeManyFiles(files []File) error {
for _, file := range files {
f, err := os.Open(file.path)
if err != nil {
return err
}
defer f.Close()
_, err = f.WriteString(file.content)
if err != nil {
return err
}
err = f.Sync()
if err != nil {
return err
}
}
return nil
}
对于这种情况，我们可以使用匿名函数来包含延迟调用，以便延迟函数调用将更早执行。例如，上述功能可以重写和改进
func writeManyFiles(files []File) error {
for _, file := range files {
if err := func() error {
f, err := os.Open(file.path)
if err != nil {
return err
}
defer f.Close()
_, err = f.WriteString(file.content)
if err != nil {
return err
}
return f.Sync()
}(); err != nil {
return err
}
}
return nil
}
