首页>内容详情

图解Go闭包的底层原理

大熊•2024-09-04 09:05:35•Golang

一、闭包是什么？

在Go语言中，闭包（Closure）是一个非常强大且常用的概念。

简而言之，闭包是一个函数，它能够捕获并引用其外部作用域中的变量。与普通函数不同，闭包不仅能访问自己内部的变量，还能“记住”它在创建时所处的外部环境，从而能够在函数外部使用这些变量。

闭包在Go中的用途非常广泛。例如，在实现回调函数、事件处理程序、以及延迟计算时，闭包都能发挥巨大的作用。此外，闭包还经常用于创建工厂函数，生成带有特定上下文的函数。

还可以这么理解：函数 + 函数定义时所使用的环境变量。例如：一个函数的返回值是函数类型，返回的函数使用了函数中的局部变量。这样就形成了闭包。

二、闭包的常见用途和特性

闭包的核心特性在于其能够捕获并持有外部变量的引用。这意味着，即使外部函数已经返回，闭包仍然可以访问这些变量。以下是一个简单的示例：

package main

import "fmt"

func adder() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}
func main() {
     valueFunc:= adder()
     fmt.Println(valueFunc(2))     // output: 2
     fmt.Println(valueFunc(2))   // output: 4
}

运行流程中的内存布局变化如图所示：

注：根据序号一步步跟着我画的图来体会内存布局操作变化过程。
闭包运行过程

过程如下：

函数调用栈 (Stack)
- 在程序执行时，main 函数被调用，其栈帧（stack frame）会被压入调用栈中。
- main 函数调用了 adder 函数，adder 函数的栈帧同样会被压入调用栈。
- 在 adder 函数中，定义了局部变量 sum，初始值为 0。虽然 sum 是在 adder 的栈帧中声明的，但由于闭包的存在，它被捕获并存储在堆（heap）中。
堆 (Heap)
- 堆中存储了变量 sum，当 adder 函数返回匿名函数时，sum 变量被绑定在这个返回的函数对象中，匿名函数对象和捕获的 sum 在堆中分配内存。
- 由于 sum 是被闭包捕获的变量，它的值在 adder 函数返回后不会被销毁，而是被保留以供后续的函数调用。
闭包捕获
- 当 main 函数调用 valueFunc(2) 时，匿名函数被调用，sum 的值被更新并存储在堆中。每次调用 valueFunc 时，sum 的值会根据传入的参数累加并更新其在堆中的值。
输出结果
- 第一次调用 valueFunc(2) 时，sum 变为 2。
- 第二次调用 valueFunc(2) 时，sum 变为 4。这说明闭包捕获的变量 sum 在多次调用中保留了其状态。

graph LR
main函数 -->|调用| adder函数
adder函数 -->|返回匿名函数赋值到| valueFunc变量
valueFunc变量 --> 调用valueFunc-2
调用valueFunc-2 --> 匿名函数的执行-sum变量变化

三、Go闭包的底层实现原理

1. 捕获和引用外部变量

Go语言中的闭包通过捕获外部变量的引用来实现这一功能。当闭包捕获一个外部变量时，该变量不会随函数的结束而销毁，而是继续存在于堆内存中，直到闭包本身不再被引用。

2. 闭包的内存布局

为了更好地理解闭包的内存布局，以下是一个示意图，展示了闭包在堆栈和堆内存中的存储方式。

闭包的内存布局

在这个图中，函数栈帧持有一个指向闭包的引用，而闭包则通过一个指针指向其捕获的外部变量。该变量被存储在堆内存中，而不是传统的栈内存，这保证了变量在闭包的整个生命周期内保持有效。

3. 闭包的创建与执行过程

闭包的创建和执行过程可以分为以下几个步骤：

创建闭包：当函数内部声明一个匿名函数并引用外部变量时，Go会创建一个闭包。这个闭包持有对外部变量的引用。
捕获外部变量：Go编译器会检测到匿名函数中引用的外部变量，并将这些变量的地址保存到闭包中。需要注意的是，如果外部变量是引用类型，如指针、切片或映射，闭包捕获的是引用本身，而不是实际的值。
执行闭包：当闭包被调用时，它会根据捕获的外部变量的当前值来执行逻辑。因为这些变量存储在堆内存中，所以它们在闭包生命周期内都是有效的。

4. 并发环境中的闭包

在并发编程中，闭包可能会引发竞态条件，这是因为多个闭包可能会同时访问或修改相同的外部变量。以下是一个典型的例子：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            fmt.Println(i)
        }()
    }
    wg.Wait()
}

在上面的代码中，闭包捕获了变量i的引用，而不是i的值。由于i在并发环境中被多个协程访问，可能会导致输出的结果与预期不符。

输出：

闭包的创建与执行过程
解决方案：可以通过将i作为闭包的参数传递给匿名函数，从而避免竞态条件：

for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(n int) {
        defer wg.Done()
        fmt.Println(n)
    }(i)
}

在这个改进的版本中，i的值被传递给匿名函数的参数n，从而确保每个闭包拥有独立的变量副本，避免了竞态条件。

避免竞态条件

四、闭包的优缺点

优点：

灵活性：闭包能够实现高度灵活的函数构造，允许在运行时动态创建带有特定上下文的函数。
数据封装：闭包通过捕获外部变量，可以实现类似于对象的数据封装，保护变量不被外部直接访问。

缺点：

内存占用：闭包捕获的变量被存储在堆内存中，这可能导致内存的过度使用，尤其是在频繁创建闭包的场景下。
竞态条件：在并发环境中，如果不小心处理，闭包可能引发竞态条件，导致程序的非确定性行为。

五、如何在实际开发中有效使用闭包

谨慎捕获变量：在编写闭包时，要明确哪些变量需要捕获，避免不必要的捕获导致内存泄漏或竞态条件。
小心并发问题：在并发场景中使用闭包时，务必考虑到变量捕获可能引发的竞态条件，并采取适当的同步措施。
适度使用：虽然闭包非常强大，但过度使用闭包可能导致代码难以理解和维护。因此，应在需要时合理使用闭包，而不是滥用。

通过本文的介绍，希望读者能够深入理解Go语言中闭包的底层原理，并在实际开发中更好地利用这一强大的功能。

上一篇：GO实时通信用WebSocket还是SSE?

下一篇：深度解密Go语言之值传递