defer trong Golang: thứ tự, lúc tính đối số và các bẫy

defer làm gì

defer đẩy một lời gọi hàm vào một danh sách. Khi hàm bao quanh trả về, danh sách chạy theo thứ tự ngược lại.

package main

import "fmt"

func main() {
	fmt.Println("start")
	defer fmt.Println("deferred 1")
	defer fmt.Println("deferred 2")
	defer fmt.Println("deferred 3")
	fmt.Println("end")
}

Đầu ra:

start
end
deferred 3
deferred 2
deferred 1

Thứ tự là vào sau, ra trước, giống một ngăn xếp. Điều đó khớp với cách tài nguyên lồng nhau: nếu bạn mở A rồi đến B, thường bạn muốn đóng B trước A.

Dọn dẹp ngay cạnh chỗ lấy tài nguyên

Công dụng chính của defer là viết phần dọn dẹp ở dòng ngay sau chỗ lấy tài nguyên, để không đường trả về nào có thể quên nó.

package main

import (
	"bufio"
	"fmt"
	"os"
)

func countLines(path string) (int, error) {
	f, err := os.Open(path)
	if err != nil {
		return 0, err
	}
	defer f.Close()

	n := 0
	sc := bufio.NewScanner(f)
	for sc.Scan() {
		n++
	}
	return n, sc.Err()
}

func main() {
	tmp, err := os.CreateTemp("", "defer-*.txt")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.Remove(tmp.Name())
	fmt.Fprint(tmp, "one\ntwo\nthree\n")
	tmp.Close()

	n, err := countLines(tmp.Name())
	fmt.Println(n, err)

	_, err = countLines("/does/not/exist")
	fmt.Println(err)
}

Để ý thứ tự: kiểm tra lỗi trước, rồi mới defer. Nếu os.Open thất bại, f là nil, và defer f.Close() trước khi kiểm tra sẽ gọi Close trên một *os.File nil (trả về một lỗi bạn không bao giờ thấy, và gây hiểu nhầm cho người đọc).

Cùng dạng đó dùng được cho khóa:

mu.Lock()
defer mu.Unlock()

Nếu đoạn code ở giữa gây panic, mutex vẫn được mở khóa.

Đối số được tính ngay lập tức

Hàm được defer và các đối số của nó được tính khi câu lệnh defer chạy. Chỉ có bản thân lời gọi là phải chờ.

package main

import "fmt"

func main() {
	x := 1
	defer fmt.Println("deferred with argument:", x)
	defer func() {
		fmt.Println("deferred closure reads:", x)
	}()
	x = 2
	fmt.Println("x is now", x)
}

Đầu ra:

x is now 2
deferred closure reads: 2
deferred with argument: 1

fmt.Println("...", x) đã lấy giá trị 1 tại dòng defer. Closure không có đối số; nó đọc x khi cuối cùng được chạy. Hãy chọn dạng khớp với điều bạn muốn ghi lại.

Điều này cũng áp dụng cho receiver của phương thức. defer t.Stop() tính t ngay lập tức, nên gán lại t sau đó không làm thay đổi giá trị nào sẽ bị dừng.

Một mẹo đo thời gian phổ biến cố ý dùng quy tắc này:

func handle() {
	defer trace("handle")() // trace runs now, the returned func runs at exit
	// ...
}

trace("handle") được gọi ngay (nó có thể in "enter" và ghi lại thời điểm bắt đầu), và hàm nó trả về mới là thứ được defer.

defer trong vòng lặp

Các lời gọi defer chạy khi hàm trả về, không phải ở cuối mỗi lần lặp. Trong một vòng lặp qua nhiều tệp, điều này giữ mọi tệp mở cho đến khi hàm kết thúc.

for _, path := range paths {
	f, err := os.Open(path)
	if err != nil {
		return err
	}
	defer f.Close() // all files stay open until the function returns
	process(f)
}

Với hàng nghìn đường dẫn, đoạn code này sẽ cạn file descriptor. Hãy chuyển thân vòng lặp vào một hàm riêng để mỗi defer chạy theo từng lần lặp:

package main

import (
	"fmt"
	"os"
)

func processFile(path string) error {
	f, err := os.Open(path)
	if err != nil {
		return err
	}
	defer f.Close()
	info, err := f.Stat()
	if err != nil {
		return err
	}
	fmt.Println(info.Name(), info.Size(), "bytes")
	return nil
}

func main() {
	dir, err := os.MkdirTemp("", "defer-loop")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.RemoveAll(dir)

	var paths []string
	for i := range 3 {
		p := fmt.Sprintf("%s/file%d.txt", dir, i)
		if err := os.WriteFile(p, make([]byte, i*10), 0o644); err != nil {
			fmt.Println(err)
			return
		}
		paths = append(paths, p)
	}
	for _, p := range paths {
		if err := processFile(p); err != nil {
			fmt.Println(err)
		}
	}
}

Mỗi lần gọi processFile đóng tệp của nó trước khi tệp tiếp theo được mở. Một function literal gọi tại chỗ (func() { ... }()) hoạt động tương tự khi một hàm hỗ trợ có tên có vẻ hơi thừa.

Thay đổi giá trị trả về

Một closure được defer chạy sau khi câu lệnh return đã gán kết quả, và nó có thể sửa các kết quả có tên trước khi bên gọi nhìn thấy chúng.

package main

import (
	"errors"
	"fmt"
)

func double(n int) (result int) {
	defer func() { result *= 2 }()
	return n // result = n, then the defer doubles it
}

func save() (err error) {
	defer func() {
		if err != nil {
			err = fmt.Errorf("save failed: %w", err)
		}
	}()
	return errors.New("disk full")
}

func main() {
	fmt.Println(double(5))
	fmt.Println(save())
}

Đoạn này in ra 10 và save failed: disk full. Với kết quả không có tên, hàm defer vẫn chạy, nhưng không có cách nào thay đổi giá trị được trả về.

Giữ lại lỗi từ Close

defer f.Close() vứt bỏ lỗi từ Close. Với tệp chỉ đọc thì không sao. Với tệp bạn đã ghi, Close có thể báo một lần ghi cuối thất bại, nên lỗi đó quan trọng. Một kết quả có tên cho phép bạn giữ lại nó:

func writeReport(path string, data []byte) (err error) {
	f, err := os.Create(path)
	if err != nil {
		return err
	}
	defer func() {
		if cerr := f.Close(); cerr != nil && err == nil {
			err = cerr
		}
	}()
	_, err = f.Write(data)
	return err
}

errors.Join(err, f.Close()) là một cách ngắn hơn khi bạn muốn báo cả hai lỗi.

defer, panic và recover

Các lời gọi defer chạy trong lúc panic tháo ngăn xếp. Đó là nơi duy nhất recover có tác dụng, và là cách một máy chủ ngăn một request lỗi làm sập cả tiến trình. Chi tiết có ở trang panic và recover.

Các lời gọi defer không chạy khi chương trình thoát qua os.Exit hoặc log.Fatal. Nếu main defer phần dọn dẹp rồi gọi os.Exit(1), phần dọn dẹp bị bỏ qua.

Chi phí

Từ Go 1.14, phần lớn defer được trình biên dịch open-code và chỉ tốn vài nano giây. Dùng defer cho mọi lần nhả mutex và đóng tệp là phong cách bình thường. Defer bên trong vòng lặp là ngoại lệ: chúng không open-code được và phải dùng đường đi chậm hơn, thêm một lý do để chuyển thân vòng lặp vào hàm riêng.

Lỗi thường gặp

• Defer trước khi kiểm tra lỗi. Kiểm tra err từ Open trước, rồi mới defer Close.
• Mong dọn dẹp theo từng lần lặp trong vòng lặp. Defer chạy khi hàm kết thúc.
• Mong đối số được defer thấy các thay đổi sau đó. Đối số được chốt tại dòng defer. Dùng closure để đọc giá trị lúc kết thúc.
• Trông cậy vào defer khi có os.Exit. Nó không bao giờ chạy.