Golang内存泄漏场景以及解决方案详析

Golang
310
0
0
2023-07-18
详解Golang时间处理的踩坑及解决
上一篇
go基础语法50问及方法详解
下一篇
目录
  • 1、字符串截取
  • 2、切片截取引起子切片内存泄漏
  • 3、没有重置丢失的子切片元素中的指针
  • 4、函数数组传参
  • 5、goroutine
  • 6、定时器
  • 1）time.After
  • 2）timer、ticker
  • 总结

1、字符串截取

func main() {
	var str = "12345678901234567890"
	str := str0[:10]
}

以上代码，会有10字节的内存泄漏，我们知道，str0和str1底层共享内存，只要str1一直活跃，str0 就不会被回收，10字节的内存被使用，剩下的10字节内存就造成了临时性的内存泄漏，直到str1不再活跃

如果str0足够大，str1截取足够小，或者在高并发场景中频繁使用，那么可想而知，会造成临时性内存泄漏，对性能产生极大影响。

解决方案1：string to []byte， []byte to string

func main() {
	var str = "12345678901234567890"
	str := string([]byte(str0[:10]))
}

将需要截取的部分先转换成[]byte，再转换成string，但是这种方式会产生两个10字节的临时变量，string转换[]byte时产生一个10字节临时变量，[]byte转换string时产生一个10字节的临时变量

解决方案2：

func main() {
	var str = "12345678901234567890"
	str := (" " + str0[:10])[1:]
}

这种方式仍旧会产生1字节的浪费 

解决方案3：strings.Builder

func main() {
	var str = "12345678901234567890"
	var builder strings.Builder
	builder.Grow()
	builder.WriteString(str[:10])
	str := builder.String()
}

这种方式的缺点就是代码量过多

解决方案4：strings.Repeat

func main() {
	var str = "12345678901234567890"
	str := strings.Repeat(str0[:10], 1)
}

这种方式底层还是用到了strings.Builder，优点就是将方案3进行了封装，代码量得到了精简

2、切片截取引起子切片内存泄漏

func main() {
	var s = []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
	s := s0[:5]
}

这种情况与字符串截取引起的内存泄漏情况类似，s1活跃情况下，造成s0中部分内存泄漏

解决方案：append

func main() {
	var s = []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
	s := append(s0[:0:0], s0[:5]...)
}

 append为内置函数，go源码src/builtin/builtin.go中释义：

// The append built-in function appends elements to the end of a slice. If
// it has sufficient capacity, the destination is resliced to accommodate the
// new elements. If it does not, a new underlying array will be allocated.
// Append returns the updated slice. It is therefore necessary to store the
// result of append, often in the variable holding the slice itself:
//	slice = append(slice, elem, elem2)
//	slice = append(slice, anotherSlice...)
// As a special case, it is legal to append a string to a byte slice, like this:
//	slice = append([]byte("hello "), "world"...)
func append(slice []Type, elems ...Type) []Type

3、没有重置丢失的子切片元素中的指针

func main() {
	var s = []*int{new(int), new(int), new(int), new(int), new(int)}
	s := s0[1:3]
}

原切片元素为指针类型，原切片被截取后，丢失的子切片元素中的指针元素未被置空，导致内存泄漏

解决方案：元素置空 

func main() {
	var s = []*int{new(int), new(int), new(int), new(int), new(int)}
	s[0], s0[3], s0[4] = nil, nil, nil
	s := s0[1:3]
}

4、函数数组传参

Go数组是值类型，赋值和函数传参都会复制整个数组

func main() {
	var arrayA = []int{1, 2, 3}
	var arrayB = []int{}
	arrayB = arrayA
	fmt.Printf("arrayA address: %p, arrayA value: %+v\n", &arrayA, arrayA)
	fmt.Printf("arrayB address: %p, arrayB value: %+v\n", &arrayB, arrayB)
	array(arrayA)
}
 
func array(array []int) {
	fmt.Printf("array address: %p, array value: %+v\n", &array, array)
}

 打印结果：

arrayA address: 0xc0000ae588, arrayA value: [1 2 3]
arrayB address: 0xc0000ae5a0, arrayB value: [1 2 3]
array address: 0xc0000ae5e8, array value: [1 2 3]

可以看到，三条打印的地址都不相同，说明数组是值传递的，这会导致什么问题呢？

如果我们在函数传参的时候用到了数组传参，且这个数组够大（我们假设数组大小为100万，64位机上消耗的内存约为800w字节，即8MB内存），或者该函数短时间内被调用N次，那么可想而知，会消耗大量内存，对性能产生极大的影响，如果短时间内分配大量内存，而又来不及GC，那么就会产生临时性的内存泄漏，对于高并发场景相当可怕。

解决方案1：采用指针传递

func main() {
	var arrayA = []int{1, 2, 3}
	var arrayB = &arrayA
	fmt.Printf("arrayA address: %p, arrayA value: %+v\n", &arrayA, arrayA)
	fmt.Printf("arrayB address: %p, arrayB value: %+v\n", arrayB, *arrayB)
	arrayP(&arrayA)
}
 
func arrayP(array *[]int) {
	fmt.Printf("array address: %p, array value: %+v\n", array, *array)
}

打印结果： 

arrayA address: 0xc00000e6a8, arrayA value: [1 2 3]
arrayB address: 0xc00000e6a8, arrayB value: [1 2 3]
array address: 0xc00000e6a8, array value: [1 2 3]

可以看到，三条打印的地址相同，说明指针是引用传递的 ，三个数组指向的都是同一块内存，就算数组很大，或者函数短时间被调用N次，也不会产生额外的内存开销，这样会不会有隐患呢？

有，如果arrayA的指针地址发生变化，那么，arrayB和函数内array的指针地址也随之改变，稍不注意，容易发生bug

解决方案2：利用切片可以很好的解决以上两个问题

func main() {
	var arrayA = []int{1, 2, 3}
	var arrayB = arrayA[:]
	fmt.Printf("arrayA address: %p, arrayA value: %+v\n", &arrayA, arrayA)
	fmt.Printf("arrayB address: %p, arrayB value: %+v\n", &arrayB, arrayB)
	arrayS(arrayB)
}
 
func arrayS(array []int) {
	fmt.Printf("array address: %p, array value: %+v\n", &array, array)
}

打印结果：

arrayA address: 0xc00000e6a8, arrayA value: [1 2 3]
arrayB address: 0xc0000040d8, arrayB value: [1 2 3]
array address: 0xc000004108, array value: [1 2 3]

 可以看到，三条打印的地址都不相同，而切片本身是一个引用类型，arrayA和arrayB底层共享内存，不会产生额外内存开销，而且arrayA的指针地址发生改变，arrayB的指针地址也不会改变，切片的数据结构如下：

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

5、goroutine

“Go里面10次内存泄漏有9次都是goroutine泄漏引起的”

有些编码不当的情况下，goroutine被长期挂住，导致该协程中的内存也无法被释放，就会造成永久性的内存泄漏。例如协程结束时协程中的channel没有关闭，导致一直阻塞；例如协程中有死循环；等等

我们来看下

func main() {
	ticker := time.NewTicker(time.Second *)
	for {
		<-ticker.C
		ch := make(chan int)
		go func() {
			for i :=; i < 100; i++ {
				ch <- i
			}
		}()
 
		for v := range ch {
			if v == {
				break
			}
		}
	}
}

将代码运行起来，并利用pprof工具，在web输入http://localhost/debug/pprof/，我们可以看到，goroutine的数量随着时间在不断的增加，而且丝毫没有减少的迹象

 这是因为break的时候，协程中的channel并没有关闭，导致协程一直存活，无法被回收

解决方案：

func main() {
	ticker := time.NewTicker(time.Second *)
	for {
		<-ticker.C
		cxt, cancel := context.WithCancel(context.Background())
		ch := make(chan int)
		go func(cxt context.Context) {
			for i :=; i < 100; i++ {
				select {
				case <-cxt.Done():
					return
				case ch <- i:
				}
			}
		}(cxt)
 
		for v := range ch {
			if v == {
				cancel()
				break
			}
		}
	}
}

利用context，在break之前cancel，目的就是通知协程退出，这样就避免了goroutine泄漏 

6、定时器

1）time.After

func main() {
	ch := make(chan int)
	go func() {
		for {
			timerC := time.After( * time.Second)
			//timerC 每次都是重新创建的，什么意思呢？简单说来，当 select 成功监听 ch 并进入它的处理分支，下次循环 timerC 重新创建了，时间肯定就重置了。
			select {
			//如果有多个 case 都可以运行，select 会随机公平选择出一个执行。其余的则不会执行
			case num := <-ch:
				fmt.Println("get num is", num)
			case <-timerC:
				//等价于 case <-time.After( * time.Second)
				fmt.Println("time's up!!!")
				//done<-true
			}
		}
	}()
 
	for i :=; i < 100000; i++ {
		ch <- i
		time.Sleep(time.Millisecond)
	}
}

 以上代码会造成内存泄漏，time.After底层实现是一个timer，而定时器未到触发时间，该定时器不会被gc回收，从而导致临时性的内存泄漏，而如果定时器一直在创建，那么就造成了永久性的内存泄漏了。

解决方案：采用timer定时器

func main() {
	ch := make(chan int)
	go func() {
		timer := time.NewTimer( * time.Second)
		defer timer.Stop()
		for {
			timer.Reset( * time.Second)
			select {
			case num := <-ch:
				fmt.Println("get num is", num)
			case <-timer.C:
				fmt.Println("time's up!!!")
			}
		}
	}()
 
	for i :=; i < 100000; i++ {
		ch <- i
		time.Sleep(time.Millisecond)
	}
}

 创建timer定时器，每次需要启动定时器的时候，使用Reset方法重置定时器，这样就不用每次都要创建新的定时器了

2）timer、ticker

在高并发、高性能场景中，使用time.NewTimer或者time.NewTicker定时器，都需要注意及时调用Stop方法来及时释放资源，否则可能造成临时性或者永久性的内存泄漏。

详解Golang时间处理的踩坑及解决
上一篇
go基础语法50问及方法详解
下一篇