脚本之家,脚本语言编程技术及教程分享平台!
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Golang - Go 中闭包的底层原理

Go 中闭包的底层原理

2021-11-25 12:13写代码的明哥 Golang

这篇文章主要介绍了Go 中闭包的底层原理,闭包的基本原理是一种现象,一个函数内引用了外部的局部变量的现象,带着些许的了解和小编一起进入文章正题学习

1. 什么是闭包?

一个函数内引用了外部的局部变量,这种现象,就称之为闭包。

例如下面的这段代码中,adder 函数返回了一个匿名函数,而该匿名函数中引用了 adder 函数中的局部变量 sum ,那这个函数就是一个闭包。

?
1
2
3
4
5
6
7
8
9
10
11
package main
 
import "fmt"
 
func adder() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}

而这个闭包中引用的外部局部变量并不会随着 adder 函数的返回而被从栈上销毁。

我们尝试着调用这个函数,发现每一次调用,sum 的值都会保留在 闭包函数中以待使用。

?
1
2
3
4
5
func main() {
     valueFunc:= adder()
     fmt.Println(valueFunc(2))     // output: 2
     fmt.Println(valueFunc(2))   // output: 4
}

2. 复杂的闭包场景

写一个闭包是比较容易的事,但单单会写简单的闭包函数,还远远不够,如果不搞清楚闭包真正的原理,那很容易在一些复杂的闭包场景中对函数的执行逻辑进行误判。

别的不说,就拿下来这个例子来说吧?

你觉得它会打印什么呢?

是 6 还是 11 呢?

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import "fmt"
 
func func1() (i int) {
    i = 10
    defer func() {
        i += 1
    }()
    return 5
}
 
func main() {
    closure := func1()
    fmt.Println(closure)
}

3. 闭包的底层原理?

还是以最上面的例子来分析

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
}

我们先对它进行逃逸分析,很容易发现 sum 作为 adder 函数局部变量,并不是分配在栈上,而是分配在堆上的。

这就解决了第一个疑惑:为什么 adder 函数返回后, sum 不会随之销毁?

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
$ go build -gcflags="-m -m -l" demo.go
# command-line-arguments
./demo.go:8:3: adder.func1 capturing by ref: sum (addr=true assign=true width=8)
./demo.go:7:9: func literal escapes to heap:
./demo.go:7:9:   flow: ~r0 = &{storage for func literal}:
./demo.go:7:9:     from func literal (spill) at ./demo.go:7:9
./demo.go:7:9:     from return func literal (return) at ./demo.go:7:2
./demo.go:6:2: sum escapes to heap:
./demo.go:6:2:   flow: {storage for func literal} = &sum:
./demo.go:6:2:     from func literal (captured by a closure) at ./demo.go:7:9
./demo.go:6:2:     from sum (reference) at ./demo.go:8:3
./demo.go:6:2: moved to heap: sum
./demo.go:7:9: func literal escapes to heap
./demo.go:15:23: valueFunc(2) escapes to heap:
./demo.go:15:23:   flow: {storage for ... argument} = &{storage for valueFunc(2)}:
./demo.go:15:23:     from valueFunc(2) (spill) at ./demo.go:15:23
./demo.go:15:23:   flow: {heap} = {storage for ... argument}:
./demo.go:15:23:     from ... argument (spill) at ./demo.go:15:13
./demo.go:15:23:     from fmt.Println(valueFunc(2)) (call parameter) at ./demo.go:15:13
./demo.go:15:13: ... argument does not escape
./demo.go:15:23: valueFunc(2) escapes to heap

可另一个问题,又浮现出来了,就算它不会销毁,那闭包函数若是存储的若是 sum 拷贝后的值,那每次调用闭包函数,里面的 sum 应该都是一样的,调用两次都应该返回 2,而不是可以累加记录。

因此,可以大胆猜测,闭包函数的结构体里存储的是 sum 的指针。

为了验证这一猜想,只能上汇编了。

通过执行下面的命令,可以输出对应的汇编代码

?
1
go build -gcflags="-S" demo.go 

输出的内容相当之多,我提取出下面最关键的一行代码,它定义了闭包函数的结构体。

其中 F 是函数的指针,但这不是重点,重点是 sum 存储的确实是指针,验证了我们的猜。

?
1
type.noalg.struct { F uintptr; "".sum *int }(SB), CX

4. 迷题揭晓

有了上面第三节的背景知识,那对于第二节给出的这道题,想必你也有答案了。

首先,由于 i 在函数定义的返回值上声明,因此根据 go 的 caller-save 模式, i 变量会存储在 main 函数的栈空间。

然后,func1 return 重新把 5 赋值给了 i ,此时 i = 5

由于闭包函数存储了这个变量 i 的指针。

因此最后,在 defer 中对 i 进行自增,是直接更新到 i 的指针上,此时 i = 5+1,所以最终打印出来的结果是 6

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import "fmt"
 
func func1() (i int) {
    i = 10
    defer func() {
        i += 1
    }()
    return 5
}
 
func main() {
    closure := func1()
    fmt.Println(closure)
}

5. 再度变题

上面那题听懂了的话,再来看看下面这道题。

func1 的返回值我们不写变量名 i 了,然后原先返回具体字面量,现在改成变量 i ,就是这两小小小的改动,会导致运行结果大大不同,你可以思考一下结果。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import "fmt"
 
func func1() (int) {
    i := 10
    defer func() {
        i += 1
    }()
    return i
}
 
func main() {
    closure := func1()
    fmt.Println(closure)
}

如果你在返回值里写了变量名,那么该变量会存储 main 的栈空间里,而如果你不写,那 i 只能存储在 func1 的栈空间里,与此同时,return 的值,不会作用于原变量 i 上,而是会存储在该函数在另一块栈内存里。

因此你在 defer 中对原 i 进行自增,并不会作用到 func1 的返回值上。

所以打印的结果,只能是 10。

你答对了吗?

6. 最后一个问题

不知道你有没有发现,在第一节示例中的 sum 是存储在堆内存中的,而后面几个示例都是存储在栈内存里。

这是为什么呢?

仔细对比,不难发现,示例一返回的是闭包函数,闭包函数在 adder 返回后还要在其他地方继续使用,在这种情况下,为了保证闭包函数的正常运行,无论闭包函数在哪里,i 都不能回收,所以 Go 编译器会智能地将其分配在堆上。

而后面的其他示例,都只是涉及了闭包的特性,并不是直接把闭包函数返回,因此完全可以将其分配在栈上,非常的合理。

到此这篇关于Go 中闭包的底层原理的文章就介绍到这了,更多相关Go 闭包底层原理内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家!

原文链接:https://network.51cto.com/art/202110/687279.htm

延伸 · 阅读

精彩推荐
  • Golanggo语言制作端口扫描器

    go语言制作端口扫描器

    本文给大家分享的是使用go语言编写的TCP端口扫描器,可以选择IP范围,扫描的端口,以及多线程,有需要的小伙伴可以参考下。 ...

    脚本之家3642020-04-25
  • Golanggo日志系统logrus显示文件和行号的操作

    go日志系统logrus显示文件和行号的操作

    这篇文章主要介绍了go日志系统logrus显示文件和行号的操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧...

    SmallQinYan12302021-02-02
  • Golanggolang json.Marshal 特殊html字符被转义的解决方法

    golang json.Marshal 特殊html字符被转义的解决方法

    今天小编就为大家分享一篇golang json.Marshal 特殊html字符被转义的解决方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧 ...

    李浩的life12792020-05-27
  • Golanggolang 通过ssh代理连接mysql的操作

    golang 通过ssh代理连接mysql的操作

    这篇文章主要介绍了golang 通过ssh代理连接mysql的操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧...

    a165861639710342021-03-08
  • GolangGolang通脉之数据类型详情

    Golang通脉之数据类型详情

    这篇文章主要介绍了Golang通脉之数据类型,在编程语言中标识符就是定义的具有某种意义的词,比如变量名、常量名、函数名等等,Go语言中标识符允许由...

    4272021-11-24
  • GolangGolang中Bit数组的实现方式

    Golang中Bit数组的实现方式

    这篇文章主要介绍了Golang中Bit数组的实现方式,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧...

    天易独尊11682021-06-09
  • Golanggolang如何使用struct的tag属性的详细介绍

    golang如何使用struct的tag属性的详细介绍

    这篇文章主要介绍了golang如何使用struct的tag属性的详细介绍,从例子说起,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看...

    Go语言中文网11352020-05-21
  • Golanggolang的httpserver优雅重启方法详解

    golang的httpserver优雅重启方法详解

    这篇文章主要给大家介绍了关于golang的httpserver优雅重启的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,...

    helight2992020-05-14