Mitä ovat goroutiinit?

Question

Accepted Answer

**Goroutiini** on kevyt, samanaikaisesti suoritettava funktio, jota hallinnoi Go-ajoympäristö. Sen käynnistäminen on yksinkertaista — laita `go` funktion kutsun edelle. Goroutiinit ovat Gon tunnusomainen samanaikaisuusominaisuus — paljon halvempia kuin käyttöjärjestelmän säikeet, joten voit suorittaa tuhansia tai miljoonia niistä.

## Goroutiinin käynnistäminen

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

`go`-avainsana käynnistää funktion uudella goroutiinilla ja palaa välittömästi — kutsuvat koodit jatkuvat ilman odottamista.

## Miksi goroutiinit ovat erityisiä: ne ovat halpoja

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

Goroutiinit eivät ole käyttöjärjestelmän säikeitä — Go-ajoitin multipleksoi monia goroutiineja muutamille käyttöjärjestelmän säikeille. Tämä tekee niistä poikkeuksellisen halpoja, mikä mahdollistaa valtavan samanaikaisuuden (esim. yksi goroutiini yhteyttä kohti palvelimessa, joka käsittelee miljoonia yhteyksiä).

## Synkronointiongelman: main voi poistua liian aikaisin

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

Kun `main` palaa, ohjelma päättyy — mikä tappaa kaikki vielä käynnissä olevat goroutiinit. Sinun on koordinoitava.

## Odottaminen sync.WaitGroupilla

```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` on vakiotapa odottaa, että joukko goroutiineja on valmis.

## Kommunikaatio kanavia käyttäen

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

Gon filosofia: **"Älä kommunikoi muistia jakamalla; jaa muistia kommunikoimalla"** — käytä kanavia tiedon välittämiseen goroutiinien välillä jakamisen muuttujien ja lukkojen sijaan.

## Miksi se on tärkeää

Goroutiinit ovat Gon määrittelevä ominaisuus ja pääsyy siihen, miksi se menestyy samanaikaisissa, verkkojärjestelmissä.

Niiden äärimmäinen keveys (kilotavuja verrattuna megatavuihin säikeissä, ajoitettu M:N-muodossa käyttöjärjestelmän säikeille) tekee massiivisesta samanaikaisuudesta käytännöllistä ja helppoa — palvelin voi luoda goroutiinin jokaista pyyntöä tai yhteyttä kohti ilman resursseja koskevia huolia, mikä on vaikeaa tai mahdotonta käyttöjärjestelmän säikeillä.

Ymmärtäminen niiden käynnistämisestä (`go`), kriittisestä tarpeesta **synkronoida** (main poistuu tappaa goroutiinit; käytä `WaitGroup`:ia odottamiseen) ja Gon mieltymyksestä **kommunikaatiolle kanavien kautta** jaetun muistin sijaan on perustavanlaatuista oikean samanaikaisesti Goa:ta kirjoitettaessa.

Goroutiinit (ja niiden ympärillä olevat mallit) ovat keskeisiä Gon arvolupauksen kannalta ja kuuluvat kielen tärkeimpiin ja useimmin testattuihin aiheisiin.