Što su goroutine-i?

Question

Što su goroutine-i?

Accepted Answer

**Goroutine** je lagana funkcija koja se izvršava istovremeno (concurrently) i upravlja je Go runtime. Pokretanje je jednostavno — stavite `go` ispred poziva funkcije. Goroutine-i su Go-va karakteristična značajka konkurentnosti — mnogo jeftiniji od OS nitI, tako da možete pokrenuti tisuće ili milijune.

## Pokretanje 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 reč `go` pokreće funkciju na novom goroutine-u i odmah se vraća — pozivajući kod se nastavlja bez čekanja.

## Zašto su goroutine-i specijalni: jeftini su

```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 nisu OS niti — Go scheduler multipleksira mnoge goroutine-e na nekoliko OS niti. To ih čini izuzetno jeftinima, omogućavajući ogroman konkurentnost (npr. jedan goroutine po konekciji na serveru koji rukuje milijunima konekcija).

## Problem sinhronizacije: main može prerano završiti

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

Kada se `main` vrati, program se završava — uništavajući sve još pokrenute goroutine-e. Trebate koordirati.

## Čekanje sa 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 čekanja da se skup goroutine-a dovrši.

## Komunikacija kanalizacijom

```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 dijeljenjem memorije; dijelite memoriju komunicirajući"** — koristite kanale za prosljeđivanje podataka između goroutine-a umjesto dijeljenih varijabli + brtvljenja.

## Zašto je to važno

Goroutine-i su definirajuća značajka Go-a i glavni razlog zbog kojeg se ističe u konkurentnim mrežnim sustavima.

Njihova ekstrema laganost (kilobajti nasuprot megabajti za niti, raspoređeni M:N na OS niti) čini ogroman konkurentnost praktičnom i lako — server može pokrenuti goroutine po zahtjevu ili konekciji bez zabrinutosti oko resursa, što je teško ili nemoguće sa OS nitima.

Razumijevanje kako ih pokrenuti (`go`), kritična potreba za **sinhronizacijom** (main koji izlazi ubija goroutine-e; koristite `WaitGroup` da čekate), i Go-va preferencija za **komunikaciju putem kanala** umjesto dijeljene memorije temeljna je za pisanje ispravljenih konkurentnih Go programa.

Goroutine-i (i obrasci oko njih) su srž Go-vog vrijednosnog prijedloga i među najvažnijim i najčešće testiranim temama u jeziku.