忏悔录 Day93
知识点
bare return
如果一个函数将所有的返回值都显示的变量名，那么该函数的return语句可以省略操作数。这称之为bare return 如：
func main(url string) (words, images int, err error) {
resp, err := http.Get(url)
if err != nil {
return
}
doc, err := html.Parse(resp.Body)
resp.Body.Close()
if err != nil {
err = fmt.Errorf("parsing HTML: %s", err)
return
}
words, images = countWordsAndImages(doc)
return
}
闭包和逃逸
匿名函数可以访问完整的词法环境(lexical environment)，这意味着在函数中定义的内部函数可以引用该函数的变量
逃逸是个啥？举个栗子
package mainimport "fmt"func Fibonacci() func int { a, b := 0, 1 return func() int { a, b = b, a+b }}func main() { f := Fibonacci() for i := 0; i < 10; i++ { fmt.printfln("FibonacciL %d\n", f()) }}此时，原本在 Fibonacci()中声明的变量，在main函数中因为闭包带回了ab的访问地址，此时就叫他们发生了 逃逸，确切说是 闭包引用逃逸
为什么要分析逃逸？
对于一个对象来说，
如果分配到栈上，待函数返回资源就被回收了
如果分配到堆上，函数返回后交给gc来管理该对象资源
而那些发生逃逸的对象，从原本的栈空间跑到了堆空间，这样就增加了gc的负担
常见的逃逸还有哪些？
指针逃逸 函数返回局部变量的指针。
栈空间不足逃逸 当对象大小超过的栈帧大小时，变量对象发生逃逸被分配到堆上。
动态类型逃逸 当对象不确定大小或者被作为不确定大小的参数时发生逃逸。
切片或map赋值逃逸 因为切片和map是引用传递(
其实是复制了指向原空间的指针，并不是真的直接传递了指针)，如果对象指针被存入切片或者map返回的话，类似于指针逃逸，外部就可以访问到原本的变量了
捕获迭代变量
来个例子：如果没有necessary这一行，会怎样？
var rmdirs []func()
for _, d := range tempDirs() {
dir := d // NOTE: necessary!
os.MkdirAll(dir, 0755) // creates parent directories too
rmdirs = append(rmdirs, func() {
os.RemoveAll(dir)
})
}
// ...do some work…
for _, rmdir := range rmdirs {
rmdir() // clean up
}
这里是错误代码：
var rmdirs []func()
for _, dir := range tempDirs() {
os.MkdirAll(dir, 0755)
rmdirs = append(rmdirs, func() {
os.RemoveAll(dir) // NOTE: incorrect!
})
}
问题的原因在于循环变量的作用域。在上面的程序中，for循环语句引入了新的词法块，循环变量dir在这个词法块中被声明。在该循环中生成的所有函数值都共享相同的循环变量。需要注意，函数值中记录的是循环变量的内存地址，而不是循环变量某一时刻的值。以dir为例，后续的迭代会不断更新dir的值，当删除操作执行时，for循环已完成，dir中存储的值等于最后一次迭代的值。这意味着，每次对os.RemoveAll的调用删除的都是相同的目录。
函数调用
调用惯例
我们来对比下C和go的调用惯例：
C语言 当参数两个时
main: pushq %rbp movq %rsp, %rbp subq $16, %rsp movl $2, %esi // 设置第二个参数 movl $1, %edi // 设置第一个参数 call my_function movl %eax, -4(%rbp)my_function: pushq %rbp movq %rsp, %rbp movl %edi, -4(%rbp) // 取出第一个参数，放到栈上 movl %esi, -8(%rbp) // 取出第二个参数，放到栈上 movl -8(%rbp), %eax // eax = esi = 1 movl -4(%rbp), %edx // edx = edi = 2 addl %edx, %eax // eax = eax + edx = 1 + 2 = 3 popq %rbp当参数八个时
main: pushq %rbp movq %rsp, %rbp subq $16, %rsp // 为参数传递申请 16 字节的栈空间 movl $8, 8(%rsp) // 传递第 8 个参数 movl $7, (%rsp) // 传递第 7 个参数 movl $6, %r9d movl $5, %r8d movl $4, %ecx movl $3, %edx movl $2, %esi movl $1, %edi call my_function我们可以将本节的发现和分析简单总结成 —— 当我们在 x86_64 的机器上使用 C 语言中调用函数时，参数都是通过寄存器和栈传递的，其中：1、六个以及六个以下的参数会按照顺序分别使用 edi、esi、edx、ecx、r8d 和 r9d 六个寄存器传递；2、六个以上的参数会使用栈传递，函数的参数会以从右到左的顺序依次存入栈中；而函数的返回值是通过 eax 寄存器进行传递的，由于只使用一个寄存器存储返回值，所以 C 语言的函数不能同时返回多个值。
Go 语言
"".main STEXT size=68 args=0x0 locals=0x28 0x0000 00000 (main.go:7) MOVQ (TLS), CX 0x0009 00009 (main.go:7) CMPQ SP, 16(CX) 0x000d 00013 (main.go:7) JLS 61 0x000f 00015 (main.go:7) SUBQ $40, SP // 分配 40 字节栈空间 0x0013 00019 (main.go:7) MOVQ BP, 32(SP) // 将基址指针存储到栈上 0x0018 00024 (main.go:7) LEAQ 32(SP), BP 0x001d 00029 (main.go:8) MOVQ $66, (SP) // 第一个参数 0x0025 00037 (main.go:8) MOVQ $77, 8(SP) // 第二个参数 0x002e 00046 (main.go:8) CALL "".myFunction(SB) 0x0033 00051 (main.go:9) MOVQ 32(SP), BP 0x0038 00056 (main.go:9) ADDQ $40, SP 0x003c 00060 (main.go:9) RET可以看到，go中的参数直接就是保存在栈上的
思考
C 语言和 Go 语言在设计函数的调用惯例时选择也不同的实现。C 语言同时使用寄存器和栈传递参数，使用 eax 寄存器传递返回值；而 Go 语言使用栈传递参数和返回值。我们可以对比一下这两种设计的优点和缺点：
C 语言的方式能够极大地减少函数调用的额外开销，但是也增加了实现的复杂度；
CPU 访问栈的开销比访问寄存器高几十倍
需要单独处理函数参数过多的情况；
Go 语言的方式能够降低实现的复杂度并支持多返回值，但是牺牲了函数调用的性能；
不需要考虑超过寄存器数量的参数应该如何传递；
不需要考虑不同架构上的寄存器差异；
函数入参和出参的内存空间需要在栈上进行分配；
Go 语言使用栈作为参数和返回值传递的方法是综合考虑后的设计，选择这种设计意味着编译器会更加简单、更容易维护。
参数传递
传值：函数调用时会对参数进行拷贝，被调用方和调用方两者持有不相关的两份数据；传引用：函数调用时会传递参数的指针，被调用方和调用方两者持有相同的数据，任意一方做出的修改都会影响另一方。
我们重点看一下传引用是不是真的“传引用”
type MyStruct struct { i int j int}func myFunction(ms *MyStruct) { ptr := unsafe.Pointer(ms) for i := 0; i < 2; i++ { c := (*int)(unsafe.Pointer((uintptr(ptr) + uintptr(8*i)))) *c += i + 1 fmt.Printf("[%p] %d\n", c, *c) }}func main() { a := &MyStruct{i: 40, j: 50} myFunction(a) fmt.Printf("[%p] %v\n", a, a)}$ go run main.go[0xc000018180] 41[0xc000018188] 52[0xc000018180] &{41 52}$ go tool compile -S -N -l main.go"".myFunction STEXT nosplit size=20 args=0x10 locals=0x0 0x0000 00000 (main.go:8) MOVQ $0, "".~r1+16(SP) // 初始化返回值 0x0009 00009 (main.go:9) MOVQ "".ms+8(SP), AX // 复制引用 0x000e 00014 (main.go:9) MOVQ AX, "".~r1+16(SP) // 返回引用 0x0013 00019 (main.go:9) RET可以看到，虽然底层值确实是改变了，但是指针地址也是改变了的，再结合下面的汇编代码，可以得到一个结论：将指针作为参数传入某一个函数时，在函数内部会对指针进行复制，也就是会同时出现两个指针指向原有的内存空间，所以 Go 语言中 传指针也是传值。
引用
go语言圣经 - 函数
GO语言变量逃逸分析
函数调用
关于忏悔录
忏悔录是我用来忏悔自己的一事无成，激励自己努力向前，督促自己以后要做好，的一系列文章吧，每天有所学，总结下来，可以是一章书本内容，一份感悟，不限内容。
希望自己坚持住，尽量每天一更。
欢迎大家关注我的公众号
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
