在Golang中如何确保资源在出错时也能被正确关闭

defer

panic

return

defer

defer

defer

defer f.Close()

Close()

Close()

package main

import (
    "fmt"
    "io"
    "log"
    "os"
)

func readFile(filename string) ([]byte, error) {
    f, err := os.Open(filename)
    if err != nil {
        return nil, fmt.Errorf("failed to open file: %w", err)
    }
    // 关键在这里：defer语句确保文件在函数退出前关闭
    // 即使这里出错了，下面的匿名函数也会执行
    defer func() {
        closeErr := f.Close()
        if closeErr != nil {
            // 如果关闭文件时出错，我们通常会记录下来
            // 特别是当函数已经有其他错误时，避免覆盖主错误
            log.Printf("Error closing file %s: %v", filename, closeErr)
        }
    }()

    data, err := io.ReadAll(f)
    if err != nil {
        return nil, fmt.Errorf("failed to read file: %w", err)
    }

    return data, nil
}

func main() {
    // 示例：成功读取文件
    content, err := readFile("example.txt")
    if err != nil {
        log.Fatalf("Error: %v", err)
    }
    fmt.Printf("File content: %s\n", string(content))

    // 示例：尝试读取不存在的文件
    _, err = readFile("nonexistent.txt")
    if err != nil {
        fmt.Printf("Expected error for nonexistent file: %v\n", err)
    }

    // 假设 "example.txt" 存在，但我们模拟一个读取错误
    // 为了演示，我们无法直接在readFile内部模拟io.ReadAll的错误
    // 但你可以想象，即使io.ReadAll出错，defer的f.Close()依然会执行
}

// 为了让上面的例子能运行，创建一个example.txt
// echo "Hello, Go defer!" > example.txt

defer

defer

return

defer

defer

Close()

Close()

defer

Close()

package main

import (
    "fmt"
    "log"
    "os"
    "sync"
)

// MyComplexResource 模拟一个管理多个内部资源的复杂结构体
type MyComplexResource struct {
    file1 *os.File
    file2 *os.File
    mu    sync.Mutex // 假设内部还有个锁
    // ... 其他资源
}

// NewMyComplexResource 构造函数，打开并初始化所有内部资源
func NewMyComplexResource(filename1, filename2 string) (*MyComplexResource, error) {
    f1, err := os.Open(filename1)
    if err != nil {
        return nil, fmt.Errorf("failed to open file1: %w", err)
    }

    f2, err := os.Open(filename2)
    if err != nil {
        // 如果f2打开失败，f1也需要关闭
        _ = f1.Close() // 忽略关闭f1的错误，因为主错误是f2的打开失败
        return nil, fmt.Errorf("failed to open file2: %w", err)
    }

    return &MyComplexResource{
        file1: f1,
        file2: f2,
    }, nil
}

// Close 方法负责关闭所有内部资源
// 注意：defer在这里是LIFO，所以f2会先关，f1后关
func (mcr *MyComplexResource) Close() error {
    var errs []error

    // 假设锁也需要释放
    // mcr.mu.Unlock() // 实际应用中，锁的释放通常是配对的，不会在这里集中释放

    if mcr.file2 != nil {
        if err := mcr.file2.Close(); err != nil {
            errs = append(errs, fmt.Errorf("failed to close file2: %w", err))
        }
    }

    if mcr.file1 != nil {
        if err := mcr.file1.Close(); err != nil {
            errs = append(errs, fmt.Errorf("failed to close file1: %w", err))
        }
    }

    if len(errs) > 0 {
        // Go 1.20+ 可以用 errors.Join
        // return errors.Join(errs...)
        // 否则，手动拼接错误信息
        return fmt.Errorf("errors during MyComplexResource close: %v", errs)
    }
    return nil
}

func main() {
    // 为了演示，创建两个文件
    os.WriteFile("res1.txt", []byte("Resource 1 data"), 0644)
    os.WriteFile("res2.txt", []byte("Resource 2 data"), 0644)

    res, err := NewMyComplexResource("res1.txt", "res2.txt")
    if err != nil {
        log.Fatalf("Failed to create complex resource: %v", err)
    }
    defer func() {
        if closeErr := res.Close(); closeErr != nil {
            log.Printf("Error closing complex resource: %v", closeErr)
        }
    }()

    fmt.Println("MyComplexResource opened and ready for use.")
    // ... 使用 res ...
    fmt.Println("MyComplexResource usage finished.")
}

defer

defer

Close

defer

defer

Close()

Close()

defer

Close

Close