「Go语言面试题」08 - Go中的defer语句有什么特点和用途？

func main() {
    defer fmt.Println("最后执行")
    fmt.Println("先执行")
}
// 输出：
// 先执行
// 最后执行

func fileProcessing() {
    f, _ := os.Open("file.txt")
    defer f.Close() // 函数返回前执行
    
    // 文件处理...
    // 即使发生panic，f.Close()仍会执行
}

func main() {
    defer fmt.Println("第一")
    defer fmt.Println("第二")
    defer fmt.Println("第三")
}
// 输出：
// 第三
// 第二
// 第一

func main() {
    start := time.Now()
    defer fmt.Println("耗时:", time.Since(start)) // 参数立即计算
    
    time.Sleep(time.Second)
}
// 输出：耗时: 0s（而非1秒）

func double(x int) (result int) {
    defer func() { result = x * 2 }()
    return x // 返回值被defer修改
}

fmt.Println(double(3)) // 输出6而不是3

func safeCall() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("恢复:", r)
        }
    }()
    panic("发生错误")
}

func processFile(path string) error {
    file, err := os.Open(path)
    if err != nil {
        return err
    }
    defer file.Close() // 确保文件关闭
    
    // 处理文件内容...
    return nil
}

var mu sync.Mutex
var balance int

func deposit(amount int) {
    mu.Lock()
    defer mu.Unlock() // 确保锁释放
    
    balance += amount
}

func processRequest() {
    start := time.Now()
    defer func() {
        fmt.Printf("请求处理耗时: %v\n", time.Since(start))
    }()
    
    // 请求处理逻辑...
}

func readConfig() (Config, error) {
    var config Config
    file, err := os.Open("config.json")
    if err != nil {
        return config, fmt.Errorf("打开文件失败: %w", err)
    }
    defer file.Close()
    
    if err := json.NewDecoder(file).Decode(&config); err != nil {
        return config, fmt.Errorf("解析失败: %w", err)
    }
    
    return config, nil
}

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        defer func() {
            log.Printf(
                "%s %s %v",
                r.Method,
                r.URL.Path,
                time.Since(start),
            )
        }()
        next.ServeHTTP(w, r)
    })
}

// 伪代码展示defer实现
func example() {
    // defer fmt.Println("deferred")
    d := struct {
        fn func() // 记录defer函数
        link *defer // 指向下一个defer
    }{fn: func() { fmt.Println("deferred") }}
    
    runtime.deferproc(&d)
    
    // 函数体...
    
    runtime.deferreturn()
}

// 错误：每次循环创建defer记录
for i := 0; i < 10000; i++ {
    f, _ := os.Open("file")
    defer f.Close() // 积累大量defer记录
}

// 正确：使用函数包装
for i := 0; i < 10000; i++ {
    func() {
        f, _ := os.Open("file")
        defer f.Close()
        // 处理文件
    }()
}

// 低效：涉及闭包捕获
func sum(a, b int) (result int) {
    defer func() { result = a + b }()
    return 0
}

// 高效：直接操作返回值
func sum(a, b int) int {
    result := a + b
    return result
}

// 开启defer池（默认启用）
// 编译器自动优化，无需代码更改

func main() {
    value := 1
    defer fmt.Println("值:", value) // 立即捕获value=1
    value = 2
}
// 输出：值: 1

defer func() { fmt.Println("值:", value) }() // 输出: 值: 2

func main() {
    defer fmt.Println("不会执行")
    os.Exit(0) // 立即终止，不执行defer
}

func leaky() {
    ch := make(chan int)
    go func() {
        defer close(ch) // 可能永远不会执行
        // 长时间运行...
    }()
    return // goroutine仍在运行
}

ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()

select {
case <-ch:
case <-ctx.Done():
}

// 理想实践示例
func process() (err error) {
    conn, err := acquireConnection()
    if err != nil {
        return err
    }
    defer releaseConnection(conn) // 资源释放
    
    mu.Lock()
    defer mu.Unlock() // 锁管理
    
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("panic: %v", r)
        }
    }() // 错误处理
    
    // 业务逻辑...
    return nil
}