GO闭包实现原理(汇编级讲解)

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

1.起因

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

  1. value通过值传递,mutable修饰可以让value可以修改,但是地址不可能一样
  2. value通过引用传递,但是在其他地方调用时,这个value局部变量早就释放,会访问到脏数据
cpp 复制代码
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 函数的,它对应的汇编是如下

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

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

附着闭包实体而一直存在。因此,闭包使用的优缺点是很明显的:闭包能够避免使用全局变量,转而维持自由变量长期存储在内存之中;但是,这种隐式地持有自由变量,在使用不当时,会很容易造成内存浪费与泄露。

相关推荐
傻啦嘿哟16 分钟前
如何使用 Python 开发一个简单的文本数据转换为 Excel 工具
开发语言·python·excel
大数据编程之光20 分钟前
Flink Standalone集群模式安装部署全攻略
java·大数据·开发语言·面试·flink
初九之潜龙勿用20 分钟前
C#校验画布签名图片是否为空白
开发语言·ui·c#·.net
Dola_Pan37 分钟前
C语言:数组转换指针的时机
c语言·开发语言·算法
ExiFengs38 分钟前
实际项目Java1.8流处理, Optional常见用法
java·开发语言·spring
paj12345678939 分钟前
JDK1.8新增特性
java·开发语言
IT古董1 小时前
【人工智能】Python在机器学习与人工智能中的应用
开发语言·人工智能·python·机器学习
繁依Fanyi1 小时前
简易安卓句分器实现
java·服务器·开发语言·算法·eclipse
湫ccc1 小时前
《Python基础》之pip换国内镜像源
开发语言·python·pip
fhvyxyci1 小时前
【C++之STL】摸清 string 的模拟实现(下)
开发语言·c++·string