Apa itu goroutines?

Question

Apa itu goroutines?

Accepted Answer

**goroutine** adalah fungsi yang ringan dan dijalankan secara serentak, dikelola oleh runtime Go. Meluncurkannya semudah meletakkan `go` sebelum panggilan fungsi. Goroutines adalah fitur concurrency khas Go — jauh lebih murah daripada thread OS, jadi Anda dapat menjalankan ribuan atau jutaan.

## Meluncurkan goroutine

```go
func sayHello() {
    fmt.Println("Hello from a goroutine")
}

go sayHello()        // launch concurrently — main does NOT wait for it
go func() {           // or an anonymous function
    fmt.Println("inline goroutine")
}()
```

Kata kunci `go` memulai fungsi di goroutine baru dan kembali segera — kode pemanggil terus berjalan tanpa menunggu.

## Mengapa goroutines istimewa: mereka murah

```text
OS thread:  ~1–2 MB of memory each → thousands max
Goroutine:  ~2 KB initial stack (grows as needed) → MILLIONS feasible
The Go runtime SCHEDULES many goroutines onto a small pool of OS threads (M:N).
```

Goroutines bukan thread OS — penjadwal Go melakukan multiplexing banyak goroutines ke beberapa thread OS. Ini membuatnya luar biasa murah, memungkinkan concurrency masif (mis. satu goroutine per koneksi di server yang menangani jutaan koneksi).

## Masalah sinkronisasi: main dapat keluar terlalu cepat

```go
func main() {
    go sayHello()    // ❌ main might EXIT before this goroutine runs → nothing printed
    // program ends immediately
}
```

Ketika `main` kembali, program berakhir — membunuh goroutine yang masih berjalan. Anda perlu mengoordinasikan.

## Menunggu dengan sync.WaitGroup

```go
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
    wg.Add(1)                    // increment the counter
    go func(n int) {
        defer wg.Done()          // decrement when this goroutine finishes
        fmt.Println("worker", n)
    }(i)                          // pass i as an argument (avoid the loop-var capture bug)
}
wg.Wait()                         // BLOCK until all goroutines call Done()
```

`sync.WaitGroup` adalah cara standar menunggu sekumpulan goroutines selesai.

## Berkomunikasi dengan channels

```go
ch := make(chan string)
go func() { ch <- "result" }()   // send a result on the channel
msg := <-ch                       // receive (blocks until a value arrives)
```

Filosofi Go: **"Jangan berkomunikasi dengan berbagi memori; bagikan memori dengan berkomunikasi"** — gunakan channels untuk mengirimkan data antar goroutines daripada variabel bersama + kunci.

## Mengapa ini penting

Goroutines adalah fitur khas Go dan alasan utama mengapa Go unggul dalam sistem concurrent dan jaringan.

Karingannya yang ekstrem (kilobytes vs megabytes untuk thread, dijadwalkan M:N ke thread OS) membuat concurrency masif praktis dan mudah — server dapat menspawn goroutine per request atau koneksi tanpa kekhawatiran sumber daya, yang sulit atau mustahil dengan thread OS.

Memahami cara meluncurkannya (`go`), kebutuhan kritis untuk **sinkronisasi** (main keluar membunuh goroutines; gunakan `WaitGroup` untuk menunggu), dan preferensi Go untuk **berkomunikasi melalui channels** daripada memori bersama adalah fundamental untuk menulis Go concurrent yang benar.

Goroutines (dan pola di sekitarnya) adalah inti dari proposisi nilai Go dan di antara topik paling penting dan paling sering diuji dalam bahasa.