Go语言Goroutine泄漏检测：pprof与runtime.NumGoroutine

Goroutine泄漏是Go语言开发中常见且隐蔽的问题。当一个Goroutine被创建但未能正常退出，且系统不断创建此类Goroutine时，内存和CPU资源会被耗尽，导致服务崩溃。本文将指导你如何通过代码监控和pprof工具，快速定位并解决Goroutine泄漏。

1. 实时监控：使用 runtime.NumGoroutine

最直接的检测方法是查看当前程序中存在的Goroutine数量。Go标准库提供了 runtime.NumGoroutine() 函数，可以返回当前程序正在运行的Goroutine总数。

编写一个简单的监控函数，每隔几秒打印一次Goroutine数量。

package main

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

func monitorGoroutines() {
    for {
        // 获取当前Goroutine数量
        count := runtime.NumGoroutine()
        // 打印时间戳和数量
        fmt.Printf("[%s] 当前活跃 Goroutine 数量: %d\n", time.Now().Format("15:04:05"), count)
        time.Sleep(2 * time.Second)
    }
}

func main() {
    // 启动监控协程
    go monitorGoroutines()

    // 模拟业务逻辑，保持主程序运行
    select {}
}

运行上述代码。你会看到控制台每隔2秒输出一个数字。如果该数字在程序空闲状态下依然持续单向上涨，且没有回落迹象，极大概率发生了泄漏。

2. 模拟泄漏场景

为了演示检测过程，我们需要先制造一个泄漏。以下代码会模拟一个“生产者不断发送消息，但消费者停止处理”的场景，导致通道阻塞，Goroutine无法退出。

创建一个名为 leak.go 的文件，并写入以下代码：

package main

import (
    "fmt"
    "net/http"
    _ "net/http/pprof" // 自动注册 pprof 路由
    "runtime"
    "time"
)

// produce 泄漏的源头：不断启动 Goroutine 向通道发送数据
func produce(ch chan int) {
    for i := 0; ; i++ {
        ch <- i // 如果没有接收者，这里会永久阻塞
    }
}

func monitor() {
    for {
        fmt.Printf("Goroutine Count: %d\n", runtime.NumGoroutine())
        time.Sleep(1 * time.Second)
    }
}

func main() {
    // 启动 pprof HTTP 服务，监听 6060 端口
    go func() {
        fmt.Println("启动 pprof 服务，地址: http://localhost:6060/debug/pprof/")
        http.ListenAndServe("localhost:6060", nil)
    }()

    go monitor()

    // 模拟泄漏
    ch := make(chan int)
    for i := 0; i < 10; i++ { // 启动10个生产者，但没有任何消费者
        go produce(ch)
    }

    // 保持程序运行
    select {}
}

运行程序：go run leak.go。

观察控制台输出，Goroutine数量会迅速从个位数暴涨，并在几秒内突破几百、几千。

3. 引入 pprof 进行深度分析

单纯看到数量上涨还不够，我们需要知道这些Goroutine卡在代码的哪一行。net/http/pprof 提供了Web界面和交互式终端来分析堆栈信息。

3.1 访问 Web 界面

在浏览器中 打开 http://localhost:6060/debug/pprof/goroutine?debug=1。

页面会列出所有Goroutine的堆栈信息。查找出现频率最高的堆栈轨迹。在泄漏场景中，你会看到大量重复的堆栈，它们都指向 ch <- i 这一行。

3.2 使用命令行工具（推荐）

对于复杂的系统，Web界面数据量过大，建议使用终端工具。

打开一个新的终端窗口。

执行以下命令连接到正在运行的进程：

go tool pprof http://localhost:6060/debug/pprof/goroutine

进入交互模式后，输入 top 命令查看消耗资源（此处指占用Goroutine数量）最多的函数。

(pprof) top

输出示例如下：

Showing nodes accounting for 100%, 100% total
Dropped 23 nodes (cum <= 0)
      flat  flat%   sum%        cum   cum%
     1024 100.00%   100%       1024 100.00%  main.produce
         0     0%   100%       1024 100.00%  main.main.func1

• flat 表示当前函数直接占用的 Goroutine 数量。
• cum 表示当前函数及其调用的子函数占用的 Goroutine 数量。
• main.produce 占用了 1024 个 Goroutine，这明显异常。

输入 traces 命令查看完整的调用堆栈。

(pprof) traces

你将看到具体的代码行号和调用关系，精确定位到 ch <- i 是阻塞点。

4. 诊断流程与排查技巧

为了系统化地处理问题，请遵循以下排查流程。该流程展示了从发现异常到定位代码的逻辑路径。

注意以下常见的泄漏模式，在排查时可作为重点怀疑对象：

5. 修复与验证

定位到 leak.go 中的问题后，我们需要修复它。

修改代码，添加一个退出机制或消费者。最简单的方法是添加 context 来控制生命周期，或者添加消费者。这里我们演示添加消费者来消化数据。

替换 main 函数中的逻辑如下：

func main() {
    go func() {
        fmt.Println("启动 pprof 服务，地址: http://localhost:6060/debug/pprof/")
        http.ListenAndServe("localhost:6060", nil)
    }()

    go monitor()

    ch := make(chan int)

    // 修复1：启动消费者，消费通道数据
    go func() {
        for range ch {
            // 消费数据，此处丢弃仅作演示
        }
    }()

    // 启动生产者
    for i := 0; i < 10; i++ {
        go produce(ch)
    }

    // 保持程序运行
    select {}
}

重启程序。此时 runtime.NumGoroutine() 的输出将保持稳定，不再暴涨。再次使用 go tool pprof 查看 top，main.produce 的数量也不再占据 100%。

确保在代码退出时，所有启动的 Goroutine 都能正常结束，避免资源浪费。