Go语言Goroutine泄漏的常见原因与检测方法

Goroutine是Go语言并发编程的核心，轻量且高效。但若使用不当，容易导致Goroutine泄漏——即Goroutine启动后无法正常退出，持续占用内存和系统资源，最终拖垮程序。以下列出常见泄漏场景及对应的检测与修复方法。

一、常见泄漏原因与修复方式

1. 未关闭的channel导致Goroutine阻塞

问题表现：Goroutine在向无缓冲或已满的channel写入数据时永久阻塞，因为没有其他Goroutine从该channel读取。

典型错误代码：

func leakExample1() {
    ch := make(chan int)
    go func() {
        ch <- 42 // 此处永久阻塞，因无人接收
    }()
    // 主函数继续执行，但后台Goroutine卡住
}

修复方法：

• 确保有接收方：为每个发送操作配对接收逻辑。
• 使用带缓冲的channel（仅限有限数据）：ch := make(chan int, 1) 可避免单次发送阻塞。
• 用select+default避免死等（适用于非关键路径）：

  select {
  case ch <- 42:
      // 发送成功
  default:
      // 通道满，放弃或记录日志
  }

2. 忘记调用context取消函数

问题表现：使用context.WithCancel创建子context后，未调用返回的cancel()函数，导致监听该context的Goroutine无法退出。

典型错误代码：

func leakExample2() {
    ctx, _ := context.WithCancel(context.Background())
    go func() {
        <-ctx.Done() // 等待取消信号
    }()
    // 忘记调用 cancel()
}

修复方法：

• 始终调用cancel()，通常配合defer：

  func fixedExample2() {
      ctx, cancel := context.WithCancel(context.Background())
      defer cancel() // 确保退出时触发取消
      go func() {
          <-ctx.Done()
      }()
  }

3. WaitGroup未正确计数或未等待

问题表现：启动多个Goroutine但未正确调用Add()，或主流程未调用Wait()，导致程序提前退出而Goroutine被“遗弃”（虽不严格算泄漏，但在长期运行服务中类似）；更严重的是，在循环中重复Add(1)却只Done()一次。

典型错误代码：

func leakExample3() {
    var wg sync.WaitGroup
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            // 工作逻辑
        }()
    }
    // 忘记 wg.Wait()，主函数直接返回
}

修复方法：

• 确保Add与Done成对出现，且在所有Goroutine启动后再调用Wait()。
• 避免在Goroutine内部调用Add()，防止竞态。

4. 定时器（time.Ticker / time.Timer）未停止

问题表现：创建time.Ticker或time.Timer后未调用Stop()，即使不再需要，其底层Goroutine仍会持续运行。

典型错误代码：

func leakExample4() {
    ticker := time.NewTicker(1 * time.Second)
    go func() {
        for range ticker.C {
            // 定期任务
        }
    }()
    // 未调用 ticker.Stop()
}

修复方法：

• 使用后立即停止：

  func fixedExample4() {
      ticker := time.NewTicker(1 * time.Second)
      defer ticker.Stop() // 确保退出时停止
      go func() {
          for {
              select {
              case <-ticker.C:
                  // 执行任务
              case <-ctx.Done(): // 结合context更安全
                  return
              }
          }
      }()
  }

二、检测Goroutine泄漏的方法

1. 使用pprof实时查看Goroutine数量

步骤：

1. 在程序中引入pprof HTTP接口：

   import _ "net/http/pprof"
   import "net/http"
   
   func main() {
       go func() {
           http.ListenAndServe("localhost:6060", nil)
       }()
       // 你的业务逻辑
   }

2. 运行程序后，访问http://localhost:6060/debug/pprof/goroutine?debug=1，可看到当前所有Goroutine的堆栈信息。

3. 观察Goroutine总数是否随时间异常增长。若每次请求后Goroutine数增加且不回落，极可能泄漏。

2. 在测试中强制检测Goroutine数量变化

步骤：

1. 编写辅助函数获取当前Goroutine数量：

   func numGoroutines() int {
       return int(runtime.NumGoroutine())
   }

2. 在单元测试前后对比数量：

   func TestNoGoroutineLeak(t *testing.T) {
       start := numGoroutines()
       // 执行可能启动Goroutine的函数
       yourFunction()
       // 等待可能的异步操作完成（必要时加短延迟）
       time.Sleep(10 * time.Millisecond)
       end := numGoroutines()
       if end > start {
           t.Errorf("Goroutine leaked: %d -> %d", start, end)
       }
   }

3. 使用第三方工具自动化检测

推荐工具 go-leak（GitHub开源项目），可在测试结束时自动检查是否有意外存活的Goroutine。

使用步骤：

1. 安装工具：

   go install github.com/uber-go/goleak@latest

2. 在测试函数中加入检查：

   import "go.uber.org/goleak"
   
   func TestMain(m *testing.M) {
       goleak.VerifyTestMain(m)
   }
   
   func TestYourFunction(t *testing.T) {
       // 你的测试逻辑
       // 测试结束后，goleak会自动验证无泄漏
   }

三、预防泄漏的最佳实践

关键原则：每一个go func()都必须有明确的生命周期终点。如果无法确定它何时结束，就很可能泄漏。