第一章 逃逸分析

学习笔记 › Go程序员面试笔试宝典
, ,

逃逸分析是什么

在编译原理中，分析指针动态范围的方法被称之为逃逸分析。通俗来讲，当一个对象的指针被多个方法或线程引用时，则称这个指针发生了逃逸。逃逸分析决定一个变量是分配在堆上还是分配在栈上。

例子：

1
2
3
4
5
6
7
// C++
int* foo {
    int = 3;
    return &t;
}
// 这里返回了函数内部的局部变量的指针，因为是栈分配的，函数执行完毕这些变量就会被销毁，
// 任何对这个返回值的操作都将扰乱程序的运行。

改进版：

1
2
3
4
5
6
7
// C++
int* foo {
    int* t = new int;
    &t = 3;
    return t;
}
// 在函数内部使用new运算符构造一个变量，然后返回此变量的地址。因为变量是在堆上创建的，所以在函数退出时不会被销毁

但这样不能解决问题，调用者可能会忘记删除或者直接将返回值给其他函数，之后就再也不能删除它了，也就发生了所谓的内存泄漏。

但同样的代码，在go没有问题：

1
2
3
4
5
6
// go
func foo() *int {
    t := new(int)
    *t = 3
    return t
}

逃逸分析有什么作用

逃逸分析把变量合理地分配到它该去的地方。即时是new函数申请到的内存，如果编译器发现这块内存在退出函数后就没有使用了，那就分配到栈上。反之则分配到堆上。真正做到“按需分配”。

堆和栈相比，堆适合不可预知大小的内存分配。但是代价是分配速度较慢，而且会形成内存碎片；栈内存分配则会非常快。只需要通过PUSH指令，并且会被自动释放。堆分配内存则首先需要去找到一个大小合适的内存块，之后要通过垃圾回收才能释放。

go的逃逸分析是通过编译器完成的。通过逃逸分析，可以尽量把那些不需要分配到堆上的变量直接分配到栈上，堆上的变量少了，会减轻堆内存分配的开销，同时也会减少垃圾回收（GC）的压力，提高程序的运行速度。

逃逸分析是怎么完成的

Go编译器会分析代码的特征和代码的生命周期，Go中的变量只有在编译器可以证明在函数返回后不会再引用的，才分配到栈上，其他情况都是分配到堆上。简单来说，编译器会根据变量是否被外部引用来决定是否逃逸：

1、如果变量在函数外部没有引用，则优先放到栈上。

2、如果变量在函数外部存在引用，则必定放到堆上。

针对第一条可能放到堆上的情形：定义了一个很大的数组，需要申请的内存过大，超过了栈的存储能力。

如何确定是否发生逃逸

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import "fmt"

func foo() *int {
    t := 3
    return &t
}

func main() {
    x := foo()
    fmt.Println(*x)
}

执行命令：go build -gcflags '-m -l' main.go

-gcflags参数用于弃用编译器支持的额外标识。例如-m用于输出编译器的优化细节（包括使用逃逸分析这种优化），反之可以使用-N来关闭编译器优化。而-l则用于禁用foot函数的内联优化，防止逃逸被编译器通过内联彻底的抹除。

得到如下输出：

1
2
3
4
# command-line-arguments
.\main.go:6:2: moved to heap: t
.\main.go:12:13: ... argument does not escape
.\main.go:12:14: *x escapes to heap

foo函数里的变量t逃逸了，而main函数里的x也逃逸了，是因为有些函数的参数为interface类型，比如fmt.Println(a …interface{})，编译期间很难确定参数的具体类型，也会发生逃逸。

使用反汇编命令也可以看出变量是否发生逃逸。执行命令：

 go tool compile -S main.go 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
"".foo STEXT size=61 args=0x0 locals=0x18 funcid=0x0
        0x0000 00000 (main.go:5)        TEXT    "".foo(SB), ABIInternal, $24-0
        0x0000 00000 (main.go:5)        CMPQ    SP, 16(R14)
        0x0004 00004 (main.go:5)        PCDATA  $0, $-2
        0x0004 00004 (main.go:5)        JLS     54
        0x0006 00006 (main.go:5)        PCDATA  $0, $-1
        0x0006 00006 (main.go:5)        SUBQ    $24, SP
        0x000a 00010 (main.go:5)        MOVQ    BP, 16(SP)
        0x000f 00015 (main.go:5)        LEAQ    16(SP), BP
        0x0014 00020 (main.go:5)        FUNCDATA        $0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
        0x0014 00020 (main.go:5)        FUNCDATA        $1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
        0x0014 00020 (main.go:6)        LEAQ    type.int(SB), AX
        0x001b 00027 (main.go:6)        PCDATA  $1, $0
        0x001b 00027 (main.go:6)        NOP
        0x0020 00032 (main.go:6)        CALL    runtime.newobject(SB)
        0x0025 00037 (main.go:6)        MOVQ    $3, (AX)
        0x002c 00044 (main.go:7)        MOVQ    16(SP), BP
        0x0031 00049 (main.go:7)        ADDQ    $24, SP
        0x0035 00053 (main.go:7)        RET
        0x0036 00054 (main.go:7)        NOP
        0x0036 00054 (main.go:5)        PCDATA  $1, $-1
        0x0036 00054 (main.go:5)        PCDATA  $0, $-2
        0x0036 00054 (main.go:5)        CALL    runtime.morestack_noctxt(SB)

15行，runtime.newobject(SB)用于在堆上分配一块内存，从而说明t被放到了堆上，也就是发生了逃逸。

Go与C/C++中的堆和栈是同一个概念吗

C/C++中提及的“程序堆栈”本质上其实是操作系统层级的概念，它通过C/C++语言的编译器和所在的系统环境来共同决定。在程序启动时，操作系统会自动维护一个所启动程序消耗内存的地址空间，并自动将这个空间从逻辑上划分为堆内存空间和栈内存空间。这时，“栈”的概念是指程序运行时自动获得的一小块内存，而后续的函数调用所消耗的栈大小，会在编译期间由编译器决定，用于保存局部变量或者保存函数调用栈。如果在C/C++中声明一个局部变量，则会执行逻辑上的压栈操作，在栈中记录局部变量。而当局部变量离开作用域之后，所谓的自动释放本质上是该位置的内存在下一次函数调用压栈的过程中，可以被无条件的覆盖；对于堆而言，每当程序通过系统调用向操作系统申请内存时，会将所需的空间从维护的堆内存地址空间中分配出去，而在归还时则会将归还的内容合并到所维护的地址空间中。

Go程序也是运行在操作系统上的程序，自然同样拥有前面提及的堆和栈的概念。但区别在于传统意义上的“栈”被Go语言的运行时全部消耗了，用于维护运行时各个组件之间的协调，例如调度器、垃圾回收、系统调用等。而对于用户态的Go代码而言，它们所消耗的“堆和栈”，其实只是Go运行时通过管理向操作系统申请的堆内存，构造的逻辑上的“堆和栈”，它们的本质都是从操作系统申请而来的堆内存。由于用户态Go程序的“栈空间”是由运行时管理堆内存得来，相较于只有1MB的C/C++中的“栈”而言，Go程序拥有“几乎”无限的栈内存（1GB）。更进一步，对于用户态Go代码消耗的栈，Go语言运行时会为了防止内存碎片化，会在适当的时候对整个栈进行深拷贝，将其整个复制到另一块内存区域（当然，这个过程对用户态的代码是不可见的），这也是相较于传统意义上栈是一块固定分配好的内存所出现的另一处差异。也正是由于这个特点的存在，指针的算术运算不再能奏效，因为在没有特殊说明的情况下，无法确定运算前后指针所指向的地址的内容是否已经被Go运行时移动。

——

这段看得我有点懵。。。