go语言闭包实现原理(汇编层解析)
1.起因
今天开始学习go语言,在学到go闭包时候,原本以为go闭包的实现方式就是类似于如下cpp lambda
- value通过值传递,mutable修饰可以让value可以修改,但是地址不可能一样
- 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编译器的逃逸分析机制，会将闭包对象分配至堆中，这样自由变量就不会随着函数栈的销毁而消失，它能依附着闭包实体而一直存在。因此，闭包使用的优缺点是很明显的：闭包能够避免使用全局变量，转而维持自由变量长期存储在内存之中；但是，这种隐式地持有自由变量，在使用不当时，会很容易造成内存浪费与泄露。
附着闭包实体而一直存在。因此，闭包使用的优缺点是很明显的：闭包能够避免使用全局变量，转而维持自由变量长期存储在内存之中；但是，这种隐式地持有自由变量，在使用不当时，会很容易造成内存浪费与泄露。
