Kaj so goroutine-i?

Question

Kaj so goroutine-i?

Accepted Answer

**Goroutine** je lahka, sočasno izvajana funkcija, ki jo upravlja Go runtime. Zagon je preprost — pred klic funkcije postavite `go`. Goroutine-i so podpisna sočasna funkcionalnost Go — veliko cenejši od OS niti, zato lahko zaženete na tisoče ali milijone.

## Zagon goroutine-a

```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")
}()
```

Ključna beseda `go` zažene funkcijo na novi goroutine in se nemudoma vrne — koda, ki jo je poklicala, se nadaljuje brez čakanja.

## Zakaj so goroutine-i posebni: poceni so

```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-i niso OS niti — Go razporejevalnik multipleksira več goroutine-jev na nekaj OS niti. To jih naredi izjemno poceni, kar omogoča masivno sočasnost (npr. ena goroutine na povezavo na strežniku, ki obravnava milijone povezav).

## Problem sinhronizacije: main se lahko zaključi prezgodaj

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

Ko se `main` vrne, se program konča — uproščene so vse še tekeče goroutine-e. Morate koordinirati.

## Čakanje z 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` je standardni način za čakanje, da se niz goroutine-jev zaključi.

## Komunikacija prek kanalov

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

Go filozofija: **"Ne komunicirajte z deljanjem pomnilnika; delite pomnilnik z komuniciranjem"** — uporabite kanale za prenos podatkov med goroutine-ji, namesto deljenega spremenljivki + zaklepov.

## Zakaj je to pomembno

Goroutine-i so značilna lastnost Go in glavni razlog, da izstopa pri sočasnih, omrežnih sistemih.

Njihova izredna lahkost (kilobajti nasproti megabajti za niti, razporejeni M:N na OS niti) naredi masivno sočasnost praktično in enostavno — strežnik lahko zažene goroutine za vsak zahtevek ali povezavo brez pomislekov glede virov, kar je težko ali nemogoče z OS nitmi.

Razumevanje, kako jih zagnati (`go`), kritične potrebe po **sinhronizaciji** (main, ki se zaključi, uproči goroutine-e; uporabite `WaitGroup` za čakanje) in Go-jeve prednosti za **komunikacijo prek kanalov** pred deljenim pomnilnikom je temeljno za pisanje pravilnih sočasnih Go programov.

Goroutine-i (in vzorci okoli njih) so osrednji do Go-jeve vrednostne predloga in med najpomembnejšimi in najpogosteje testiranimi temami v jeziku.