Mit jelent a goroutine?

Question

Accepted Answer

A **goroutine** egy könnyűsúlyú, egyidejűleg futó függvény, amelyet a Go futtatókörnyezet felügyel. Egy goroutine indítása olyan egyszerű, mint a `go` kulcsszó egy függvényhívás elé helyezése. A goroutine-ok a Go aláírás párhuzamosságkezelési eszközei — sokkal olcsóbbak az OS szálainál, így akár több ezer vagy milliót is futtathat egyszerre.

## Goroutine indítása

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

A `go` kulcsszó indítja a függvényt egy új goroutine-on és azonnal visszatér — a hívó kód folytatódik anélkül, hogy várnék.

## Miért különlegesek a goroutine-ok: olcsók

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

A goroutine-ok nem OS szálak — a Go ütemezője sok goroutine-ot kevés OS szálra multiplexel. Ez rendkívül olcsóvá teszi őket, ami masszív párhuzamosságot tesz lehetővé (például egy goroutine egy kapcsolatonként egy szerverinél, amely millió kapcsolatot kezel).

## A szinkronizációs probléma: a main túl korán kiléphet

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

Ha a `main` függvény visszatér, a program véget ér — megöl minden még futó goroutine-ot. Szinkronizálnod kell.

## Várakozás sync.WaitGroup-pal

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

A `sync.WaitGroup` a standard módszer arra, hogy megvárj egy goroutine-ok halmazát, amíg befejezik a munkat.

## Kommunikáció csatornákon keresztül

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

A Go filozófiája: **"Ne kommunikálj memóriamegosztással; ossz meg memóriát kommunikáción keresztül"** — csatornákat használj adatok továbbítására goroutine-ok között, nem megosztott változókat és zárolásokat.

## Miért fontos

A goroutine-ok a Go meghatározó jellemzője és az a fő ok, amely miatt kiváló az egyidejű, hálózatos rendszereknél.

Extrém könnyűségük (kilobájtok vs megabájtok szálak számára, M:N ütemezés az OS szálakra) gyakorlatiassá és könnyűvé teszi a masszív párhuzamosságot — a szerver goroutine-ot spawnolhat kérésenkénti vagy kapcsolatonkénti alapon erőforrás-problémák nélkül, amely nehéz vagy lehetetlen az OS szálakkal.

Annak megértése, hogy hogyan kell őket indítani (`go`), az **szinkronizáció** kritikus szükségessége (a main kilépése megöli a goroutine-okat; használj `WaitGroup`-ot a várakozáshoz) és a Go **csatornákon keresztüli kommunikáció** előnyben részesítése a megosztott memória helyett, alapvető a helyes, párhuzamos Go kód írásához.

A goroutine-ok (és az őket körülvevő minták) a Go értékpropozíciójának központi elemei, és a nyelv legfontosabb és leggyakrabban tesztelendő témái között tartoznak.