Goroutine泄漏是指Go程序中启动的goroutine未能按预期退出，导致内存和CPU资源持续占用，最终可能引发性能下降或程序崩溃，常见原因包括：**阻塞操作未超时**（如无期限等待channel或锁）、**循环创建未回收的goroutine**（如任务生产者未控制并发数）、**未正确处理上下文取消**（如未监听ctx.Done()信号）。 ，检测手段包括：**监控runtime.NumGoroutine()**的异常增长、使用**pprof工具分析**goroutine堆栈、借助**go-leak等第三方库**自动化测试，预防措施包括：**为阻塞操作设置超时**（context.WithTimeout）、**使用sync.WaitGroup确保goroutine退出**、**避免全局channel或无限循环**、**通过缓冲池限制并发量**，关键是通过代码审查和压测提前发现潜在泄漏点。

在Go语言中，goroutine是一种轻量级的并发执行单元，由于其创建和销毁的开销极小，开发者可以轻松地创建成千上万的goroutine来处理并发任务，如果不加以控制，goroutine可能会因为某些原因无法正常退出，导致goroutine泄漏，这种泄漏会逐渐消耗系统资源，最终可能导致程序性能下降甚至崩溃，本文将探讨goroutine泄漏的原因、如何检测泄漏,并提供预防措施。

---

什么是Goroutine泄漏？

Goroutine泄漏指的是程序中启动的goroutine由于某些原因未能正确退出，导致它们一直占用系统资源（如内存、CPU等），这些泄漏的goroutine会不断累积,最终影响程序的稳定性和性能。

与内存泄漏类似，goroutine泄漏也是一种资源泄漏问题，但它的影响可能更加隐蔽,因为Go的运行时不会主动报告未退出的goroutine。

---

Goroutine泄漏的常见原因

1 未关闭的channel阻塞

在Go中,goroutine可能会因为等待一个永远不会关闭或写入的channel而永远阻塞。

func leak() {
    ch := make(chan int)
    go func() {
        val := <-ch // 阻塞，因为ch永远不会被写入
        fmt.Println(val)
    }()
    // 主goroutine退出，但子goroutine仍在等待
}

在这个例子中，由于ch没有写入数据，子goroutine会一直阻塞,导致泄漏。

2 无限循环未退出

如果goroutine进入无限循环，且没有退出条件,它将一直运行：

func leak() {
    go func() {
        for {
            // 无限循环，没有退出机制
        }
    }()
}

3 未处理的context超时或取消

在使用context.Context时，如果goroutine没有正确监听ctx.Done(),可能会导致泄漏：

func leak(ctx context.Context) {
    go func() {
        select {
        case <-time.After(5 * time.Second): // 未监听ctx.Done()
            fmt.Println("Done")
        }
    }()
}

如果ctx被取消，该goroutine仍然会等待5秒后才退出,而不是立即响应取消信号。

4 未正确使用WaitGroup

sync.WaitGroup用于等待一组goroutine完成，但如果wg.Done()未被调用，wg.Wait()会一直阻塞：

func leak() {
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        // 忘记调用 wg.Done()
    }()
    wg.Wait() // 永久阻塞
}

---

如何检测Goroutine泄漏？

1 使用runtime.NumGoroutine()

Go的runtime包提供了NumGoroutine()函数，可以获取当前运行的goroutine数量,可以在关键代码前后检查goroutine数量是否异常增长：

func TestGoroutineLeak(t *testing.T) {
    before := runtime.NumGoroutine()
    leak()
    after := runtime.NumGoroutine()
    if after > before {
        t.Error("goroutine leak detected")
    }
}

2 使用pprof

Go的pprof工具可以分析程序的goroutine堆栈信息：

import (
    "net/http"
    _ "net/http/pprof"
)
func main() {
    go func() {
        http.ListenAndServe(":6060", nil)
    }()
    // ... 其他代码
}

访问http://localhost:6060/debug/pprof/goroutine?debug=1可以查看所有活跃的goroutine及其堆栈信息,帮助定位泄漏点。

3 使用go leak检测工具

第三方工具如uber-go/goleak可以集成到单元测试中,自动检测goroutine泄漏：

import "go.uber.org/goleak"
func TestMain(m *testing.M) {
    goleak.VerifyTestMain(m)
}

---

如何预防Goroutine泄漏？

1 使用带缓冲的channel或select+default

避免goroutine因channel阻塞而泄漏：

ch := make(chan int, 1) // 带缓冲的channel
go func() {
    select {
    case val := <-ch:
        fmt.Println(val)
    default: // 避免阻塞
    }
}()

2 使用context控制goroutine生命周期

确保goroutine能响应取消信号：

func worker(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            return // 退出goroutine
        default:
            // 执行任务
        }
    }
}

3 确保WaitGroup正确使用

确保每个wg.Add(1)都有对应的wg.Done()：

var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done() // 确保调用
    // 任务代码
}()
wg.Wait()

4 限制goroutine数量

使用worker pool模式（如ants库）控制并发goroutine数量,避免无限制创建：

pool, _ := ants.NewPool(10) // 限制最多10个goroutine
defer pool.Release()
pool.Submit(func() {
    // 任务代码
})

---

Goroutine泄漏是Go并发编程中常见的问题，可能导致资源耗尽和程序崩溃，通过合理使用channel、context、WaitGroup等机制，并结合pprof或goleak等工具检测，可以有效预防和修复泄漏问题，在编写并发代码时，务必确保每个goroutine都有明确的退出路径,避免因疏忽导致资源泄漏。