GC是否将整个对象保留在内存中，即使只有指向其字段的内部指针仍然存在？这可能导致内存泄漏吗？

偷偷努力，悄无声息地变强，然后惊艳所有人！哈哈，小伙伴们又来学习啦~今天我将给大家介绍《GC是否将整个对象保留在内存中，即使只有指向其字段的内部指针仍然存在？这可能导致内存泄漏吗？》，这篇文章主要会讲到等等知识点，不知道大家对其都有多少了解，下面我们就一起来看一吧！当然，非常希望大家能多多评论，给出合理的建议，我们一起学习，一起进步！

go 的 gc 是否将整个对象保留在内存中，而指向字段的内部指针仍然保留？

在这样的代码中，这会导致内存泄漏吗？或者 go 的 gc 是否“足够聪明”，能够注意到不再需要对象的其余部分并将其从内存中清除？

package main

import (
    "fmt"
)

const aLot = 500000000

func getInteriorPointer() *int {
    type bigStruct struct {
        someBigThing [aLot]int
        smallThing   int
    }
    b := bigStruct{smallThing: 3}
    return &b.smallThing
}

func main() {
    p := getInteriorPointer()
    // keep using p in the rest of the app, 
    // never using someBigThing from the struct
    fmt.Println(*p)
}

解决方案

是的。内存将被保留，直到不再有任何对分配的任何部分的引用为止。

切片技巧中给出了常见的示例

SliceTricks

删除而不保留​​顺序

a[i] = a[len(a)-1] 
a = a[:len(a)-1]

注意如果元素的类型是指针或带指针的结构体 需要垃圾回收的字段，以上实现 cut和delete存在潜在的内存泄漏问题：某些元素 值仍然被切片 a 引用，因此不能 已收集。

查看profiler，似乎确实是内存泄漏（go1.11.5 darwin/amd64）

让我们看看分析器。

我找到了 an online example for debugging memory。通过适应我的示例，我这样做了：

package main

import (
    "fmt"
    "os"
    "runtime"
    "runtime/debug"
    "runtime/pprof"
)

const alot = 5000000

func getinteriorpointer() *int {
    type bigstruct struct {
        somebigthing [alot]int
        smallthing   int
    }
    b := bigstruct{smallthing: 3}
    return &b.smallthing
}

func main() {
    p := getinteriorpointer()
    runtime.gc()
    debug.freeosmemory()
    fmem, _ := os.create("prof.prof")
    pprof.writeheapprofile(fmem)

    // keep using p in the rest of the app,
    // never using somebigthing from the struct
    fmt.println(*p)
}

现在我运行 go 工具 pprof prof.prof 和 list main

ROUTINE ======================== main.getInteriorPointer in /Users/karel/exp/exp.go
   38.15MB    38.15MB (flat, cum)   100% of Total
         .          .     13:func getInteriorPointer() *int {
         .          .     14:   type bigStruct struct {
         .          .     15:           someBigThing [aLot]int
         .          .     16:           smallThing   int
         .          .     17:   }
   38.15MB    38.15MB     18:   b := bigStruct{smallThing: 3}
         .          .     19:   return &b.smallThing
         .          .     20:}
         .          .     21:
         .          .     22:func main() {
         .          .     23:   p := getInteriorPointer()
ROUTINE ======================== main.main in /Users/karel/exp/exp.go
         0    38.15MB (flat, cum)   100% of Total
         .          .     18:   b := bigStruct{smallThing: 3}
         .          .     19:   return &b.smallThing
         .          .     20:}
         .          .     21:
         .          .     22:func main() {
         .    38.15MB     23:   p := getInteriorPointer()
         .          .     24:   runtime.GC()
         .          .     25:   debug.FreeOSMemory()
         .          .     26:   fmem, _ := os.Create("prof.prof")
         .          .     27:   pprof.WriteHeapProfile(fmem)
         .          .     28:

看来垃圾收集器确实没有从内存中删除不必要的对象。 如果我正确理解了格式。 （我可能不会，因为几乎没有文档。）

到这里，我们也就讲完了《GC是否将整个对象保留在内存中，即使只有指向其字段的内部指针仍然存在？这可能导致内存泄漏吗？》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！