您当前的位置:首页 > 电脑百科 > 程序开发 > 语言 > Go语言

Go 内存优化与垃圾收集

时间:2024-01-15 17:26:34  来源:微信公众号  作者:DeepNoMind

Go提供了自动化的内存管理机制,但在某些情况下需要更精细的微调从而避免发生OOM错误。本文将讨论Go的垃圾收集器、应用程序内存优化以及如何防止OOM(Out-Of-Memory)错误。

Go中的堆(Heap)栈(Stack)

我不会详细介绍垃圾收集器如何工作,已经有很多关于这个主题的文章和官方文档(比如A Guide to the Go Garbage Collector[2]和源码[3])。但是,我会提到一些有助于理解本文主题的基本概念。

你可能已经知道,Go的数据可以存储在两个主要的内存存储中: 栈(stack)和堆(heap)。

通常,栈存储的数据的大小和使用时间可以由Go编译器预测,包括函数局部变量、函数参数、返回值等。

栈是自动管理的,遵循后进先出(LIFO)原则。当调用函数时,所有相关数据都放在栈的顶部,函数结束时,这些数据将从栈中删除。栈不需要复杂的垃圾收集机制,其内存管理开销最小,在栈中检索和存储数据的过程非常快。

然而,并不是所有数据都可以存储在栈中。在执行过程中动态更改的数据或需要在函数范围之外访问的数据不能放在栈上,因为编译器无法预测其使用情况,这种数据应该存储在堆中。

与栈不同,从堆中检索数据并对其进行管理的成本更高。

栈里放什么,堆里放什么?

正如前面提到的,栈用于具有可预测大小和寿命的值,例如:

  • 在函数内部声明的局部变量,例如基本数据类型变量(例如数字和布尔值)。
  • 函数参数。
  • 函数返回后不再被引用的返回值。

Go编译器在决定将数据放在栈中还是堆中时会考虑各种细微差别。

例如,预分配大小为64 KB的数据将存储在栈中,而大于64 KB的数据将存储在堆中。这同样适用于数组,如果数组超过10 MB,将存储在堆中。

可以使用逃逸分析(escape analysis)来确定特定变量的存储位置。

例如,可以通过命令行编译参数-gcflags=-m来分析应用程序:

go build -gcflags=-m mAIn.go

如果使用-gcflags=-m参数编译下面的main.go:

package main

func main() {
  var arrayBefore10Mb [1310720]int
  arrayBefore10Mb[0] = 1

  var arrayAfter10Mb [1310721]int
  arrayAfter10Mb[0] = 1

  sliceBefore64 := make([]int, 8192)
  sliceOver64 := make([]int, 8193)
  sliceOver64[0] = sliceBefore64[0]
}

结果是:

# command-line-arguments
./main.go:3:6: can inline main
./main.go:7:6: moved to heap: arrayAfter10Mb
./main.go:10:23: make([]int, 8192) does not escape
./main.go:11:21: make([]int, 8193) escapes to heap

可以看到arrayAfter10Mb数组被移动到堆中,因为大小超过了10MB,而arrayBefore10Mb仍然留在栈中(对于int变量,10MB等于10 * 1024 * 1024 / 8 = 1310720个元素)。

此外,sliceBefore64没有存储在堆中,因为它的大小小于64KB,而sliceOver64被存储在堆中(对于int变量,64KB等于64 * 1024 / 8 = 8192个元素)。

要了解更多关于在堆中分配的位置和内容,可以参考malloc.go源码[4]。

因此,使用堆的一种方法是尽量避免用它!但是,如果数据已经落在堆中了呢?

与栈不同,堆的大小是无限的,并且不断增长。堆存储动态创建的对象,如结构体、分片和映射,以及由于其限制而无法放入栈中的大内存块。

在堆中重用内存并防止其完全阻塞的唯一工具是垃圾收集器。

浅谈垃圾收集器的工作原理

垃圾收集器(GC)是一种专门用于识别和释放动态分配内存的系统。

Go使用基于跟踪和标记和扫描算法的垃圾收集算法。在标记阶段,垃圾收集器将应用程序正在使用的数据标记为活跃堆。然后,在清理阶段,GC遍历所有未标记为活跃的内存并复用。

垃圾收集器不是免费工作的,需要消耗两个重要的系统资源: CPU时间和物理内存。

垃圾收集器中的内存由以下部分组成:

  • 活跃堆内存(在前一个垃圾收集周期中标记为"活跃"的内存)
  • 新的堆内存(尚未被垃圾收集器分析的堆内存)
  • 存储元数据的内存,与前两个实体相比,这些元数据通常微不足道。

垃圾收集器所消耗的CPU时间与其工作细节有关。有一种称为"stop-the-world"的垃圾收集器实现,它在垃圾收集期间完全停止程序执行,导致CPU时间被花在非生产性工作上。

在Go里,垃圾收集器并不是完全"stop-the-world",而是与应用程序并行执行其大部分工作(例如标记堆)。

但是,垃圾收集器的操作仍然有一些限制,并且会在一个周期内多次完全停止工作代码的执行,想要了解更多可以阅读源码[5]。

如何管理垃圾收集器

在Go中可以通过某些参数管理垃圾收集器: GOGC环境变量或runtime/debug包中的等效函数SetGCPercent。

GOGC参数确定将触发垃圾收集的新未分配堆内存相对于活跃内存的百分比。

GOGC的默认值是100,意味着当新内存达到活跃堆内存的100%时将触发垃圾收集。

当新堆占用活跃堆的100%时,将运行垃圾收集器

我们以示例程序为例,通过go tool trace跟踪堆大小的变化,我们用Go 1.20.1版本来运行程序。

在本例中,performMemoryIntensiveTask函数使用了在堆中分配的大量内存。这个函数启动一个队列大小为NumWorker的工作池,任务数量等于NumTasks。

package main

import (
 "fmt"
 "os"
 "runtime/debug"
 "runtime/trace"
 "sync"
)

const (
 NumWorkers    = 4     // Number of workers.
 NumTasks      = 500   // Number of tasks.
 MemoryIntense = 10000 // Size of memory-intensive task (number of elements).
)

func main() {
 // Write to the trace file.
 f, _ := os.Create("trace.out")
 trace.Start(f)
 defer trace.Stop()

 // Set the target percentage for the garbage collector. Default is 100%.
 debug.SetGCPercent(100)

 // Task queue and result queue.
 taskQueue := make(chan int, NumTasks)
 resultQueue := make(chan int, NumTasks)

 // Start workers.
 var wg sync.WaitGroup
 wg.Add(NumWorkers)
 for i := 0; i < NumWorkers; i++ {
  go worker(taskQueue, resultQueue, &wg)
 }

 // Send tasks to the queue.
 for i := 0; i < NumTasks; i++ {
  taskQueue <- i
 }
 close(taskQueue)

 // Retrieve results from the queue.
 go func() {
  wg.Wait()
  close(resultQueue)
 }()

 // Process the results.
 for result := range resultQueue {
  fmt.Println("Result:", result)
 }

 fmt.Println("Done!")
}

// Worker function.
func worker(tasks <-chan int, results chan<- int, wg *sync.WaitGroup) {
 defer wg.Done()

 for task := range tasks {
  result := performMemoryIntensiveTask(task)
  results <- result
 }
}

// performMemoryIntensiveTask is a memory-intensive function.
func performMemoryIntensiveTask(task int) int {
 // Create a large-sized slice.
 data := make([]int, MemoryIntense)
 for i := 0; i < MemoryIntense; i++ {
  data[i] = i + task
 }

 // Latency imitation.
 time.Sleep(10 * time.Millisecond)

 // Calculate the result.
 result := 0
 for _, value := range data {
  result += value
 }
 return result
}

跟踪程序执行的结果被写入文件trace.out:

// Writing to the trace file.
f, _ := os.Create("trace.out")
trace.Start(f)
defer trace.Stop()

通过go tool trace,可以观察堆大小的变化,并分析程序中垃圾收集器的行为。

 

请注意,go tool trace的精确细节和功能可能因go版本不同而有所差异,因此建议参考官方文档,以获取有关其在特定go版本中使用的详细信息。

 

GOGC的默认值

GOGC参数可以使用runtime/debug包中的debug.SetGCPercent进行设置,GOGC默认设置为100%。

用下面命令运行程序:

go run main.go

程序执行后,将会创建trace.out文件,可以使用go tool工具对其进行分析。要做到这一点,执行命令:

go tool trace trace.out

然后可以通过打开web浏览器并访问http://127.0.0.1:54784/trace来查看基于web的跟踪查看器。

GOGC = 100

在"STATS"选项卡中,可以看到"Heap"字段,显示了在应用程序执行期间堆大小的变化情况,图中红色区域表示堆占用的内存。

在"PROCS"选项卡中,"GC"(垃圾收集器)字段显示的蓝色列表示触发垃圾收集器的时刻。

一旦新堆的大小达到活动堆大小的100%,就会触发垃圾收集。例如,如果活跃堆大小为10 MB,则当当前堆大小达到10 MB时将触发垃圾收集。

跟踪所有垃圾收集调用使我们能够确定垃圾收集器处于活动状态的总时间。

GOGC=100时的GC调用次数

示例中,当GOGC值为100时,将调用垃圾收集器16次,总执行时间为14 ms。

更频繁的调用GC

如果我们将debug.SetGCPercent(10)设置为10%后运行代码,将观察到垃圾收集器调用的频率更高。现在,如果当前堆大小达到活跃堆大小的10%时,将触发垃圾收集。

换句话说,如果活跃堆大小为10 MB,则当前堆大小达到1 MB时就将触发垃圾收集。

GOGC = 10

在本例中,垃圾收集器被调用了38次,总垃圾收集时间为28 ms。

GOGC=10时的GC调用次数

可以观察到,将GOGC设置为低于100%的值可以增加垃圾收集的频率,可能导致CPU使用率增加并降低程序性能。

更少的调用GC

如果运行相同程序,但将debug.SetGCPercent(1000)设置为1000%,我们将得到以下结果:

GOGC = 1000

可以看到,当前堆的大小一直在增长,直到达到活跃堆大小的1000%。换句话说,如果活跃堆大小为10 MB,则当前堆大小达到100 MB时将触发垃圾收集。

GOGC=1000时的GC调用次数

在当前情况下,垃圾收集器被调用一次并执行2毫秒。

关闭GC

还可以通过设置GOGC=off或调用debug.SetGCPercent(-1)来禁用垃圾收集。

下面是禁用垃圾收集器而不设置GOMEMLIMIT时堆的行为:

当GC=off时,堆大小不断增长。

可以看到,在关闭GC后,应用程序的堆大小一直在增长,直到程序执行为止。

堆占用多少内存?

在活跃堆的实际内存分配中,通常不像我们在trace中看到的那样定期和可预测的工作。

活跃堆随着每个垃圾收集周期动态变化,并且在某些条件下,其绝对值可能出现峰值。

例如,如果由于多个并行任务的重叠,活跃堆的大小可以增长到800 MB,那么只有在当前堆大小达到1.6 GB时才会触发垃圾收集。

现代开发通常在具有内存使用限制的容器中运行应用。因此,如果容器将内存限制设置为1 GB,并且总堆大小增加到1.6 GB,则容器将失效,并出现OOM(out of memory)错误。

让我们模拟一下这种情况。例如,我们在内存限制为10 MB的容器中运行程序(仅用于测试目的)。Dockerfile:

FROM golang:latest as builder


WORKDIR /src
COPY . .


RUN go env -w GO111MODULE=on


RUN go mod vendor
RUN CGO_ENABLED=0 GOOS=linux go build -mod=vendor -a -installsuffix cgo -o App ./cmd/


FROM golang:latest
WORKDIR /root/
COPY --from=builder /src/app .
EXPOSE 8080
CMD ["./app"]

Docker-compose描述:

version: '3'
services:
 my-app:
   build:
     context: .
     dockerfile: Dockerfile
   ports:
     - 8080:8080
   deploy:
     resources:
       limits:
         memory: 10M

让我们使用前面设置GOGC=1000%的代码启动容器。

可以使用以下命令运行容器:

docker-compose build
docker-compose up

几秒钟后,容器将崩溃,并产生与OOM相对应的错误。

exited with code 137

这种情况非常令人不快: GOGC只控制新堆的相对值,而容器有绝对限制。

如何避免OOM?

从1.19版本开始,在GOMEMLIMIT选项的帮助下,Golang引入了一个名为"软内存管理"的特性,runtime/debug包中名为SetMemoryLimit的类似函数(可以阅读48409-soft-memory-limit.md[6]了解有关此选项的一些有趣的设计细节)提供了相同的功能。

GOMEMLIMIT环境变量设置Go运行时可以使用的总体内存限制,例如: GOMEMLIMIT = 8MiB。要设置内存值,需要使用大小后缀,在本例中为8 MB。

让我们启动将GOMEMLIMIT境变量设置为8MiB的容器。为此,我们将环境变量添加到docker-compose文件中:

version: '3'
services:
 my-app:
    environment:
      GOMEMLIMIT: "8MiB"
   build:
     context: .
     dockerfile: Dockerfile
   ports:
     - 8080:8080
   deploy:
     resources:
       limits:
         memory: 10M

现在,当启动容器时,程序运行没有任何错误。该机制是专门为解决OOM问题而设计的。

这是因为启用GOMEMLIMIT=8MiB后,会定期调用垃圾收集器,并将堆大小保持在一定限制内,结果就是会频繁调用垃圾收集器以避免内存过载。

运行垃圾收集器以使堆大小保持在一定的限制内。

成本是什么?

GOMEMLIMIT是强有力的工具,但也可能适得其反。

在上面的堆跟踪图中可以看到这种场景的一个示例。

当总内存大小由于活跃堆或持久程序泄漏的增长而接近GOMEMLIMIT时,将开始根据该限制不断调用垃圾收集器。

由于频繁调用垃圾收集器,应用程序的运行时可能会无限增加,从而消耗应用程序的CPU时间。

这种行为被称为死亡螺旋[7],可能导致应用程序性能下降,与OOM错误不同,这种问题很难检测和修复。

这正是GOMEMLIMIT机制作为软限制起作用的原因。

Go不能100%保证GOMEMLIMIT指定的内存限制会被严格执行,而是会允许使用超出限制的内存,并防止频繁调用垃圾收集器的情况。

为了实现这一点,需要对CPU使用设置限制。目前,这个限制被设置为所有处理器时间的50%,CPU窗口为2 * GOMAXPROCS秒。

这就是为什么我们不能完全避免OOM错误,而是会将其推迟到很久以后发生。

在哪里应用GOMEMLIMIT和GOGC

如果默认垃圾收集器设置在大多数情况下是足够的,那么带有GOMEMLIMIT的软内存管理机制可以使我们避免不愉快的情况。

使用GOMEMLIMIT内存限制可能有用的例子:

  • 在内存有限的容器中运行应用程序时,最好将GOMEMLIMIT设置为保留5-10%的可用内存。
  • 在运行资源密集型库或代码时,对GOMEMLIMIT进行实时管理是有好处的。
  • 当在容器中以脚本形式运行应用程序时(意味着应用程序在一段时间内执行某些任务,然后终止),禁用垃圾收集器但设置GOMEMLIMIT可以提高性能并防止超出容器的资源限制。

避免使用GOMEMLIMIT的情况:

  • 当程序已经接近其环境的内存限制时,不要设置内存限制。
  • 在无法控制的执行环境中部署时,不要使用内存限制,特别是在程序的内存使用与其输入数据成正比的情况下,例如CLI工具或桌面应用程序。

如上所述,通过深思熟虑的方法,我们可以管理程序中的微调设置,例如垃圾收集器和GOMEMLIMIT。然而,仔细考虑应用这些设置的策略无疑非常重要。

参考资料

  • [1]Memory Optimization and Garbage Collector Management in Go: https://betterprogramming.pub/memory-optimization-and-garbage-collector-management-in-go-71da4612a960
  • [2]A Guide to the Go Garbage Collector: https://tip.golang.org/doc/gc-guide
  • [3]mgc.go: https://go.dev/src/runtime/mgc.go
  • [4]malloc.go: https://go.dev/src/runtime/malloc.go
  • [5]mgc.go: https://go.dev/src/runtime/mgc.go
  • [6]48409-soft-memory-limit.md: https://Github.com/golang/proposal/blob/master/design/48409-soft-memory-limit.md
  • [7]Soft Memory Limit Death Spirals: https://github.com/golang/proposal/blob/master/design/48409-soft-memory-limit.md#death-spirals


Tags:Go   点击:()  评论:()
声明:本站部分内容及图片来自互联网,转载是出于传递更多信息之目的,内容观点仅代表作者本人,不构成投资建议。投资者据此操作,风险自担。如有任何标注错误或版权侵犯请与我们联系(Email:2595517585@qq.com),我们将及时更正、删除。
▌相关推荐
Go 内存优化与垃圾收集
Go提供了自动化的内存管理机制,但在某些情况下需要更精细的微调从而避免发生OOM错误。本文将讨论Go的垃圾收集器、应用程序内存优化以及如何防止OOM(Out-Of-Memory)错误。Go...【详细内容】
2024-01-15  Tags: Go  点击:(0)  评论:(0)  加入收藏
PHP+Go 开发仿简书,实战高并发高可用微服务架构
来百度APP畅享高清图片//下栽のke:chaoxingit.com/2105/PHP和Go语言结合,可以开发出高效且稳定的仿简书应用。在实现高并发和高可用微服务架构时,我们可以采用一些关键技术。首...【详细内容】
2024-01-14  Tags: Go  点击:(3)  评论:(0)  加入收藏
Go编程中调用外部命令的几种场景
在很多场合, 使用Go语言需要调用外部命令来完成一些特定的任务, 例如: 使用Go语言调用Linux命令来获取执行的结果,又或者调用第三方程序执行来完成额外的任务。在go的标准库...【详细内容】
2024-01-09  Tags: Go  点击:(5)  评论:(0)  加入收藏
从Google Gemini到OpenAI Q*:生成式AI研究领域全面综述
新智元报道来源:专知【新智元导读】这项综述性研究报告批判性地分析了生成式AI的发展现状和发展方向,并探究了谷歌Gemini和备受期待的OpenAI Q*等创新成果将如何改变多个领域...【详细内容】
2024-01-09  Tags: Go  点击:(11)  评论:(0)  加入收藏
MongoDB 大量数据插入时的性能影响及解决方法
MongoDB 是一种广泛应用的 NoSQL 数据库,以其高度可扩展性和灵活性而闻名。然而,在处理大量数据时,MongoDB 的性能可能会受到一些影响。大量数据插入对 MongoDB 性能的影响磁盘...【详细内容】
2024-01-05  Tags: Go  点击:(9)  评论:(0)  加入收藏
Go 语言不支持并发读写 Map,为什么?
Go语言的map类型不支持并发读写的主要原因是并发读写会导致数据竞态(data race),这意味着多个 goroutine 可能同时访问并修改同一个 map,从而引发不确定的结果。在Go语言的设计...【详细内容】
2024-01-05  Tags: Go  点击:(5)  评论:(0)  加入收藏
如何免费生成logo?
Logo设计对于一个品牌来说非常重要,它是品牌的身份标识,可以帮助人们迅速识别和记住一个品牌。同时还可以帮助建立品牌认知度,传达出品牌的专业形象。无论是大公司还是刚起步的...【详细内容】
2024-01-05  Tags: Go  点击:(0)  评论:(0)  加入收藏
Go微服务入门到容器化实践
Go微服务入门到容器化实践Go 是一门高效、现代化、快速增长的编程语言,非常适合构建 Web 应用程序。而 Docker 是一种轻量级的容器化技术,能够使得您的应用程序在任何地方运行...【详细内容】
2024-01-01  Tags: Go  点击:(10)  评论:(0)  加入收藏
你是否想知道如何应对高并发?Go语言为你提供了答案!
并发编程是当前软件领域中不可忽视的一个关键概念。随着CPU等硬件的不断发展,我们都渴望让我们的程序运行速度更快、更快。而Go语言在语言层面天生支持并发,充分利用现代CPU的...【详细内容】
2023-12-29  Tags: Go  点击:(25)  评论:(0)  加入收藏
慢聊Golang协程池Ants实现原理
大家都知道goroutine 是 Go语言中的轻量级线程实现,由 Go 运行时(runtime)管理,Go 程序会智能地将 goroutine 中的任务合理地分配给每个 CPU。创建一个goroutine大小大概在2k左...【详细内容】
2023-12-27  Tags: Go  点击:(25)  评论:(0)  加入收藏
▌简易百科推荐
Go 内存优化与垃圾收集
Go提供了自动化的内存管理机制,但在某些情况下需要更精细的微调从而避免发生OOM错误。本文将讨论Go的垃圾收集器、应用程序内存优化以及如何防止OOM(Out-Of-Memory)错误。Go...【详细内容】
2024-01-15  DeepNoMind  微信公众号  Tags:Go   点击:(0)  评论:(0)  加入收藏
Go编程中调用外部命令的几种场景
在很多场合, 使用Go语言需要调用外部命令来完成一些特定的任务, 例如: 使用Go语言调用Linux命令来获取执行的结果,又或者调用第三方程序执行来完成额外的任务。在go的标准库...【详细内容】
2024-01-09  suntiger    Tags:Go编程   点击:(5)  评论:(0)  加入收藏
Go 语言不支持并发读写 Map,为什么?
Go语言的map类型不支持并发读写的主要原因是并发读写会导致数据竞态(data race),这意味着多个 goroutine 可能同时访问并修改同一个 map,从而引发不确定的结果。在Go语言的设计...【详细内容】
2024-01-05  Go语言圈  微信公众号  Tags:Go 语言   点击:(5)  评论:(0)  加入收藏
Go微服务入门到容器化实践
Go微服务入门到容器化实践Go 是一门高效、现代化、快速增长的编程语言,非常适合构建 Web 应用程序。而 Docker 是一种轻量级的容器化技术,能够使得您的应用程序在任何地方运行...【详细内容】
2024-01-01  大雷家吃饭    Tags:Go微服务   点击:(10)  评论:(0)  加入收藏
你是否想知道如何应对高并发?Go语言为你提供了答案!
并发编程是当前软件领域中不可忽视的一个关键概念。随着CPU等硬件的不断发展,我们都渴望让我们的程序运行速度更快、更快。而Go语言在语言层面天生支持并发,充分利用现代CPU的...【详细内容】
2023-12-29  灵墨AI探索室  微信公众号  Tags:Go语言   点击:(25)  评论:(0)  加入收藏
慢聊Golang协程池Ants实现原理
大家都知道goroutine 是 Go语言中的轻量级线程实现,由 Go 运行时(runtime)管理,Go 程序会智能地将 goroutine 中的任务合理地分配给每个 CPU。创建一个goroutine大小大概在2k左...【详细内容】
2023-12-27  小许code  微信公众号  Tags:Golang   点击:(25)  评论:(0)  加入收藏
Go 语言为什么建议多使用切片,少使用数组?
01 、介绍在 Go 语言中,数组固定长度,切片可变长度;数组和切片都是值传递,因为切片传递的是指针,所以切片也被称为“引用传递”。读者朋友们在使用 Go 语言开发项目时,或者在阅读...【详细内容】
2023-12-27  Golang语言开发栈    Tags:Go 语言   点击:(22)  评论:(0)  加入收藏
Go 语言使用 Echo 构建高性能 Web 应用
Echo提供了一个高性能且易用的框架,用于构建Go语言编写的Web应用。它具备灵活的路由功能、方便的请求处理、强大的中间件支持和简单的JSON操作,非常适合快速开发API服务和Web...【详细内容】
2023-12-26  源自开发者  微信公众号  Tags:Go 语言   点击:(25)  评论:(0)  加入收藏
基于Go-Kit的Golang整洁架构实践
简介Go是整洁架构(Clean Architecture)的完美选择。整洁架构本身只是一种方法,并没有告诉我们如何构建源代码,在尝试用新语言实现时,认识到这点非常重要。自从我有了使用Ruby o...【详细内容】
2023-12-25  DeepNoMind  微信公众号  Tags:Golang   点击:(30)  评论:(0)  加入收藏
Go 中 Goroutines 轻量级并发
并发是现代软件开发的一个基本概念,使程序能够同时执行多个任务。在 Go 编程领域,理解 Goroutines 是至关重要的。本文将全面概述 Goroutines,它们的轻量级特性,如何使用 go 关...【详细内容】
2023-12-22  技术的游戏  微信公众号  Tags:Go   点击:(31)  评论:(0)  加入收藏
站内最新
站内热门
站内头条