MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Go defer的功能与用途

2024-08-105.7k 阅读

Go defer 的基本概念

在 Go 语言中，defer 语句用于延迟一个函数的执行，直到包含该 defer 语句的函数返回时才执行。这种延迟执行机制在许多场景下都非常有用，它允许我们在函数结束时执行一些清理操作，而无需手动将这些操作放置在函数的末尾。

来看一个简单的代码示例：

package main

import "fmt"

func main() {
    fmt.Println("开始执行")
    defer fmt.Println("延迟执行")
    fmt.Println("继续执行")
}

在上述代码中，defer fmt.Println("延迟执行") 这行代码将 fmt.Println("延迟执行") 函数的执行延迟到 main 函数返回时。程序的输出结果为：

开始执行
继续执行
延迟执行

可以看到，defer 语句后的代码继续正常执行，而 defer 所延迟的函数在 main 函数即将结束时才被调用。

defer 语句的执行时机

  1. 函数正常返回时执行：当函数执行到 return 语句，准备返回时，会先执行所有已经注册的 defer 函数。例如：
package main

import "fmt"

func returnValue() int {
    defer fmt.Println("延迟执行")
    return 10
}

func main() {
    result := returnValue()
    fmt.Println("返回值:", result)
}

在 returnValue 函数中，defer fmt.Println("延迟执行") 会在 return 10 准备返回时执行。程序输出：

延迟执行
返回值: 10
  1. 函数发生恐慌（panic）时执行：即使函数发生恐慌（panic），defer 函数依然会被执行。这在处理错误或清理资源时非常重要。例如：
package main

import "fmt"

func panicFunction() {
    defer fmt.Println("延迟执行，即使发生 panic")
    panic("发生恐慌")
}

func main() {
    defer fmt.Println("主函数中的 defer")
    panicFunction()
}

在这个例子中，panicFunction 函数发生恐慌，但其中的 defer 语句依然会执行。同时，main 函数中的 defer 语句也会在恐慌向上传播到 main 函数结束时执行。输出结果为：

延迟执行，即使发生 panic
主函数中的 defer
panic: 发生恐慌

goroutine 1 [running]:
main.panicFunction()
        /tmp/sandbox509302633/main.go:6 +0x5c
main.main()
        /tmp/sandbox509302633/main.go:11 +0x3a
  1. 多层 defer 的执行顺序：如果一个函数中有多个 defer 语句，它们会按照后进先出（LIFO，Last In First Out）的顺序执行。例如：
package main

import "fmt"

func multipleDefer() {
    defer fmt.Println("第三个 defer")
    defer fmt.Println("第二个 defer")
    defer fmt.Println("第一个 defer")
}

func main() {
    multipleDefer()
}

输出结果为：

第一个 defer
第二个 defer
第三个 defer

这是因为 defer 语句就像是将函数调用压入一个栈中，当函数返回时，从栈顶开始依次弹出并执行这些函数。

defer 的功能与用途

资源清理

  1. 文件操作：在 Go 语言中，对文件进行读写操作后，需要及时关闭文件以释放资源。使用 defer 可以确保无论文件操作过程中是否发生错误，文件都会被正确关闭。例如：
package main

import (
    "fmt"
    "os"
)

func readFile() {
    file, err := os.Open("test.txt")
    if err != nil {
        fmt.Println("打开文件错误:", err)
        return
    }
    defer file.Close()

    // 这里进行文件读取操作
    var content []byte
    content, err = os.ReadFile("test.txt")
    if err != nil {
        fmt.Println("读取文件错误:", err)
        return
    }
    fmt.Println("文件内容:", string(content))
}

func main() {
    readFile()
}

在上述代码中，defer file.Close() 确保了在 readFile 函数结束时，文件 file 会被关闭，无论在文件读取过程中是否发生错误。

  1. 数据库连接：类似地，在与数据库进行交互时，连接资源也需要及时释放。使用 defer 可以简化这一过程。假设我们使用 database/sql 包连接 MySQL 数据库：
package main

import (
    "database/sql"
    "fmt"

    _ "github.com/go - sql - driver/mysql"
)

func queryDatabase() {
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/test")
    if err != nil {
        fmt.Println("连接数据库错误:", err)
        return
    }
    defer db.Close()

    // 执行数据库查询操作
    rows, err := db.Query("SELECT * FROM users")
    if err != nil {
        fmt.Println("查询数据库错误:", err)
        return
    }
    defer rows.Close()

    for rows.Next() {
        var id int
        var name string
        err := rows.Scan(&id, &name)
        if err != nil {
            fmt.Println("扫描结果错误:", err)
            return
        }
        fmt.Printf("ID: %d, Name: %s\n", id, name)
    }
    err = rows.Err()
    if err != nil {
        fmt.Println("遍历结果集错误:", err)
    }
}

func main() {
    queryDatabase()
}

在这个例子中，defer db.Close() 确保数据库连接在函数结束时关闭，defer rows.Close() 确保结果集在使用完毕后关闭，避免资源泄漏。

异常处理与恢复

  1. 捕获 panic 并恢复：在 Go 语言中，defer 与 recover 结合使用，可以捕获函数中的恐慌（panic）并进行恢复，使程序不至于崩溃。例如：
package main

import "fmt"

func recoverPanic() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("捕获到恐慌:", r)
        }
    }()
    panic("故意触发恐慌")
}

func main() {
    recoverPanic()
    fmt.Println("程序继续执行")
}

在 recoverPanic 函数中，defer 语句注册了一个匿名函数，该匿名函数使用 recover 来捕获可能发生的恐慌。当 panic("故意触发恐慌") 执行时，程序并不会崩溃，而是被 recover 捕获，输出：

捕获到恐慌: 故意触发恐慌
程序继续执行
  1. 在复杂函数中处理错误：在一些复杂的业务逻辑函数中，可能会有多个步骤，任何一个步骤都可能发生错误导致恐慌。使用 defer 和 recover 可以统一处理这些情况。例如：
package main

import "fmt"

func complexBusiness() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("业务处理过程中捕获到恐慌:", r)
        }
    }()

    step1()
    step2()
    step3()
}

func step1() {
    fmt.Println("执行步骤1")
    // 假设这里可能发生恐慌
    panic("步骤1发生错误")
}

func step2() {
    fmt.Println("执行步骤2")
}

func step3() {
    fmt.Println("执行步骤3")
}

func main() {
    complexBusiness()
    fmt.Println("业务处理结束，程序继续执行")
}

在这个例子中，complexBusiness 函数调用了三个步骤函数，其中 step1 故意触发恐慌。由于 complexBusiness 函数中使用了 defer 和 recover，恐慌被捕获，程序不会崩溃，继续输出：

执行步骤1
业务处理过程中捕获到恐慌: 步骤1发生错误
业务处理结束，程序继续执行

性能统计与日志记录

  1. 性能统计：在开发过程中，我们经常需要统计函数的执行时间，以优化性能。defer 可以方便地实现这一功能。例如：
package main

import (
    "fmt"
    "time"
)

func measureTime() {
    start := time.Now()
    defer func() {
        elapsed := time.Since(start)
        fmt.Println("函数执行时间:", elapsed)
    }()

    // 模拟一些耗时操作
    time.Sleep(2 * time.Second)
}

func main() {
    measureTime()
}

在 measureTime 函数中，start := time.Now() 记录函数开始执行的时间，defer 语句中的匿名函数在函数结束时计算并输出函数的执行时间。输出结果为：

函数执行时间: 2.0000005s
  1. 日志记录：在函数执行过程中，记录一些关键信息或错误信息是很有必要的。defer 可以确保在函数结束时，无论是否发生错误，都能记录相关日志。例如：
package main

import (
    "fmt"
    "log"
)

func logFunction() {
    defer func() {
        if r := recover(); r != nil {
            log.Println("函数发生恐慌:", r)
        } else {
            log.Println("函数正常结束")
        }
    }()

    // 模拟业务逻辑
    fmt.Println("执行函数逻辑")
    // 假设这里可能发生恐慌
    panic("发生恐慌")
}

func main() {
    logFunction()
}

在这个例子中，defer 语句中的匿名函数根据是否捕获到恐慌来记录不同的日志信息。输出的日志信息类似：

2024/01/01 12:00:00 函数发生恐慌: 发生恐慌

defer 的原理与实现

从底层原理来看，Go 语言在编译阶段会对 defer 语句进行特殊处理。当编译器遇到 defer 语句时，会将 defer 后的函数调用包装成一个 deferproc 函数调用。deferproc 函数会将延迟执行的函数信息（如函数指针、参数等）保存到一个链表结构中。

当函数返回时，Go 运行时系统会调用 deferreturn 函数，该函数会从链表中依次取出延迟执行的函数，并按照后进先出的顺序执行它们。

在实现细节上，defer 函数的参数在 defer 语句出现时就会被求值并保存。这意味着如果 defer 函数的参数是一个变量，即使在 defer 语句之后该变量的值发生了变化，defer 函数执行时使用的依然是 defer 语句出现时该变量的值。例如：

package main

import "fmt"

func deferParameter() {
    num := 10
    defer fmt.Println("延迟执行，num的值:", num)
    num = 20
}

func main() {
    deferParameter()
}

输出结果为：

延迟执行，num的值: 10

这表明在 defer fmt.Println("延迟执行，num的值:", num) 语句出现时，num 的值 10 就已经被确定并保存，后续 num 值的改变不会影响 defer 函数的执行。

注意事项与常见问题

  1. 避免不必要的性能开销：虽然 defer 非常方便，但过多地使用 defer 可能会带来一定的性能开销。因为每次执行 defer 语句都需要进行一些额外的操作，如创建延迟函数记录、将其添加到链表中等。所以在性能敏感的代码区域，应谨慎使用 defer，确保其带来的便利性大于性能损耗。
  2. 注意参数求值时机：如前文所述，defer 函数的参数在 defer 语句出现时就会被求值。这可能会导致一些意想不到的结果，尤其是当参数是一个复杂表达式或函数调用时。例如：
package main

import "fmt"

func getValue() int {
    fmt.Println("getValue 被调用")
    return 10
}

func deferWithFunctionCall() {
    defer fmt.Println("延迟执行，值:", getValue())
    fmt.Println("函数继续执行")
}

func main() {
    deferWithFunctionCall()
}

输出结果为：

getValue 被调用
函数继续执行
延迟执行，值: 10

可以看到，getValue 函数在 defer 语句出现时就被调用并求值，而不是在 defer 函数实际执行时。

  1. 嵌套函数中的 defer：在嵌套函数中使用 defer 时，需要注意其作用范围。defer 语句只会影响包含它的最内层函数的返回。例如：
package main

import "fmt"

func outerFunction() {
    fmt.Println("外层函数开始")
    func() {
        defer fmt.Println("内层函数的 defer")
        fmt.Println("内层函数开始")
        return
    }()
    fmt.Println("外层函数结束")
}

func main() {
    outerFunction()
}

输出结果为：

外层函数开始
内层函数开始
内层函数的 defer
外层函数结束

内层函数中的 defer 语句只会在其自身返回时执行，不会影响外层函数。

  1. defer 与闭包：当 defer 与闭包结合使用时，需要特别小心变量的作用域和生命周期。闭包会捕获其周围环境中的变量，而 defer 函数在延迟执行时可能会访问到已经超出其原始作用域的变量。例如：
package main

import "fmt"

func deferWithClosure() {
    var numbers []int
    for i := 0; i < 3; i++ {
        defer func() {
            fmt.Println("延迟执行，i的值:", i)
        }()
        numbers = append(numbers, i)
    }
    fmt.Println("数组:", numbers)
}

func main() {
    deferWithClosure()
}

输出结果为：

数组: [0 1 2]
延迟执行，i的值: 3
延迟执行，i的值: 3
延迟执行，i的值: 3

这里闭包捕获了 i 变量，由于 defer 函数延迟执行，当它们执行时，for 循环已经结束，i 的值变为 3。如果想要每个 defer 函数捕获不同的 i 值，可以通过将 i 作为参数传递给闭包来实现：

package main

import "fmt"

func deferWithClosureFixed() {
    var numbers []int
    for i := 0; i < 3; i++ {
        defer func(n int) {
            fmt.Println("延迟执行，n的值:", n)
        }(i)
        numbers = append(numbers, i)
    }
    fmt.Println("数组:", numbers)
}

func main() {
    deferWithClosureFixed()
}

此时输出结果为：

数组: [0 1 2]
延迟执行，n的值: 2
延迟执行，n的值: 1
延迟执行，n的值: 0

通过将 i 作为参数传递给闭包，每个闭包捕获到的是不同的 i 值。

总结与最佳实践

  1. 总结：defer 是 Go 语言中一个强大而灵活的特性，它主要用于延迟函数的执行，在函数返回时执行一些清理操作、处理异常、进行性能统计和日志记录等。defer 语句的执行时机包括函数正常返回、发生恐慌以及多层 defer 的后进先出执行顺序。同时，我们需要了解其底层原理，注意参数求值时机、性能开销以及在嵌套函数和闭包中的使用等问题。
  2. 最佳实践：
    • 资源清理优先使用 defer：在涉及文件操作、数据库连接等资源管理的代码中，应优先使用 defer 来确保资源的正确释放，避免资源泄漏。
    • 谨慎使用 defer 进行异常处理：虽然 defer 和 recover 可以捕获恐慌，但应尽量在业务逻辑中避免恐慌的发生，通过合理的错误处理机制来解决问题。只有在确实需要捕获并恢复恐慌的情况下，才使用 defer 和 recover。
    • 注意性能影响：在性能敏感的代码区域，仔细评估 defer 的使用，确保其带来的便利性大于性能损耗。可以考虑其他替代方案，如手动管理资源释放等。
    • 遵循清晰的代码结构：使用 defer 时，要保持代码结构清晰，避免过度嵌套和复杂的逻辑。对于复杂的业务逻辑，可以将相关的 defer 操作封装到独立的函数中，提高代码的可读性和可维护性。

通过正确理解和使用 defer 特性，我们可以编写出更加健壮、高效和可读的 Go 语言程序。在实际开发中，不断积累经验，根据具体的业务场景选择最合适的方式来运用 defer，以充分发挥其优势，提升程序的质量和可靠性。