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

1.起因

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

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

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

好文推荐

评论可见，请评论后查看内容，谢谢！！！
 您阅读本篇文章共花了：