Apa penyebab goroutine leaks lan carane nyegah?

Question

Accepted Answer

A **goroutine leak** minangka goroutine sing ora bakal rampung — dheweke tetep terblock utawa mlaku selamanya, nganggo memori (lan njaga obyek sing direferensikake tetep urip) sapanjang umur program. Amarga goroutines iku murah kanggo diluncurake, gampang banget bocor, lan bocor numpuk kanthi senyap nganti layanan berkurang utawa kehabisan memori.

## Penyebab 1: terblock ing saluran tanpa pengirim/penerima

```go
// ❌ LEAK — this goroutine blocks forever waiting to send
func leak() {
    ch := make(chan int)   // unbuffered
    go func() {
        ch <- 42           // blocks forever — NOBODY ever receives
    }()                     // the goroutine is stuck, never exits
    // function returns without reading ch → the goroutine leaks
}
```

Goroutine sing terblock ing saluran ngirim/narima sing ora bakal rampung bakal nunggu **selamanya** — dheweke ora bakal dicopotake sampah amarga dheweke teknise isih "mlaku."

## Penyebab 2: ora ana pembatalan / sinyal rampung

```go
// ❌ LEAK — a goroutine in an infinite loop with no way to stop
func worker(jobs <-chan int) {
    for {
        job := <-jobs      // blocks forever if jobs is never closed and stops sending
        process(job)
    }                       // no exit condition — leaks when no longer needed
}
```

## Pencegahan 1: gunakake context kanggo pembatalan

```go
// ✅ the goroutine can be told to stop
func worker(ctx context.Context, jobs <-chan int) {
    for {
        select {
        case job := <-jobs:
            process(job)
        case <-ctx.Done():       // cancellation signal → exit cleanly
            return                // the goroutine terminates, no leak
        }
    }
}
// caller: ctx, cancel := context.WithCancel(...); defer cancel()
```

Menehi saben goroutine sing umur dawa cara kanggo dibatalake (`<-ctx.Done()`) minangka pertahanan utama — iki njamin goroutines bakal rampung nalika kerjane ora luwih dibutuhake.

## Pencegahan 2: gunakake saluran buffered utawa pastikake penerima

```go
// ✅ ensure a receiver exists, or use a buffered channel so the send doesn't block
ch := make(chan int, 1)   // buffered → the send completes even if no one receives yet
go func() { ch <- 42 }()   // doesn't block
```

## Pencegahan 3: tansah tutup saluran / drainake kanthi bener

```go
// ✅ close channels so range loops terminate
go func() {
    defer close(results)    // signal completion → for-range over results ends
    for _, job := range jobs { results <- process(job) }
}()
```

## Ndeteksi bocor

```go
runtime.NumGoroutine()         // monitor the goroutine count — steady growth = leak
import _ "net/http/pprof"      // pprof exposes goroutine stacks (/debug/pprof/goroutine)
// the goleak library asserts no leaked goroutines in tests
```

Monitoring `runtime.NumGoroutine()` (nomer sing mundhak terus nunjukake bocor), nginspeksi dump goroutine liwat `pprof`, lan nggunakake `goleak` ing tes minangka alat deteksi utama.

## Mengapa penting

Goroutine leaks minangka salah siji masalah paling umum lan paling licik ing layanan Go produksi.

Amarga goroutines itu murah banget kanggo diluncurake, para pengembang nggawekake nang bebas — nanging goroutine sing terblock selamanya (ing saluran tanpa padanan, utawa ing loop tanpa henti tanpa pembatalan) **ora bakal rampung lan ora bakal ngluncurake memori** (kalebu kabeh apa sing direferensikake).

Ing server sing mlaku dawa, bocor iki numpuk kanthi senyap, perlahan-lahan nganggo memori nganti layanan berkurang utawa ambruk — lan dheweke angel dideleng amarga ora ana kesalahan langsung.

Nemahke penyebabe (operasi saluran sing terblock, pembatalan sing ilang) lan pencegahane (**pembatalan berbasis context** minangka pertahanan utama, penutupan saluran sing bener, saluran buffered, njamin penerima) penting banget kanggo nulis Go konkurren sing bisa dipercaya.

Ngetung alat deteksi (`runtime.NumGoroutine`, pprof, goleak) uga penting.

Iki minangka topik penting lan asring diuji sing mbedakake pengembang sing bisa nulis Go konkurren tingkat produksi saka wong-wong sing nulis kode sing bocor ndhuwur beban berkelanjutan.