《GO语言圣经》学习笔记(六)函数

知识点

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 main

import "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 语言中传指针其实也是传值。

引用


欢迎大家关注我的公众号


半亩房顶

推荐阅读更多精彩内容