Apa itu goroutine?

Question

Apa itu goroutine?

Accepted Answer

**Goroutine** adalah fungsi yang ringan dan dieksekusi secara bersamaan yang dikelola oleh runtime Go. Meluncurkan satu sangat sederhana — cukup letakkan `go` sebelum pemanggilan fungsi. Goroutine adalah fitur concurrency signature Go — jauh lebih murah daripada thread OS, sehingga 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")
}()
```

Keyword `go` memulai fungsi pada goroutine baru dan kembali segera — kode pemanggil berlanjut tanpa menunggu.

## Mengapa goroutine 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).
```

Goroutine bukan thread OS — penjadwal Go melakukan multiplexing banyak goroutine ke beberapa thread OS. Ini membuat mereka sangat murah, memungkinkan concurrency besar-besaran (misalnya 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 apa pun 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 untuk menunggu serangkaian goroutine selesai.

## Berkomunikasi dengan channel

```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; berbagi memori dengan berkomunikasi"** — gunakan channel untuk meneruskan data antar goroutine daripada variabel bersama + lock.

## Mengapa ini penting

Goroutine adalah fitur penentu Go dan alasan utama mengapa Go unggul dalam sistem concurrent dan networked.

Karingan ekstrem mereka (kilobyte versus megabyte untuk thread, dijadwalkan M:N ke thread OS) membuat concurrency besar-besaran praktis dan mudah — server dapat meluncurkan goroutine per request atau koneksi tanpa kekhawatiran sumber daya, yang sulit atau tidak mungkin dengan thread OS.

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

Goroutine (dan pola di sekitarnya) adalah pusat proposisi nilai Go dan di antara topik yang paling penting dan sering diuji dalam bahasa ini.