Go 中结构的堆栈与堆分配，以及它们与垃圾收集的关系

一分耕耘，一分收获！既然打开了这篇文章《Go 中结构的堆栈与堆分配，以及它们与垃圾收集的关系》，就坚持看下去吧！文中内容包含golang等等知识点...希望你能在阅读本文后，能真真实实学到知识或者帮你解决心中的疑惑，也欢迎大佬或者新人朋友们多留言评论，多给建议！谢谢！

问题内容

我是 Go 新手，我在 C 风格的基于堆栈的编程（其中自动变量位于堆栈上，分配的内存位于堆上）与 Python 风格的基于堆栈的编程之间存在一些认知失调，其中唯一的存在于堆栈上的东西是指向堆上对象的引用/指针。

据我所知，以下两个函数给出相同的输出：

func myFunction() (*MyStructType, error) {
    var chunk *MyStructType = new(HeaderChunk)

    ...

    return chunk, nil
}


func myFunction() (*MyStructType, error) {
    var chunk MyStructType

    ...

    return &chunk, nil
}

即，分配一个新结构并返回它。

如果我用 C 语言编写，第一个会将对象放在堆上，第二个会将它放在堆栈上。第一个将返回一个指向堆的指针，第二个将返回一个指向堆栈的指针，在函数返回时它会消失，这将是一件坏事。

如果我用 Python（或除 C# 之外的许多其他现代语言）编写它，示例 2 将是不可能的。

我知道 Go 垃圾会收集这两个值，所以上述两种形式都很好。

报价：

请注意，与 C 不同，返回局部变量的地址是完全可以的；与变量关联的存储在函数返回后仍然存在。事实上，每次计算复合文字的地址时都会分配一个新的实例，因此我们可以将最后两行组合起来。

http://golang.org/doc/effective_go.html#functions

但它提出了几个问题。

1. 在示例 1 中，结构是在堆上声明的。例子2呢？是在堆栈上以与在 C 中相同的方式声明还是在堆上进行声明？

2. 如果示例 2 在堆栈上声明，那么它在函数返回后如何保持可用？

3. 如果示例 2 实际上是在堆上声明的，那么结构是如何通过值而不是通过引用传递的？在这种情况下，指针的意义何在？

正确答案

值得注意的是，“stack”和“heap”这两个词并没有出现在语言规范中的任何地方。您的问题的措辞是“......在堆栈上声明”和“......在堆上声明”，但请注意，Go 声明语法没有说明堆栈或堆。

从技术上讲，这使得您所有问题的答案都依赖于实施。当然，实际上，有一个堆栈（每个 goroutine！）和一个堆，有些东西在堆栈上，有些在堆上。在某些情况下，编译器遵循严格的规则（例如“new始终在堆上分配”），而在其他情况下，编译器会进行“转义分析”来确定对象是否可以存在于堆栈上，或者是否必须在堆上分配。

在您的示例 2 中，转义分析将显示指向结构转义的指针，因此编译器必须分配结构。但是，我认为 Go 的当前实现在这种情况下遵循严格的规则，即如果地址取自结构的任何部分，则结构会进入堆。

对于问题 3，我们可能会对术语感到困惑。Go 中的所有内容都是按值传递的，没有按引用传递。在这里，您将返回一个指针值。指针的意义何在？考虑对您的示例进行以下修改：

type MyStructType struct{}

func myFunction1() (*MyStructType, error) {
    var chunk *MyStructType = new(MyStructType)
    // ...
    return chunk, nil
}

func myFunction2() (MyStructType, error) {
    var chunk MyStructType
    // ...
    return chunk, nil
}

type bigStruct struct {
    lots [1e6]float64
}

func myFunction3() (bigStruct, error) {
    var chunk bigStruct
    // ...
    return chunk, nil
}

我修改了 myFunction2 以返回结构而不是结构的地址。现在比较 myFunction1 和 myFunction2 的汇编输出，

--- prog list "myFunction1" ---
0000 (s.go:5) TEXT    myFunction1+0(SB),$16-24
0001 (s.go:6) MOVQ    $type."".MyStructType+0(SB),(SP)
0002 (s.go:6) CALL    ,runtime.new+0(SB)
0003 (s.go:6) MOVQ    8(SP),AX
0004 (s.go:8) MOVQ    AX,.noname+0(FP)
0005 (s.go:8) MOVQ    $0,.noname+8(FP)
0006 (s.go:8) MOVQ    $0,.noname+16(FP)
0007 (s.go:8) RET     ,

--- prog list "myFunction2" ---
0008 (s.go:11) TEXT    myFunction2+0(SB),$0-16
0009 (s.go:12) LEAQ    chunk+0(SP),DI
0010 (s.go:12) MOVQ    $0,AX
0011 (s.go:14) LEAQ    .noname+0(FP),BX
0012 (s.go:14) LEAQ    chunk+0(SP),BX
0013 (s.go:14) MOVQ    $0,.noname+0(FP)
0014 (s.go:14) MOVQ    $0,.noname+8(FP)
0015 (s.go:14) RET     ,

不要担心这里的 myFunction1 输出与 peterSO 的（优秀）答案不同。我们显然在运行不同的编译器。否则，请参阅我修改了 myFunction2 以返回 myStructType 而不是 *myStructType。对 runtime.new 的调用消失了，在某些情况下这将是一件好事。不过等一下，这里是 myFunction3，

--- prog list "myFunction3" ---
0016 (s.go:21) TEXT    myFunction3+0(SB),$8000000-8000016
0017 (s.go:22) LEAQ    chunk+-8000000(SP),DI
0018 (s.go:22) MOVQ    $0,AX
0019 (s.go:22) MOVQ    $1000000,CX
0020 (s.go:22) REP     ,
0021 (s.go:22) STOSQ   ,
0022 (s.go:24) LEAQ    chunk+-8000000(SP),SI
0023 (s.go:24) LEAQ    .noname+0(FP),DI
0024 (s.go:24) MOVQ    $1000000,CX
0025 (s.go:24) REP     ,
0026 (s.go:24) MOVSQ   ,
0027 (s.go:24) MOVQ    $0,.noname+8000000(FP)
0028 (s.go:24) MOVQ    $0,.noname+8000008(FP)
0029 (s.go:24) RET     ,

仍然没有调用 runtime.new，是的，它确实可以按值返回一个 8MB 的对象。它有效，但您通常不想这样做。此处指针的目的是避免推送大约 8MB 的对象。

理论要掌握，实操不能落！以上关于《Go 中结构的堆栈与堆分配，以及它们与垃圾收集的关系》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！