Go常见GC和内存泄漏问题分析

package main

import "fmt"

// 场景1: 返回局部变量指针 - 逃逸
func escapeExample1() *int {
    x := 42
    return &x // x逃逸到堆
}

// 场景2: 不返回指针 - 不逃逸
func noEscapeExample1() int {
    x := 42
    return x // x分配在栈上
}

// 场景3: 接口类型 - 逃逸
func escapeExample2() {
    x := 42
    fmt.Println(x) // x逃逸（fmt.Println参数是interface{}）
}

// 场景4: 闭包引用 - 可能逃逸
func escapeExample3() func() int {
    x := 42
    return func() int {
        return x // x逃逸（被闭包捕获）
    }
}

// 场景5: 发送到channel - 逃逸
func escapeExample4() {
    ch := make(chan *int, 1)
    x := 42
    ch <- &x // x逃逸
}

// 场景6: slice/map存储指针 - 逃逸
func escapeExample5() {
    x := 42
    slice := []*int{&x} // x逃逸
    _ = slice
}

// 场景7: 大对象 - 逃逸
func escapeExample6() {
    // 超过一定大小（通常10KB）的对象会逃逸
    largeArray := [10000]int{}
    _ = largeArray // 逃逸到堆
}

# 编译时查看逃逸分析
go build -gcflags="-m -m" main.go

# 输出示例：
# ./main.go:6:2: x escapes to heap:
# ./main.go:6:2:   flow: ~r0 = &x:
# ./main.go:6:2:     from &x (address-of) at ./main.go:7:9
# ./main.go:6:2:     from return &x (return) at ./main.go:7:2

// 伪代码：Dijkstra插入屏障
func DijkstraWriteBarrier(slot *unsafe.Pointer, ptr unsafe.Pointer) {
    shade(ptr) // 将新引用的对象标记为灰色
    *slot = ptr
}

// 伪代码：Yuasa删除屏障
func YuasaWriteBarrier(slot *unsafe.Pointer, ptr unsafe.Pointer) {
    shade(*slot) // 将旧引用的对象标记为灰色
    *slot = ptr
}

// 伪代码：混合写屏障
func HybridWriteBarrier(slot *unsafe.Pointer, ptr unsafe.Pointer) {
    shade(*slot) // Yuasa删除屏障
    shade(ptr)   // Dijkstra插入屏障
    *slot = ptr
}

// 触发条件：
// 当前堆内存 >= 上次GC后的堆内存 × (1 + GOGC/100)

// 默认GOGC=100，即堆内存增长100%（翻倍）时触发GC

# 环境变量
export GOGC=200  # 堆内存增长200%才触发GC（减少GC频率）
export GOGC=50   # 堆内存增长50%就触发GC（增加GC频率）
export GOGC=off  # 关闭自动GC

# 代码中设置
debug.SetGCPercent(200)

// 如果距离上次GC超过2分钟，强制触发GC
// 防止长时间不GC导致内存占用过高

// 手动调用
runtime.GC()

// 使用场景：
// - 测试代码
// - 在空闲时主动GC
// - 特殊业务逻辑（不推荐）

# 方法1: 设置环境变量GODEBUG
export GODEBUG=gctrace=1
go run main.go

# 输出示例：
# gc 1 @0.004s 0%: 0.018+0.50+0.003 ms clock, 0.14+0.16/0.23/0.56+0.027 ms cpu, 4->4->0 MB, 5 MB goal, 8 P
# 解释：
# gc 1: 第1次GC
# @0.004s: 程序运行0.004秒时触发
# 0%: GC占用CPU时间百分比
# 0.018+0.50+0.003 ms clock: sweep termination + 并发标记 + mark termination
# 4->4->0 MB: GC开始时堆大小 -> GC结束时堆大小 -> 存活对象大小
# 5 MB goal: 下次GC触发阈值
# 8 P: 使用8个P

# 方法2: 代码中获取GC统计
var stats runtime.MemStats
runtime.ReadMemStats(&stats)
fmt.Printf("GC次数: %d\n", stats.NumGC)
fmt.Printf("GC总暂停时间: %v\n", time.Duration(stats.PauseTotalNs))
fmt.Printf("上次GC暂停时间: %v\n", time.Duration(stats.PauseNs[(stats.NumGC+255)%256]))

package main

import (
    "os"
    "runtime/pprof"
    "time"
)

func main() {
    // 方法1: 生成heap profile
    f, _ := os.Create("heap.prof")
    defer f.Close()
    
    // 运行你的程序
    runYourApplication()
    
    // 写入heap profile
    pprof.WriteHeapProfile(f)
    
    // 方法2: 使用net/http自动暴露pprof接口
    // import _ "net/http/pprof"
    // go func() {
    //     http.ListenAndServe("localhost:6060", nil)
    // }()
}

func runYourApplication() {
    // 模拟内存分配
    data := make([][]byte, 0)
    for i := 0; i < 1000; i++ {
        data = append(data, make([]byte, 1024*1024)) // 1MB
        time.Sleep(10 * time.Millisecond)
    }
}

# 方法1: 命令行交互式分析
go tool pprof heap.prof

# 常用命令：
# (pprof) top          # 显示内存占用最多的函数
# (pprof) top10        # 显示前10个
# (pprof) list funcName # 显示函数源码及内存分配
# (pprof) web          # 生成调用图（需要graphviz）
# (pprof) png          # 生成PNG图片
# (pprof) help         # 查看帮助

# 方法2: Web界面分析（推荐）
go tool pprof -http=:8080 heap.prof
# 浏览器打开 http://localhost:8080
# 可以查看：
# - Top: 函数排序
# - Graph: 调用关系图
# - Flame Graph: 火焰图
# - Peek: 查看源码
# - Source: 源码视图

# 方法3: 在线分析HTTP接口
go tool pprof -http=:8080 http://localhost:6060/debug/pprof/heap

# 方法4: 对比两个profile（查找内存增长）
go tool pprof -base=heap1.prof heap2.prof

# 查看正在使用的内存（inuse）
go tool pprof -inuse_space heap.prof    # 按字节数
go tool pprof -inuse_objects heap.prof  # 按对象数

# 查看累计分配的内存（alloc，包括已释放的）
go tool pprof -alloc_space heap.prof    # 按字节数
go tool pprof -alloc_objects heap.prof  # 按对象数

package main

import (
    "os"
    "runtime/trace"
)

func main() {
    // 创建trace文件
    f, _ := os.Create("trace.out")
    defer f.Close()
    
    // 开始trace
    trace.Start(f)
    defer trace.Stop()
    
    // 运行你的程序
    runYourApplication()
}

# 启动trace web界面
go tool trace trace.out

# 浏览器会自动打开，可以看到：
# 1. View trace: 时间线视图，可以看到：
#    - 每个P的执行情况
#    - GC事件
#    - Goroutine的创建和执行
#    - 系统调用
#    - 网络阻塞

# 2. Goroutine analysis: 
#    - 每个goroutine的执行时间
#    - 阻塞时间分析

# 3. Network blocking profile:
#    - 网络IO阻塞分析

# 4. Synchronization blocking profile:
#    - 锁竞争分析

# 5. Syscall blocking profile:
#    - 系统调用阻塞分析

# 启用GC追踪
export GODEBUG=gctrace=1

# 输出示例：
# gc 1 @0.004s 0%: 0.018+0.50+0.003 ms clock, 0.14+0.16/0.23/0.56+0.027 ms cpu, 4->4->0 MB, 5 MB goal, 8 P

package main

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

func printGCStats() {
    var stats runtime.MemStats
    runtime.ReadMemStats(&stats)
    
    fmt.Println("=== GC统计信息 ===")
    fmt.Printf("GC次数: %d\n", stats.NumGC)
    fmt.Printf("GC总暂停时间: %v\n", time.Duration(stats.PauseTotalNs))
    fmt.Printf("上次GC暂停时间: %v\n", time.Duration(stats.PauseNs[(stats.NumGC+255)%256]))
    fmt.Printf("堆内存分配: %d MB\n", stats.HeapAlloc/1024/1024)
    fmt.Printf("堆内存总大小: %d MB\n", stats.HeapSys/1024/1024)
    fmt.Printf("堆对象数量: %d\n", stats.HeapObjects)
    fmt.Printf("下次GC目标: %d MB\n", stats.NextGC/1024/1024)
    fmt.Printf("累计分配: %d MB\n", stats.TotalAlloc/1024/1024)
    fmt.Println()
}

func main() {
    // 初始状态
    printGCStats()
    
    // 分配一些内存
    data := make([][]byte, 100)
    for i := 0; i < 100; i++ {
        data[i] = make([]byte, 1024*1024) // 1MB
    }
    
    // 分配后状态
    printGCStats()
    
    // 手动GC
    runtime.GC()
    
    // GC后状态
    printGCStats()
    
    // 释放引用
    data = nil
    runtime.GC()
    
    // 释放后状态
    printGCStats()
}

# 默认GOGC=100，堆内存翻倍时触发GC

# 减少GC频率（适合内存充足、追求吞吐量的场景）
export GOGC=200  # 堆内存增长200%才GC
export GOGC=300  # 堆内存增长300%才GC

# 增加GC频率（适合内存紧张、追求低延迟的场景）
export GOGC=50   # 堆内存增长50%就GC

# 代码中动态调整
debug.SetGCPercent(200)

# 设置软内存上限为4GB
export GOMEMLIMIT=4GiB

# 或在代码中设置
debug.SetMemoryLimit(4 * 1024 * 1024 * 1024)

package main

import (
    "sync"
)

// 对象池
var bufferPool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 4096)
    },
}

// 不使用Pool：每次都分配新对象
func processWithoutPool(data []byte) {
    buffer := make([]byte, 4096) // 频繁分配
    copy(buffer, data)
    // 处理buffer...
    // buffer会被GC回收
}

// 使用Pool：复用对象
func processWithPool(data []byte) {
    buffer := bufferPool.Get().([]byte) // 从池中获取
    defer bufferPool.Put(buffer)         // 用完放回
    
    copy(buffer, data)
    // 处理buffer...
}

// 不好的做法：频繁扩容
func badSliceAlloc() []int {
    slice := []int{}
    for i := 0; i < 10000; i++ {
        slice = append(slice, i) // 多次扩容，产生垃圾
    }
    return slice
}

// 好的做法：预分配
func goodSliceAlloc() []int {
    slice := make([]int, 0, 10000) // 预分配容量
    for i := 0; i < 10000; i++ {
        slice = append(slice, i) // 无需扩容
    }
    return slice
}

// 使用值类型：无需GC扫描
type Point struct {
    X, Y int
}

// 使用指针：GC需要扫描
type PointPtr struct {
    X, Y *int
}

// 数组vs切片
var arr [1000]Point    // 栈上分配，无GC压力
var slice []Point      // 堆上分配，有GC压力

package main

import (
    "fmt"
    "runtime"
)

func main() {
    // 分配一个大的ballast
    // 这块内存不使用，只是为了推高GC阈值
    ballast := make([]byte, 10*1024*1024*1024) // 10GB
    
    // 打印GC目标
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    fmt.Printf("NextGC: %d MB\n", m.NextGC/1024/1024)
    
    // 防止被优化掉
    runtime.KeepAlive(ballast)
    
    // 运行实际业务...
}

package main

import (
    "fmt"
    "time"
)

// 问题：goroutine永久阻塞
func leakyGoroutine() {
    ch := make(chan int) // 无缓冲channel
    
    go func() {
        val := <-ch // 永久阻塞：没有人发送数据
        fmt.Println(val)
    }()
    
    // 主goroutine继续执行，channel未关闭
    // 上面的goroutine永远阻塞，无法退出
}

func main() {
    for i := 0; i < 10000; i++ {
        leakyGoroutine()
    }
    
    // 10000个goroutine都泄漏了！
    time.Sleep(time.Hour)
}

func fixedGoroutine1() {
    ch := make(chan int, 1) // 缓冲channel
    
    go func() {
        select {
        case val := <-ch:
            fmt.Println(val)
        case <-time.After(time.Second):
            // 超时退出
            return
        }
    }()
}

func fixedGoroutine2(ctx context.Context) {
    ch := make(chan int)
    
    go func() {
        select {
        case val := <-ch:
            fmt.Println(val)
        case <-ctx.Done():
            // context取消时退出
            return
        }
    }()
}

// 使用：
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
fixedGoroutine2(ctx)

func fixedGoroutine3() {
    ch := make(chan int)
    
    go func() {
        for val := range ch { // 用range，channel关闭时会退出
            fmt.Println(val)
        }
    }()
    
    // 使用完后关闭channel
    ch <- 1
    ch <- 2
    close(ch) // 关闭channel，goroutine会退出
}

package main

import (
    "fmt"
    "time"
)

// 问题：goroutine无限循环，没有退出条件
func leakyWorker() {
    go func() {
        for {
            // 做一些工作
            doWork()
            time.Sleep(time.Second)
            // 没有任何退出条件！
        }
    }()
}

func doWork() {
    fmt.Println("working...")
}

func main() {
    for i := 0; i < 100; i++ {
        leakyWorker() // 创建100个永不退出的goroutine
    }
    
    time.Sleep(time.Hour)
}

package main

import (
    "context"
    "fmt"
    "time"
)

// 方法1：使用done channel
func goodWorker1() chan struct{} {
    done := make(chan struct{})
    
    go func() {
        defer close(done)
        for {
            select {
            case <-done:
                fmt.Println("worker退出")
                return
            default:
                doWork()
                time.Sleep(time.Second)
            }
        }
    }()
    
    return done
}

// 方法2：使用context（推荐）
func goodWorker2(ctx context.Context) {
    go func() {
        for {
            select {
            case <-ctx.Done():
                fmt.Println("worker退出:", ctx.Err())
                return
            default:
                doWork()
                time.Sleep(time.Second)
            }
        }
    }()
}

func main() {
    // 使用done channel
    done := goodWorker1()
    time.Sleep(5 * time.Second)
    close(done) // 通知worker退出
    
    // 使用context
    ctx, cancel := context.WithCancel(context.Background())
    for i := 0; i < 100; i++ {
        goodWorker2(ctx)
    }
    time.Sleep(5 * time.Second)
    cancel() // 一次性通知所有worker退出
    
    time.Sleep(time.Second) // 等待worker退出
}

package main

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

func monitorGoroutines() {
    ticker := time.NewTicker(5 * time.Second)
    defer ticker.Stop()
    
    for range ticker.C {
        num := runtime.NumGoroutine()
        fmt.Printf("当前Goroutine数量: %d\n", num)
        
        // 告警：如果数量持续增长
        if num > 1000 {
            fmt.Println("警告：Goroutine数量异常！")
        }
    }
}

func main() {
    go monitorGoroutines()
    
    // 运行你的程序...
    select {}
}

# 1. 在程序中暴露pprof接口
# import _ "net/http/pprof"
# go http.ListenAndServe("localhost:6060", nil)

# 2. 获取goroutine profile
curl http://localhost:6060/debug/pprof/goroutine?debug=2 > goroutine.txt

# 3. 分析goroutine.txt
# 可以看到每个goroutine的调用栈，找到泄漏的goroutine

# 4. 或使用pprof工具
go tool pprof http://localhost:6060/debug/pprof/goroutine

# (pprof) top
# 显示创建goroutine最多的函数

# (pprof) list funcName
# 查看具体代码

package main

import (
    "fmt"
    "sync"
)

// 问题：全局map无限增长
var (
    cache = make(map[string][]byte)
    mu    sync.RWMutex
)

func addToCache(key string, value []byte) {
    mu.Lock()
    defer mu.Unlock()
    cache[key] = value // 永远不删除！
}

func main() {
    // 不断添加数据
    for i := 0; i < 1000000; i++ {
        key := fmt.Sprintf("key_%d", i)
        value := make([]byte, 1024) // 1KB
        addToCache(key, value)
    }
    
    // cache占用了 1000000 * 1KB = 1GB 内存
    // 且永远不会释放！
}

package main

import (
    "fmt"
    "sync"
    "time"
)

var (
    cache = make(map[string]entry)
    mu    sync.RWMutex
)

type entry struct {
    value     []byte
    timestamp time.Time
}

func addToCache(key string, value []byte) {
    mu.Lock()
    defer mu.Unlock()
    cache[key] = entry{
        value:     value,
        timestamp: time.Now(),
    }
}

// 定期清理过期数据
func cleanupCache(maxAge time.Duration) {
    ticker := time.NewTicker(time.Minute)
    defer ticker.Stop()
    
    for range ticker.C {
        mu.Lock()
        now := time.Now()
        for key, e := range cache {
            if now.Sub(e.timestamp) > maxAge {
                delete(cache, key)
            }
        }
        mu.Unlock()
    }
}

func main() {
    go cleanupCache(5 * time.Minute)
    
    // 使用cache...
}

package main

import (
    "container/list"
    "sync"
)

// 简单的LRU缓存实现
type LRUCache struct {
    capacity int
    cache    map[string]*list.Element
    lruList  *list.List
    mu       sync.Mutex
}

type entry struct {
    key   string
    value []byte
}

func NewLRUCache(capacity int) *LRUCache {
    return &LRUCache{
        capacity: capacity,
        cache:    make(map[string]*list.Element),
        lruList:  list.New(),
    }
}

func (c *LRUCache) Get(key string) ([]byte, bool) {
    c.mu.Lock()
    defer c.mu.Unlock()
    
    if elem, ok := c.cache[key]; ok {
        c.lruList.MoveToFront(elem)
        return elem.Value.(*entry).value, true
    }
    return nil, false
}

func (c *LRUCache) Put(key string, value []byte) {
    c.mu.Lock()
    defer c.mu.Unlock()
    
    if elem, ok := c.cache[key]; ok {
        c.lruList.MoveToFront(elem)
        elem.Value.(*entry).value = value
        return
    }
    
    // 超过容量，删除最久未使用的
    if c.lruList.Len() >= c.capacity {
        oldest := c.lruList.Back()
        if oldest != nil {
            c.lruList.Remove(oldest)
            delete(c.cache, oldest.Value.(*entry).key)
        }
    }
    
    // 添加新元素
    elem := c.lruList.PushFront(&entry{key, value})
    c.cache[key] = elem
}

func main() {
    cache := NewLRUCache(1000) // 最多保存1000个元素
    
    // 使用cache...
    cache.Put("key1", []byte("value1"))
    value, ok := cache.Get("key1")
    _ = value
    _ = ok
}

package main

var globalSlice [][]byte

func appendToGlobal(data []byte) {
    globalSlice = append(globalSlice, data)
    // globalSlice永远不会清理！
}

func main() {
    for i := 0; i < 1000000; i++ {
        data := make([]byte, 1024)
        appendToGlobal(data)
    }
    
    // globalSlice占用大量内存
}

package main

var (
    globalSlice [][]byte
    maxSize     = 10000
)

func appendToGlobal(data []byte) {
    globalSlice = append(globalSlice, data)
    
    // 超过限制时，清理旧数据
    if len(globalSlice) > maxSize {
        // 方法1：删除前一半
        copy(globalSlice, globalSlice[len(globalSlice)/2:])
        globalSlice = globalSlice[:maxSize/2]
        
        // 方法2：完全重置
        // globalSlice = globalSlice[:0]
    }
}

package main

import "fmt"

func getFirstTwoBytes() []byte {
    largeArray := make([]byte, 10*1024*1024) // 10MB
    // 填充数据...
    
    // 只返回前两个字节
    return largeArray[:2]
    // 问题：返回的slice仍然引用整个10MB数组！
    // 底层数组无法被GC回收
}

func main() {
    result := getFirstTwoBytes()
    // result只有2字节，但占用了10MB内存！
    fmt.Println(len(result), cap(result))
    // 输出：2 10485760 (cap仍然是10MB)
}

package main

import "fmt"

func getFirstTwoBytesFixed() []byte {
    largeArray := make([]byte, 10*1024*1024) // 10MB
    // 填充数据...
    
    // 复制需要的数据到新slice
    result := make([]byte, 2)
    copy(result, largeArray[:2])
    return result
    // largeArray在函数返回后可以被GC回收
}

func main() {
    result := getFirstTwoBytesFixed()
    fmt.Println(len(result), cap(result))
    // 输出：2 2 (只占用2字节)
}

package main

func getPrefix() string {
    largeString := string(make([]byte, 10*1024*1024)) // 10MB字符串
    
    // 只返回前10个字符
    return largeString[:10]
    // Go 1.18之前：substring与原字符串共享底层数组
    // 10MB无法被回收！
}

package main

import "strings"

func getPrefixFixed() string {
    largeString := string(make([]byte, 10*1024*1024))
    
    // 方法1：使用strings.Clone（Go 1.18+）
    return strings.Clone(largeString[:10])
    
    // 方法2：手动复制（Go 1.18之前）
    // prefix := largeString[:10]
    // return string([]byte(prefix))
}

package main

import "time"

type LargeStruct struct {
    data [10 * 1024 * 1024]byte // 10MB
}

func createClosure() func() int {
    large := &LargeStruct{} // 10MB对象
    counter := 0
    
    return func() int {
        counter++
        // 闭包捕获了large和counter
        // 但实际上只使用了counter
        // large无法被GC回收！
        return counter
    }
}

func main() {
    closure := createClosure()
    // large对象被闭包引用，无法回收
    
    for i := 0; i < 100; i++ {
        closure()
        time.Sleep(time.Millisecond)
    }
}

package main

func createClosureFixed() func() int {
    large := &LargeStruct{}
    counter := 0
    
    // 使用large...
    _ = large
    
    // 在返回闭包前，将large设置为nil
    large = nil
    
    return func() int {
        counter++
        // 闭包只捕获counter
        return counter
    }
}

// 或者：不在闭包中引用大对象
func createClosureBetter() func() int {
    counter := 0
    // large在局部作用域，不被闭包捕获
    {
        large := &LargeStruct{}
        // 使用large...
        _ = large
    } // large在这里可以被回收
    
    return func() int {
        counter++
        return counter
    }
}

package main

import "time"

func processMessages() {
    messages := make(chan string, 100)
    
    go func() {
        for {
            select {
            case msg := <-messages:
                process(msg)
            case <-time.After(time.Minute): // 问题！
                // 超时处理
            }
        }
    }()
}

func process(msg string) {}

package main

import "time"

func processMessagesFixed() {
    messages := make(chan string, 100)
    
    go func() {
        timer := time.NewTimer(time.Minute)
        defer timer.Stop()
        
        for {
            select {
            case msg := <-messages:
                if !timer.Stop() {
                    <-timer.C // 排空channel
                }
                process(msg)
                timer.Reset(time.Minute) // 重置timer
                
            case <-timer.C:
                // 超时处理
                timer.Reset(time.Minute)
            }
        }
    }()
}

package main

import (
    "io"
    "net/http"
)

func fetchData(url string) ([]byte, error) {
    resp, err := http.Get(url)
    if err != nil {
        return nil, err
    }
    // 忘记关闭resp.Body！
    
    return io.ReadAll(resp.Body)
    // 连接无法复用，导致连接泄漏
}

package main

import (
    "io"
    "net/http"
)

func fetchDataFixed(url string) ([]byte, error) {
    resp, err := http.Get(url)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close() // 确保关闭
    
    return io.ReadAll(resp.Body)
}

// 更好的写法：即使读取失败也要关闭
func fetchDataBetter(url string) ([]byte, error) {
    resp, err := http.Get(url)
    if err != nil {
        return nil, err
    }
    defer func() {
        // 读取剩余数据并关闭，确保连接可复用
        io.Copy(io.Discard, resp.Body)
        resp.Body.Close()
    }()
    
    return io.ReadAll(resp.Body)
}

package main

import (
    "io"
    "os"
)

func readFile(filename string) ([]byte, error) {
    file, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    // 忘记关闭文件！
    
    return io.ReadAll(file)
}