Satu kata kunci go yang kamu tulis sembarangan cukup untuk meruntuhkan layanan produksi lewat memory leak yang senyap. Banyak developer Go terbuai oleh murahnya biaya membuat goroutine, lalu menembakkannya ke latar belakang tanpa rencana terminasi yang jelas. Akibatnya, pemakaian RAM server merangkak naik tanpa sebab yang kelihatan, memicu Out-Of-Memory (OOM) kill di tengah jam sibuk, dan memaksamu restart darurat berkali-kali. Seperti yang ditegaskan Dave Cheney, setiap goroutine tetap memakan footprint memori yang nyata dan terbatas. Sebelum menulis perintah go berikutnya, pastikan kamu tahu persis bagaimana dan kapan proses itu akan berhenti.

Ilusi "goroutine itu gratis"

Runtime Go memang dirancang untuk menangani puluhan hingga ratusan ribu goroutine secara efisien. Ukurannya jauh lebih ringan daripada OS thread tradisional, sehingga banyak engineer menganggapnya hampir tanpa biaya.

Masalahnya, ringan bukan berarti gratis. Setiap goroutine membutuhkan stack memori (mulai dari sekitar 2 KB di Go modern, dan bisa membesar sesuai kebutuhan) serta beban penjadwalan di Go scheduler. Kalau aplikasimu membuat ribuan goroutine setiap menit dan sebagian tidak pernah selesai, sisa memorinya menumpuk sampai server kehabisan napas.

Anatomi goroutine leak

Perhatikan pola yang sering muncul di proyek production (diadaptasi dari contoh Dave Cheney):

ch := someFunction()
go func() {
    for val := range ch {
        process(val)
    }
}()

Sekilas kode ini bersih dan idiomatis. Tapi ajukan satu pertanyaan kritis: kapan goroutine ini keluar?

Goroutine ini hanya berhenti jika channel ch ditutup dengan close(ch). Padahal ch dibuat dan dikembalikan oleh someFunction(). Kalau terjadi error, early return, atau perubahan logika di dalam someFunction() yang membuat channel tidak pernah ditutup, goroutine tadi terjebak menunggu selamanya. Ia tidak menghasilkan error, tidak memicu panic, dan diam-diam memakan memori servermu.

Pengecualian yang sangat jarang

Ada goroutine yang memang dirancang hidup selama aplikasi berjalan, misalnya worker pemantau file konfigurasi atau loop utama listener.Accept() pada HTTP/TCP server. Jumlahnya sangat sedikit dan siklus hidupnya terikat langsung ke proses utama (program exit). Di luar kasus itu, setiap goroutine wajib punya pintu keluar yang eksplisit.

Cara memastikan goroutine punya pintu keluar

Untuk mencegah goroutine yatim piatu (orphaned goroutine), terapkan dua pola dasar ini setiap kali bekerja dengan konkurensi di Go:

  • Gunakan context.Context untuk pembatalan. Selalu oper ctx ke dalam goroutine agar ia berhenti seketika saat request selesai, timeout tercapai, atau sistem melakukan graceful shutdown.
  • Gunakan select di dalam loop. Jangan pernah memblokir pembacaan atau pengiriman channel tanpa jalur keluar alternatif.
func startWorker(ctx context.Context, ch <-chan int) {
    go func() {
        for {
            select {
            case <-ctx.Done():
                // Pintu keluar eksplisit saat context dibatalkan
                return
            case val, ok := <-ch:
                if !ok {
                    // Pintu keluar saat channel ditutup
                    return
                }
                process(val)
            }
        }
    }()
}

Kesimpulan

Menulis kode konkurensi di Go terasa menyenangkan karena sintaksnya sederhana. Namun kedisiplinan seorang Go engineer tidak diukur dari seberapa cepat ia menjalankan goroutine, melainkan dari seberapa rapi ia menghentikannya.

Referensi