Go Runtime深度解析：垃圾回收（GC）

go build -gcflags="-gcflags=all=-d=gcflags=GOGC=50"

import "runtime/debug"

// 设置GOGC为75
debug.SetGCPercent(75)

export GOGC=75
./your_app

package main

import (
    "runtime/debug"
    "sync/atomic"
)

var requestCount int64

func main() {
    // 初始设置
    debug.SetGCPercent(100)

    // 监控请求量并动态调整
    go func() {
        ticker := time.NewTicker(30 * time.Second)
        defer ticker.Stop()

        for range ticker.C {
            count := atomic.LoadInt64(&requestCount)
            if count > 1000 {
                debug.SetGCPercent(75) // 高负载时降低GOGC
            } else {
                debug.SetGCPercent(100) // 正常负载时使用默认值
            }
            atomic.StoreInt64(&requestCount, 0)
        }
    }()

    // ... 应用逻辑
}

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

func main() {
    go func() {
        log.Println(http.ListenAndServe("localhost:6060", nil))
    }()

    // ... 应用逻辑
}

import (
    "os"
    "runtime/pprof"
)

func analyzeMemory() {
    // 创建内存分析文件
    f, err := os.Create("memprofile.out")
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()

    // 获取内存堆信息
    if err := pprof.WriteHeapProfile(f); err != nil {
        log.Fatal(err)
    }
}

# 获取堆内存分析
go tool pprof http://localhost:6060/debug/pprof/heap

# 获取内存分配历史
go tool pprof http://localhost:6060/debug/pprof/allocs

# 进入pprof交互模式
(pprof) top10
# 显示前10个内存分配最多的函数

(pprof) list someFunction
# 显示特定函数的内存分配详情

(pprof) web
# 生成图形化报告（需要graphviz）

(pprof) png > memory_profile.png
# 生成PNG格式的可视化报告

# 定期获取heap数据
curl -s http://localhost:6060/debug/pprof/heap > heap_$(date +%s).out

# 比较两个heap文件
go tool pprof -base=heap_1.out heap_2.out

go tool pprof http://localhost:6060/debug/pprof/allocs
(pprof) top20

go tool pprof http://localhost:6060/debug/pprof/goroutine
(pprof) traces

var bufPool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 1024)
    },
}

func processData() {
    buf := bufPool.Get().([]byte)
    defer bufPool.Put(buf)

    // 使用buf处理数据
}

// 不推荐
var result string
for _, s := range strings {
    result += s
}

// 推荐
var builder strings.Builder
for _, s := range strings {
    builder.WriteString(s)
}
result := builder.String()

// 不推荐
var items []Item
for i := 0; i < 1000; i++ {
    items = append(items, createItem(i))
}

// 推荐
items := make([]Item, 0, 1000)
for i := 0; i < 1000; i++ {
    items = append(items, createItem(i))
}

import "runtime"

func printGCStats() {
    var memStats runtime.MemStats
    runtime.ReadMemStats(&memStats)

    fmt.Printf("GC次数: %d\n", memStats.NumGC)
    fmt.Printf("GC总暂停时间: %d\n", memStats.PauseTotalNs)
    fmt.Printf("最近GC暂停时间: %d\n", memStats.PauseNs[(memStats.NumGC+255)%256])
    fmt.Printf("堆内存使用: %d bytes\n", memStats.HeapAlloc)
    fmt.Printf("堆内存目标: %d bytes\n", memStats.NextGC)
}

# 输出GC详细信息
GODEBUG=gctrace=1 ./your_app

# 输出更详细的GC信息
GODEBUG=gctrace=2 ./your_app

# 强制GC在每次分配时触发
GODEBUG=gccheckmark=1 ./your_app

import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promauto"
)

var (
    gcDuration = promauto.NewHistogram(prometheus.HistogramOpts{
        Name: "app_gc_duration_seconds",
        Help: "Duration of GC cycles",
    })

    gcCount = promauto.NewCounter(prometheus.CounterOpts{
        Name: "app_gc_count_total",
        Help: "Total number of GC cycles",
    })

    heapSize = promauto.NewGauge(prometheus.GaugeOpts{
        Name: "app_heap_size_bytes",
        Help: "Current heap size in bytes",
    })
)

func updateGCMetrics() {
    var memStats runtime.MemStats
    runtime.ReadMemStats(&memStats)

    heapSize.Set(float64(memStats.HeapAlloc))
    gcCount.Add(float64(memStats.NumGC))

    // 在GC回调中更新GC持续时间
}