go中函数是头等对象，可以作为参数传递，可以作为返回值，也可以绑定到变量。go中称这样的参数，返回值或者变量为function value。
函数指令在编译期间生成，而function value本质是上一个指针，但是并不直接指向函数的指令入口。而是指向一个runtime.funcval结构体，这个结构体里只有一个地址，就是这个函数指令的入口地址
函数A被赋值给f1和f2两个变量，这种情况，编译器会做出优化，让f1和f2共用一个funcval结构体
如果函数A的指令在这，入口地址addr1，编译阶段，会在只读数据段分配一个funcval结构体，fn指向函数A指令入口，而它本身的起始地址，会在执行阶段赋给f1和f2。通过f1来执行函数，就会通过它存储的地址找到对应的funcval结构体，拿到函数入口地址，然后调转执行。
既然只要有函数入口地址就能调用 ，为什么要通过funcval结构体包装这个地址，然后使用一个二级指针来调用呢？这里主要是为了处理闭包的情况
闭包定义
闭包的两个定义：
- 第一：必须要有在函数外部定义，但在函数内部引用的“自由变量”
- 第二：脱离了形成闭包的上下文，闭包也能照常使用这些自由变量
函数create的返回值是一个函数，但这个函数内部使用了外部定义的变量c，即使create执行结束，通过f1和f2依然能正常调用这个闭包函数。并使用定义在create函数内部的局部变量c，所以这里符合闭包的定义。通常称这个变量c为捕获变量。
闭包函数的指令自然也是在编译阶段生成，但因为每个闭包对象都要保存自己的捕获变量。所以要到执行阶段才创建对应的闭包对象。
到执行阶段，main函数栈帧有两个局部变量，然后是返回值空间。到create函数栈帧这里，有一个局部变量c=2。
create函数会在堆上分配一个funcval结构体，fn指向闭包函数入口，除此之外，还有一个捕获列表，这里只捕获一个变量c，然后这个结构体的起始地址就作为返回值写入返回值空间，所以f1被赋值为addr2，下面再次调用create函数，它就会再次创建一个funcval结构体，同样捕获变量c，然后这个起始地址addr3作为返回值写入，最终f2
被赋值为addr3。
通过f1和f2调用闭包函数，就会找到各自对应的funcval结构体，拿到同一个函数入口，但是通过f1调用时要使用addr2上面的捕获列表，f2调用时要使用addr3上面的捕获列表，这就是称闭包为有状态的函数的原因
那究竟函数如何找到对应的捕获列表呢，go语言中通过一个function value调用函数时，会把对应的funcval结构体地址存入特定寄存器，例如amd64平台使用的是DX寄存器。这样在闭包函数中，就可以通过寄存器取出funcval结构体的地址，然后加上相应的偏移来找到每一个被捕获的变量。所以go语言中闭包就是有捕获列表的function value，而没有捕获列表的function value直接忽略这个寄存器的值就好了
捕获列表
被闭包捕获的变量，要在外层函数与闭包函数中表现一致，好像它们在使用同一个变量，为此，go语言的编译器针对不同情况做了不同的处理
被捕获的变量没有被修改的情况
最简单的情况就像上面那个例子，被捕获的变量除了初始化赋值外，在任何地方都没有被修改过，所以直接拷贝值到捕获列表就ok了
被捕获的变量被修改的情况
如果除了初始化赋值外还被修改过，那就要再做细分了，在这个例子中，被捕获的是局部变量i，而且除了初始化赋值(i:=0)外还被修改(i++)过
闭包函数指令入口addrf，main函数栈帧中，局部变量fs是一个长度为2的function value类型数组，返回值为零值，到create函数栈帧，由于被闭包捕获并修改，局部变量i改为堆分配。在栈上只存一个地址。
第一次for循环。在堆上创建funcval结构体，捕获i的地址，这样闭包函数就和外层函数操作同一个变量了，返回值第一个元素存储addr0，第一次for循环结束，i自增1
第二次for循环开始，再次堆分配一个funcval，捕获变量i的地址，第二个元素存储addr1，第二次循环结束，i再次自增1，create函数结束，把返回值拷贝到局部变量fs
通过fs[0]调用函数时，把addr0存入寄存器。闭包函数通过寄存器存储的地址加上偏移找到捕获变量i的地址。fs[1]同理，被捕获的地址都指向它，所以每次都会打印2。
闭包导致的局部变量堆分配，也是变量逃逸的一种场景。
有修改并被捕获的是参数
如果有修改并被捕获的是参数，涉及到函数原型，就不能像局部变量那样处理了。
参数依然通过调用者栈帧传入，但是编译器会把栈上这个参数拷贝到堆上一份。然后外层函数和闭包函数都使用堆上分配的这一个
被捕获的是返回值
如果被捕获的是返回值，处理方式又有些不同
调用者栈帧上依然会分配返回值的空间，不过闭包的外层函数会在堆上也分配一个，外层函数和闭包函数都使用堆上这个，但是在外层函数返回前，需要把堆上的返回值拷贝到栈上的返回值空间
处理方式虽然多样，但是目标只有一个，就是保存捕获变量在外层函数和闭包函数中的一致性
测试代码package main
import "fmt"
func main() {
Test1()// 5 5 5 5 5 除了初始化赋值外还被闭包修改--->捕获变量i的地址
//为什么Test1这里明明没有修改，但是不是值拷贝呢？
//因为代码里取地址了，当然就不能捕获值，肯定要捕获地址
//因为编译器认为闭包内用到的要和外层一致
Test2()// 4 4 4 4 4 除了初始化赋值外还被外层函数修改--->捕获变量t的地址
Test3()// 0 1 2 3 4 只被初始化赋值--->值拷贝t
}
func Test1() {
fmt.Println("test1 start--------------")
fs := Closure1()
for _, f := range fs {
f()
}
fmt.Println("test1 end--------------")
}
func Closure1() (fs [5]func()) {
for i := 0; i < 5; i++ {
fmt.Println("i address=",&i)
fs[i] = func() {
fmt.Println(i, &i)
}
}
return
}
func Test2() {
fmt.Println("test2 start--------------")
fs := Closure2()
for _, f := range fs {
f()
}
fmt.Println("test2 end--------------")
}
func Closure2() (fs [5]func()) {
t := 0
for i := 0; i < 5; i++ {
t = i
fmt.Println("t address=",&t)
fs[i] = func() {
fmt.Println(t, &t)
}
}
return
}
func Test3() {
fmt.Println("test3 start--------------")
fs := Closure3()
for _, f := range fs {
f()
}
fmt.Println("test3 end--------------")
}
func Closure3() (fs [5]func()) {
for i := 0; i < 5; i++ {
t := i
fmt.Println("t address=",&t)
fs[i] = func() {
fmt.Println(t)
}
}
return
}
test1 start--------------
i address= 0xc00000a098
i address= 0xc00000a098
i address= 0xc00000a098
i address= 0xc00000a098
i address= 0xc00000a098
5 0xc00000a098
5 0xc00000a098
5 0xc00000a098
5 0xc00000a098
5 0xc00000a098
test1 end--------------
test2 start--------------
t address= 0xc00000a0c0
t address= 0xc00000a0c0
t address= 0xc00000a0c0
t address= 0xc00000a0c0
t address= 0xc00000a0c0
4 0xc00000a0c0
4 0xc00000a0c0
4 0xc00000a0c0
4 0xc00000a0c0
4 0xc00000a0c0
test2 end--------------
test3 start--------------
t address= 0xc00000a0c8
t address= 0xc00000a0d0
t address= 0xc00000a0d8
t address= 0xc00000a0e0
t address= 0xc00000a0e8
0
1
2
3
4
test3 end--------------
进程 已完成，退出代码为 0