go语言内存泄漏的常见形式

go语言内存泄漏

子字符串导致的内存泄漏

使用自动垃圾回收的语言进行编程时，通常我们无需担心内存泄漏的问题，因为运行时会定期回收未使用的内存。但是如果你以为这样就完事大吉了，哪里就大错特措了。

因为，虽然go中并未对字符串时候共享底层内存块进行规定，但go语言编译器/运行时默认情况下允许字符串共享底层内存块，直到原先的字符串指向的内存被修改才会进行写时复制，这是一个很好的设计，既能节省内存，又能节省CPU资源，但有时也会导致"内存泄漏"。

例如如下代码，一旦调用demo就会导致将近1M内存的泄漏，因为s0只使用了50字节，但是会导致1M的内存一直无法被回收，这些内存会一直持续到下次s0被修改的时候才会被释放掉。

var s0 string // a package-level variable// A demo purpose function.
func f(s1 string) {s0 = s1[:50]// Now, s0 shares the same underlying memory block// with s1. Although s1 is not alive now, but s0// is still alive, so the memory block they share// couldn't be collected, though there are only 50// bytes used in the block and all other bytes in// the block become unavailable.
}func demo() {s := createStringWithLengthOnHeap(1 << 20) // 1M bytesf(s)
}

为了避免这种内存泄漏，我们可以使用[]byte来替代原先的1M大小的内存，不过这样会有两次50字节的内存重复

func f(s1 string) {s0 = string([]byte(s1[:50]))
}

当然我们也可以利用go编译器的优化来避免不必要的重复，只需要浪费一个字节内存就行

func f(s1 string) {s0 = (" " + s1[:50])[1:]
}

上述方法的缺点是编译器优化以后可能会失效，并且其他编译器可能无法提供该优化

避免此类内存泄漏的第三种方法是利用 Go 1.10 以来支持的 strings.Builder 。

import "strings"func f(s1 string) {var b strings.Builderb.Grow(50)b.WriteString(s1[:50])s0 = b.String()
}

从 Go 1.18 开始， strings 标准库包中新增了 Clone 函数，这成为了完成这项工作的最佳方式。

子切片导致的内存泄漏

同样场景下，切片也会导致内存的浪费

与子字符串类似，子切片也可能导致某种内存泄漏。在下面的代码中，调用 g 函数后，保存 s1 元素的内存块所占用的大部分内存将会丢失（如果没有其他值引用该内存块）。

var s0 []intfunc g(s1 []int) {// Assume the length of s1 is much larger than 30.s0 = s1[len(s1)-30:]
}

如果我们想避免这种内存泄漏，我们必须复制 s0 的 30 个元素，这样 s0 的活跃性就不会阻止收集承载 s1 元素的内存块。

func g(s1 []int) {s0 = make([]int, 30)copy(s0, s1[len(s1)-30:])// Now, the memory block hosting the elements// of s1 can be collected if no other values// are referencing the memory block.
}

未重置子切片指针导致的内存泄漏

在下面的代码中，调用 h 函数后，为切片 s 的第一个和最后一个元素分配的内存块将丢失。

func h() []*int {s := []*int{new(int), new(int), new(int), new(int)}// do something with s ...// 返回一个从1开始，不能到索引3的新切片， 也就是 s[1], s[2]return s[1:3:3]
}

只要返回的切片仍然有效，它就会阻止收集 s 的任何元素，从而阻止收集为 s 的第一个和最后一个元素引用的两个 int 值分配的两个内存块。

如果我们想避免这种内存泄漏，我们必须重置丢失元素中存储的指针。

func h() []*int {s := []*int{new(int), new(int), new(int), new(int)}// do something with s ...// Reset pointer values.s[0], s[len(s)-1] = nil, nilreturn s[1:3:3]
}

挂起Goroutine导致的内存泄漏

有时，Go 程序中的某些 goroutine 可能会永远处于阻塞状态。这样的 goroutine 被称为挂起的 goroutine。Go 运行时不会终止挂起的 goroutine，因此为挂起的 goroutine 分配的资源（以及它们引用的内存块）永远不会被垃圾回收。

Go 运行时不会杀死挂起的 Goroutine 有两个原因。一是 Go 运行时有时很难判断一个阻塞的 Goroutine 是否会被永久阻塞。二是我们有时会故意让 Goroutine 挂起。例如，有时我们可能会让 Go 程序的主 Goroutine 挂起，以避免程序退出。

如果不停止time.Ticker也会导致内存泄漏

当 time.Timer 值不再使用时，它会在一段时间后被垃圾回收。但 time.Ticker 值则不然。我们应该在 time.Ticker 值不再使用时停止它。

不正确地使用终结器会导致真正的内存泄漏

为属于循环引用组的成员值设置终结器（finalizer）可能会阻止为该循环引用组分配的所有内存块被回收。这是真正的内存泄漏，不是某种假象。

例如，在调用并退出以下函数后，分配给 x 和 y 的内存块不能保证在未来的垃圾收集中被收集。

func memoryLeaking() {type T struct {v [1<<20]intt *T}var finalizer = func(t *T) {fmt.Println("finalizer called")}var x, y T// The SetFinalizer call makes x escape to heap.runtime.SetFinalizer(&x, finalizer)// The following line forms a cyclic reference// group with two members, x and y.// This causes x and y are not collectable.x.t, y.t = &y, &x // y also escapes to heap.
}

因此，请避免为循环引用组中的值设置终结器。

延迟函数调用导致的某种资源泄漏

非常大的延迟调用堆栈也可能会消耗大量内存，并且如果某些调用延迟太多，某些资源可能无法及时释放。

例如，如果在调用以下函数时需要处理许多文件，那么在函数退出之前将有大量文件处理程序无法释放。

func writeManyFiles(files []File) error {for _, file := range files {f, err := os.Open(file.path)if err != nil {return err}defer f.Close()_, err = f.WriteString(file.content)if err != nil {return err}err = f.Sync()if err != nil {return err}}return nil
}

对于这种情况，我们可以使用匿名函数来封装延迟调用，以便延迟函数调用能够更早地执行。例如，上面的函数可以重写并改进为

func writeManyFiles(files []File) error {for _, file := range files {if err := func() error {f, err := os.Open(file.path)if err != nil {return err}// The close method will be called at// the end of the current loop step.defer f.Close()_, err = f.WriteString(file.content)if err != nil {return err}return f.Sync()}(); err != nil {return err}}return nil
}

当然不要犯以下错误，需要有些同学将需要延时调用的函数字节省略，导致资源泄漏

_, err := os.Open(file.path)

如果是http请求，还会导致服务端挤压大量的连接无法释放