go语言闭包实现原理(汇编层解析)

1.起因

今天开始学习go语言,在学到go闭包时候,原本以为go闭包的实现方式就是类似于如下cpp lambda

1. value通过值传递,mutable修饰可以让value可以修改,但是地址不可能一样
2. value通过引用传递,但是在其他地方调用时,这个value局部变量早就释放,会访问到脏数据

std::function<void()> func(){int value = 666;return [value]()mutable{value++;std::cout << &value;}
}

但是经过测试,我居然惊奇的发现在go的fun函数和闭包中value变量的地址一模一样,但是在c++的理解中这是不可能的(c++中栈随着函数退出而销毁,value也成为脏数据,一旦访问很可能会读到意料之外的数据)

2.探索

于是,我查看了go编译后的汇编代码,首先先看看闭包经典代码,再看删除第六行不在闭包内修改变量value的变化的汇编代码

1.闭包经典代码

首先，我们发现不一样的是 var value int = 100 会调用 runtime.newobject 函数（内置new函数的底层函数，它返回数据类型指针）。在正常函数局部变量的定义时，例如下:

2.删除第六行代码,不在闭包中修改value

我们能发现 var value int = 100 是不会调用 runtime.newobject 函数的，它对应的汇编是如下

对比两段代码的汇编,我们可以看见一个数据结构:闭包对象数据结构

type noalg struct{F unitptr	//函数对象X0 *int		//第一段代码的汇编,在闭包内修改对象//X0 int	//第二段代码的汇编,不在闭包内修改对象
}

之后，在通过 runtime.newobject 函数创建了闭包对象。而且由于 LEAQ xxx yyy代表的是将 xxx 指针，传递给 yyy，因此 outer 函数最终的返回，其实是闭包结构体对象指针。很明显，闭包对象会被分配至堆上，变量x也会随着对象逃逸至堆。这就很好地解释了为什么x变量没有随着函数栈的销毁而消亡。

验证

通过go build指令的逃逸分析,可以看见,第一段代码的变量value和函数对象都分配到了堆上面

这其实就是Go编译器做得精妙的地方：当闭包内没有对外部变量造成修改时，Go 编译器会将自由变量的引用传递优化为直接值传递，避免变量逃逸。

PS D:\goProject\src\learn> go build -gcflags '-m -m -l' main.go
# command-line-arguments
./main.go:4:6: fun capturing by ref: value (addr=false assign=true width=8)
./main.go:7:13: value escapes to heap:
./main.go:7:13:   flow: {storage for ... argument} = &{storage for value}:
./main.go:7:13:     from value (spill) at ./main.go:7:13
./main.go:7:13:     from ... argument (slice-literal-element) at ./main.go:7:12
./main.go:7:13:   flow: {heap} = {storage for ... argument}:
./main.go:7:13:     from ... argument (spill) at ./main.go:7:12
./main.go:7:13:     from fmt.Print(... argument...) (call parameter) at ./main.go:7:12
./main.go:5:9: func literal escapes to heap:
./main.go:5:9:   flow: ~r0 = &{storage for func literal}:
./main.go:5:9:     from func literal (spill) at ./main.go:5:9
./main.go:5:9:     from return func literal (return) at ./main.go:5:2
./main.go:4:6: value escapes to heap:
./main.go:4:6:   flow: {storage for func literal} = &value:
./main.go:4:6:     from value (captured by a closure) at ./main.go:6:3
./main.go:4:6:     from value (reference) at ./main.go:6:3
./main.go:4:6: moved to heap: value				//变量value逃逸
./main.go:5:9: func literal escapes to heap		//函数逃逸
./main.go:7:12: ... argument does not escape
./main.go:7:13: value escapes to heap

总结

函数闭包一点也不神秘，它就是函数和引用环境而组合的实体。在Go中，闭包在底层是一个结构体对象，它包含了函数指针与自由变量。

Go编译器的逃逸分析机制，会将闭包对象分配至堆中，这样自由变量就不会随着函数栈的销毁而消失，它能依附着闭包实体而一直存在。因此，闭包使用的优缺点是很明显的：闭包能够避免使用全局变量，转而维持自由变量长期存储在内存之中；但是，这种隐式地持有自由变量，在使用不当时，会很容易造成内存浪费与泄露。
附着闭包实体而一直存在。因此，闭包使用的优缺点是很明显的：闭包能够避免使用全局变量，转而维持自由变量长期存储在内存之中；但是，这种隐式地持有自由变量，在使用不当时，会很容易造成内存浪费与泄露。