Co jsou goroutiny?

Question

Co jsou goroutiny?

Accepted Answer

**Goroutina** je lehká funkce spouštěná souběžně, kterou spravuje runtime Go. Spuštění je jednoduché — stačí před volání funkce napsat `go`. Goroutiny jsou charakteristická součást konkurenčního programování v Go — mnohem levnější než vlákna OS, takže můžete spustit tisíce či miliony.

## Spuštění goroutiny

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

Klíčové slovo `go` spustí funkci na nové goroutině a vrátí se ihned — volající kód pokračuje bez čekání.

## Proč jsou goroutiny speciální: jsou levné

```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).
```

Goroutiny nejsou vlákna OS — scheduler Go multiplexuje mnoho gorutin na několik vláken OS. To je činí mimořádně levnými a umožňuje obrovský stupeň souběžnosti (např. jednu gorutinu na připojení na serveru obsluhujícím miliony připojení).

## Problém synchronizace: main se může skončit příliš brzy

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

Když se `main` vrátí, program skončí — zabil všechny stále běžící goroutiny. Musíte koordinovat.

## Čekání se 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 standardní způsob, jak čekat na dokončení sady gorutin.

## Komunikace přes kanály

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

Filozofie Go: **"Nekomunikujte sdílením paměti; sdílejte paměť komunikací"** — používejte kanály k předávání dat mezi gorutinami místo sdílených proměnných + zámků.

## Proč to záleží

Goroutiny jsou charakteristickou součástí Go a hlavním důvodem, proč vyniká v souběžných, síťových systémech.

Jejich extrémní lehkost (kilobajty vs megabajty pro vlákna, plánována M:N na vlákna OS) činí masivní souběžnost praktickou a snadnou — server může spustit gorutinu na požadavek či připojení bez obav o prostředky, což je u vláken OS obtížné nebo nemožné.

Porozumění tomu, jak je spustit (`go`), kritické potřebě **synchronizace** (main ukončuje goroutiny; k čekání použijte `WaitGroup`) a preferencí Go **komunikovat přes kanály** místo sdílené paměti je základem pro psaní korektního souběžného kódu v Go.

Goroutiny (a vzory kolem nich) jsou centrální k hodnotě Go a patří mezi nejdůležitější a nejčastěji testované témata v jazyce.