Golang内存监控实现

最近在研究Golang的内存监控实现，想请教几个问题：

  1. Golang自带的runtime包可以获取哪些内存相关的指标？比如堆内存、栈内存这些具体要怎么获取？

  2. 除了runtime包，还有哪些常用的第三方库可以用来监控Golang程序的内存使用情况？

  3. 在生产环境中，针对Golang程序的内存监控有什么最佳实践吗？比如应该关注哪些关键指标，如何设置合理的告警阈值？

  4. 对于内存泄漏的排查，Golang有什么工具或方法推荐吗？

希望能得到一些实际项目中使用过的经验分享，谢谢！

2 回复

使用Go内置的runtime包可监控内存。常用方法：

  1. runtime.ReadMemStats(&memStats)获取内存统计。
  2. 结合pprof包进行性能分析，导出堆内存信息。
  3. 使用expvar包暴露内存指标，便于外部监控工具采集。

更多关于Golang内存监控实现的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


在Golang中实现内存监控，可以通过以下几种方式：

1. 使用runtime包获取内存信息

package main

import (
    "fmt"
    "runtime"
    "time"
)

func printMemStats() {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    
    fmt.Printf("Alloc = %v MiB", bToMb(m.Alloc))
    fmt.Printf("\tTotalAlloc = %v MiB", bToMb(m.TotalAlloc))
    fmt.Printf("\tSys = %v MiB", bToMb(m.Sys))
    fmt.Printf("\tNumGC = %v\n", m.NumGC)
}

func bToMb(b uint64) uint64 {
    return b / 1024 / 1024
}

func main() {
    // 定时打印内存信息
    for {
        printMemStats()
        time.Sleep(5 * time.Second)
    }
}

2. 使用pprof进行性能分析

package main

import (
    "log"
    "net/http"
    _ "net/http/pprof"
    "time"
)

func memoryIntensiveTask() {
    // 模拟内存密集型任务
    data := make([]byte, 100*1024*1024) // 100MB
    for i := range data {
        data[i] = byte(i % 256)
    }
    time.Sleep(time.Second)
}

func main() {
    // 启动pprof服务器
    go func() {
        log.Println(http.ListenAndServe("localhost:6060", nil))
    }()
    
    // 定期执行内存密集型任务
    ticker := time.NewTicker(10 * time.Second)
    for range ticker.C {
        memoryIntensiveTask()
    }
}

访问 http://localhost:6060/debug/pprof/heap 查看堆内存信息。

3. 使用expvar包暴露内存指标

package main

import (
    "expvar"
    "fmt"
    "net/http"
    "runtime"
)

var (
    memStats = expvar.NewMap("memory")
)

func updateMemStats() {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    
    memStats.Set("alloc", expvar.Func(func() interface{} {
        return m.Alloc
    }))
    memStats.Set("total_alloc", expvar.Func(func() interface{} {
        return m.TotalAlloc
    }))
    memStats.Set("sys", expvar.Func(func() interface{} {
        return m.Sys
    }))
    memStats.Set("num_gc", expvar.Func(func() interface{} {
        return m.NumGC
    }))
}

func main() {
    // 注册内存统计
    updateMemStats()
    
    // 启动HTTP服务器暴露指标
    http.Handle("/debug/vars", expvar.Handler())
    fmt.Println("Server started at :8080")
    http.ListenAndServe(":8080", nil)
}

4. 集成Prometheus监控

package main

import (
    "net/http"
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
    "runtime"
)

var (
    memAlloc = prometheus.NewGauge(prometheus.GaugeOpts{
        Name: "go_memstats_alloc_bytes",
        Help: "Currently allocated bytes",
    })
    memSys = prometheus.NewGauge(prometheus.GaugeOpts{
        Name: "go_memstats_sys_bytes",
        Help: "Total bytes obtained from system",
    })
)

func init() {
    prometheus.MustRegister(memAlloc, memSys)
}

func updateMetrics() {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    
    memAlloc.Set(float64(m.Alloc))
    memSys.Set(float64(m.Sys))
}

func main() {
    // 定期更新指标
    go func() {
        for {
            updateMetrics()
            time.Sleep(5 * time.Second)
        }
    }()
    
    http.Handle("/metrics", promhttp.Handler())
    http.ListenAndServe(":2112", nil)
}

关键内存指标说明

  • Alloc: 当前堆内存分配字节数
  • TotalAlloc: 累计分配的堆内存字节数
  • Sys: 从系统获取的总内存字节数
  • NumGC: 垃圾回收次数

这些方法可以帮助你有效监控Golang应用的内存使用情况，及时发现内存泄漏和性能问题。

回到顶部