Go 为什么指向局部变量的指针会逃逸到堆中？

这是我的围棋环境：

[lorneli@localhost GoTest]$ go version
go version go1.9 linux/amd64

这是我的节目：

package main

type request struct {
    ID string
    size uint32
    off uint64
}

func main() {
    r := request{}
    iter := interface{}(&r) // &r escapes to heap
    iters := make([]interface{}, 0)
    iters = append(iters, iter)
}

我分配一个

请求

实例，并将其指针转换为

接口{}

。 但是当使用flag

-gcflags“-m”

进行分析时，我发现实例逃逸了 在转换时进行堆。为什么会发生这种情况

以下是分析结果：

[lorneli@localhost GoTest]$ go build -gcflags "-m"
# _/mnt/hgfs/vmfolder/workspace/GoTest
./main.go:9:6: can inline main
./main.go:11:21: (interface {})(&r) escapes to heap
./main.go:11:22: &r escapes to heap
./main.go:10:15: moved to heap: r
./main.go:12:15: main make([]interface {}, 0) does not escape

---

我认为此案例与上列出的任何案例都不匹配。

简化您的示例。使用

-gcflags='-m-m'

进行分析

示例1：

package main

func main() {
    var v int
    s := make([]*int, 0)
    s = append(s, &v) // &v escapes to heap
}

package main

func main() {
    var v int
    lc := 1
    s := make([]*int, lc)
    s[0] = &v
}

$ go run -gcflags='-m -m' esc2.go
./esc2.go:3:6: can inline main as: func() { var v int; v = <N>; lc := 1; s := make([]*int, lc); s[0] = &v }
./esc2.go:6:11: make([]*int, lc) escapes to heap
./esc2.go:6:11:     from make([]*int, lc) (too large for stack) at ./esc2.go:6:11
./esc2.go:7:9: &v escapes to heap
./esc2.go:7:9:  from s[0] (slice-element-equals) at ./esc2.go:7:7
./esc2.go:4:6: moved to heap: v
$ 

输出：

$ go version
go version devel +df8c2b905b Tue Mar 6 06:13:17 2018 +0000 linux/amd64
$ go run -gcflags='-m -m' esc.go
# command-line-arguments
./esc.go:3:6: can inline main as: func() { var v int; v = <N>; s := make([]*int, 0); s = append(s, &v) }
./esc.go:6:16: &v escapes to heap
./esc.go:6:16:  from append(s, &v) (appended to slice) at ./esc.go:6:12
./esc.go:4:6: moved to heap: v
./esc.go:5:11: main make([]*int, 0) does not escape
$ 

---

切片的

make

返回切片描述符

struct

（指向底层数组、长度和容量的指针），并分配底层切片元素数组。底层数组通常在堆上分配：

make（[]*int，lc）从make（[]*int，lc）转义到堆。

s[0]=&v

存储对堆上基础数组中变量

v

（

&v

）的引用：

&v从s[0]转义到堆（切片元素等于）

，

移动到堆：v

。在函数结束并回收其堆栈后，引用将保留在堆上，直到底层数组被垃圾回收

---

如果

make

片容量是一个小的（编译时）常数，那么在您的示例中，

make（[]*int，1）

可能会在堆栈上分配底层数组。但是，转义分析没有考虑到这一点。

我的看法是，您提到的文档中的“流经字段”案例涵盖了这种情况：类型为

interface{}

的值是两个指针字段的结构。尽管如此，请注意，该文件非常陈旧（2015年），因此我会在邮件列表上提出这个问题，以征求对这些问题的更新。这是在golang-nuts上提出的实施细节。感谢您的建议。我稍后会在邮件列表中询问。@perter谢谢。我将代码更改为：

s:=make（[]*int，1）s[1]=&v

。变量仍然会逃逸。这是因为分析认为切片中的指针可能会退出函数。我找到了一个博客。在倒数第二段，“请记住，片和映射实际上只是Go结构，带有指向堆分配内存的指针”。我想这可以解释为什么变量仍然逃逸。谢谢你的耐心！

type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}