Go是一门带有垃圾回收的现代语言，实现内存的主动申请和释放的管理
一.堆和栈
- 应用程序的内存载体，我们可以简单地将其分为堆和栈。
- 在Go中，栈的内存是由编译器自动进行分配和释放，栈区往往存储着函数参数、局部变量和调用函数帧，它们随着函数的创建而分配，函数的退出而销毁，一个goroutine对应一个栈
- 与栈不同的是，应用程序在运行时只会存在一个堆。狭隘地说，内存管理只是针对堆内存而言的。程序在运行期间可以主动从堆上申请内存，这些内存通过Go的内存分配器分配，并由垃圾收集器回收。
- 栈是每个goroutine独有的，这就意味着栈上的内存操作是不需要加锁的。而堆上的内存，有时需要加锁防止多线程冲突（为什么要说有时呢，因为Go的内存分配策略学习了TCMalloc的线程缓存思想，他为每个处理器P分配了一个mcache，从mcache分配内存也是无锁的）。
- 对于程序堆上的内存回收，还需要通过标记清除阶段，例如Go采用的三色标记法+隔离屏障。
- 在栈上的内存而言，它的分配与释放非常廉价。简单地说，它只需要两个CPU指令：一个是分配入栈，另外一个是栈内释放。而这，只需要借助于栈相关寄存器即可完成。
二.逃逸分析
如果可以，Go编译器会尽可能将变量分配到到栈上
如果变量在函数外部没有引用，则优先放到栈中
如果变量在函数外部存在引用，则必定放在堆中
//我们可通过gcflags来查看逃逸分析结果，-m 打印逃逸分析信息，-l禁止内联优化。
go build -gcflags '-m -l'
情况一：变量类型不确定
package main
import "fmt"
func main() {
a := 123
fmt.Println(a)
}
//执行：go build -gcflags '-m -m -l'。为了看到更多细节，可以在语句中再添加一个-m参数
//1 $ go build -gcflags '-m -m -l' main.go
//2# command-line-arguments
//3./main.go:7:13: a escapes to heap:
//4./main.go:7:13: flow: {storage for ... argument} = &{storage for a}:
//5./main.go:7:13: from a (spill) at ./main.go:7:13
//6./main.go:7:13: from ... argument (slice-literal-element) at ./main.go:7:13
//7./main.go:7:13: flow: {heap} = {storage for ... argument}:
//8./main.go:7:13: from ... argument (spill) at ./main.go:7:13
//9./main.go:7:13: from fmt.Println(... argument...) (call parameter) at ./main.go:7:13
//10./main.go:7:13: ... argument does not escape
//11./main.go:7:13: a escapes to heap
因为fmt.Println的函数参数为interface类型，编译期不能确定其参数的具体类型，所以将其分配于堆上。
func Println(a ...interface{}) (n int, err error)
情况二：暴露给外部指针
package main
func foo() *int {
a := 666
return &a
}
func main() {
_ = foo()
}
//逃逸分析如下，变量a发生了逃逸。
//1 $ go build -gcflags '-m -m -l' main.go
//2# command-line-arguments
//3./main.go:4:2: a escapes to heap:
//4./main.go:4:2: flow: ~r0 = &a:
//5./main.go:4:2: from &a (address-of) at ./main.go:5:9
//6./main.go:4:2: from return &a (return) at ./main.go:5:2
//7./main.go:4:2: moved to heap: a
这种情况直接满足我们上述中的原则：变量在函数外部存在引用
情况三：变量所占内存较大
func foo() {
s := make([]int, 10000, 10000)
for i := 0; i < len(s); i++ {
s[i] = i
}
}
func main() {
foo()
}
//逃逸分析结果
//1$ go build -gcflags '-m -m -l' main.go
//2# command-line-arguments
//3./main.go:4:11: make([]int, 10000, 10000) escapes to heap:
//4./main.go:4:11: flow: {heap} = &{storage for make([]int, 10000, 10000)}:
//5./main.go:4:11: from make([]int, 10000, 10000) (too large for stack) at ./main.go:4:11
//6./main.go:4:11: make([]int, 10000, 10000) escapes to heap
当我们创建了一个容量为10000的int类型的底层数组对象时，由于对象过大，它也会被分配到堆上。
那么，多大的对象会被分配到堆上呢？
看看GMP模型
当程序里发生了32kb以下的小块内存申请时，Go会从一个叫做的mcache的本地缓存给程序分配内存。 这个本地缓存mcache持有一系列的大小为32kb的内存块
这样的一个内存块里叫做mspan，它是要给程序分配内存时的分配单元。
情况四：变量大小不确定
package main
func foo() {
n := 1
s := make([]int, n)
for i := 0; i < len(s); i++ {
s[i] = i
}
}
func main() {
foo()
}
//得到逃逸分析结果如下
//1$ go build -gcflags '-m -m -l' main.go
//2# command-line-arguments
//3./main.go:5:11: make([]int, n) escapes to heap:
//4./main.go:5:11: flow: {heap} = &{storage for make([]int, n)}:
//5./main.go:5:11: from make([]int, n) (non-constant size) at ./main.go:5:11
//6./main.go:5:11: make([]int, n) escapes to heap
make方法中，没有直接指定大小，而是填入了变量n，这时Go逃逸分析也会将其分配到堆区去。
