Điều gì gây ra rò rỉ goroutine và bạn ngăn chặn chúng như thế nào?

Question

Accepted Answer

Một **rò rỉ goroutine (goroutine leak)** là một goroutine không bao giờ kết thúc — nó ở mãi trạng thái bị chặn hoặc chạy mãi, tiêu thụ bộ nhớ (và giữ cho các object nó tham chiếu còn sống) trong suốt vòng đời của chương trình. Vì goroutine rẻ để khởi chạy, rất dễ làm rò rỉ chúng, và các rò rỉ tích tụ âm thầm cho đến khi dịch vụ suy giảm hoặc hết bộ nhớ.

## Nguyên nhân 1: bị chặn trên một channel không có bên gửi/nhận

```go
// ❌ RÒ RỈ — goroutine này chặn mãi mãi để chờ gửi
func leak() {
    ch := make(chan int)   // không buffer
    go func() {
        ch <- 42           // chặn mãi mãi — KHÔNG AI nhận cả
    }()                     // goroutine bị kẹt, không bao giờ thoát
    // hàm trả về mà không đọc ch → goroutine rò rỉ
}
```

Một goroutine bị chặn trên một thao tác gửi/nhận channel không bao giờ hoàn thành sẽ chờ **mãi mãi** — nó không bao giờ được garbage collected vì về mặt kỹ thuật nó vẫn đang "chạy".

## Nguyên nhân 2: không có hủy / tín hiệu done

```go
// ❌ RÒ RỈ — một goroutine trong vòng lặp vô hạn không có cách dừng
func worker(jobs <-chan int) {
    for {
        job := <-jobs      // chặn mãi nếu jobs không bao giờ đóng và ngừng gửi
        process(job)
    }                       // không có điều kiện thoát — rò rỉ khi không còn cần
}
```

## Phòng ngừa 1: dùng context để hủy

```go
// ✅ goroutine có thể được bảo dừng
func worker(ctx context.Context, jobs <-chan int) {
    for {
        select {
        case job := <-jobs:
            process(job)
        case <-ctx.Done():       // tín hiệu hủy → thoát sạch
            return                // goroutine kết thúc, không rò rỉ
        }
    }
}
// bên gọi: ctx, cancel := context.WithCancel(...); defer cancel()
```

Cho mỗi goroutine sống lâu một cách để bị hủy (`<-ctx.Done()`) là phòng tuyến chính — nó đảm bảo các goroutine kết thúc khi công việc của chúng không còn cần thiết.

## Phòng ngừa 2: dùng channel có buffer hoặc đảm bảo có bên nhận

```go
// ✅ đảm bảo một bên nhận tồn tại, hoặc dùng channel có buffer để việc gửi không chặn
ch := make(chan int, 1)   // có buffer → việc gửi hoàn thành ngay cả khi chưa ai nhận
go func() { ch <- 42 }()   // không chặn
```

## Phòng ngừa 3: luôn đóng channel / cạn chúng đúng cách

```go
// ✅ đóng channel để các vòng lặp range kết thúc
go func() {
    defer close(results)    // báo hiệu hoàn thành → vòng for-range trên results kết thúc
    for _, job := range jobs { results <- process(job) }
}()
```

## Phát hiện rò rỉ

```go
runtime.NumGoroutine()         // theo dõi số lượng goroutine — tăng đều = rò rỉ
import _ "net/http/pprof"      // pprof phơi bày các stack goroutine (/debug/pprof/goroutine)
// thư viện goleak khẳng định không có goroutine bị rò rỉ trong test
```

Theo dõi `runtime.NumGoroutine()` (số lượng tăng đều báo hiệu rò rỉ), kiểm tra các dump goroutine qua `pprof`, và dùng `goleak` trong test là các công cụ phát hiện chính.

## Tại sao điều này quan trọng

Rò rỉ goroutine là một trong những vấn đề phổ biến và nguy hiểm ngầm nhất trong các dịch vụ Go production.

Vì goroutine rẻ đến mức để khởi chạy, các lập trình viên tạo chúng thoải mái — nhưng một goroutine bị chặn mãi mãi (trên một channel không có đối ứng, hoặc trong một vòng lặp vô hạn không có hủy) **không bao giờ kết thúc và không bao giờ giải phóng bộ nhớ của nó** (bao gồm mọi thứ nó tham chiếu).

Trong một server chạy lâu, các rò rỉ này tích tụ âm thầm, dần dần tiêu thụ bộ nhớ cho đến khi dịch vụ suy giảm hoặc crash — và chúng khó phát hiện vì không có lỗi tức thời.

Hiểu các nguyên nhân (thao tác channel bị chặn, thiếu hủy) và các biện pháp phòng ngừa (**hủy dựa trên context** là phòng tuyến chính, đóng channel đúng cách, channel có buffer, đảm bảo có bên nhận) là thiết yếu để viết Go concurrent đáng tin cậy.

Biết các công cụ phát hiện (`runtime.NumGoroutine`, pprof, goleak) cũng quan trọng không kém.

Đây là một chủ đề then chốt, được kiểm tra thường xuyên, phân biệt các lập trình viên có thể viết Go concurrent cấp production với những người viết code rò rỉ dưới tải kéo dài.