Apa iku goroutine?

Question

Apa iku goroutine?

Accepted Answer

Goroutine** iku fungsi ringan sing dieksekusi bebarengan, dikelola dening runtime Go. Ngluncurne iku gampang — mung tingal nambah `go` sadurunge panggilan fungsi. Goroutine iku fitur keserentakan sing khas Go — luwih murah tinimbang thread OS, dadi kowe bisa njalanake ribuan utawa jutaane.

## Ngluncurake 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` ngluncurake fungsi ing goroutine anyar lan bali kanthi cepet — kode sing manggil tetep nerusake tanpa ngenteni.

## Napa goroutine istimewa: 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 iku dudu thread OS — scheduler Go ngluncurake akeh goroutine ing sawetarane thread OS. Iki ndadekne luwih murah banget, ngidupake serentakan masif (contone: siji goroutine saben sambungan ing server sing ngolah jutaane sambungan).

## Masalah sinkronisasi: main bisa wae ketutup luwih dhisik

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

Lawas `main` mulih, program entuk rampung — mbunuhi sembarang goroutine sing isih mlaku. Perlu diatur.

## Ngenteni nganggo 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` iku cara standar ngenteni goroutine set selesai.

## Komunikasi nganggo channel

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

Filsafat Go: **"Ojo komunikasi kanthi nuduhake memori; nuduhake memori kanthi komunikasi"** — gunaake channel kanggo nerusake data antarane goroutine tinimbang variabel srawung + kunci.

## Napa iku penting

Goroutine iku fitur khas Go lan alasan utama kenapa Go unggul ing sistem jaringan serentakan.

Kamurahane ekstrim (kilobyte tinimbang megabyte kanggo thread, dijadwal M:N ing thread OS) ndadekne serentakan masif praktis lan gampang — server bisa ngluluske goroutine saben panjaluk utawa sambungan tanpa kuwatir sumber daya, apa sing angel utawa ora bisa nganggo thread OS.

Paham carane ngluncurake (`go`), kabutuhan kritikal ngatur sinkronisasi (`main` entuk rampung mbunuhi goroutine; gunaake `WaitGroup` kanggo ngenteni), lan pilihan Go kanggo komunikasi liwat channel tinimbang memori srawung iku dhasar kanggo nulis Go serentakan sing bener.

Goroutine (lan pola sekirane) iku pusete proposisi nilai Go lan salah siji topik penting banget lan akeh kena tes ing basa.