Ce sunt goroutine-urile?

Question

Accepted Answer

O **goroutine** este o funcție ușoară, executată concurent, gestionată de runtime-ul Go. Lansarea uneia este la fel de simplă ca punerea `go` înaintea unui apel de funcție. Goroutine-urile sunt caracteristica de concurență semnificativă a Go — mult mai ieftine decât firele de execuție ale SO, deci poți rula mii sau milioane.

## Lansarea unei goroutine

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

Cuvântul cheie `go` pornește funcția pe o nouă goroutine și se întoarce imediat — codul apelator continuă fără să aștepte.

## De ce goroutine-urile sunt speciale: sunt ieftine

```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-urile nu sunt firele de execuție ale SO — scheduler-ul Go multiplexează multe goroutine-uri pe puține fire de execuție ale SO. Aceasta le face extraordinar de ieftine, permițând concurență masivă (de exemplu, o goroutine per conexiune într-un server care gestionează milioane de conexiuni).

## Problema sincronizării: main poate ieși prea devreme

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

Când `main` se întoarce, programul se termină — ucigând orice goroutine-uri care mai sunt în curs de execuție. Trebuie să coordonezi.

## Așteptare cu 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` este modul standard de a aștepta ca un set de goroutine-uri să se completeze.

## Comunicare cu canale

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

Filosofia Go: **"Nu comunica prin partajarea memoriei; partajează memoria prin comunicare"** — folosește canale pentru a transmite date între goroutine-uri în loc de variabile partajate + încuietori.

## De ce contează

Goroutine-urile sunt caracteristica definitorie a Go și motivul principal pentru care exccelează în sisteme concurente și în rețea.

Lichidul lor extrem (kiloocteți vs megaocteți pentru fire de execuție, planificate M:N pe fire de execuție ale SO) face concurența masivă practică și ușoară — un server poate genera o goroutine per cerere sau conexiune fără probleme de resurse, ceea ce este greu sau imposibil cu fire de execuție ale SO.

Înțelegerea modului de lansare a acestora (`go`), nevoia critică de **sincronizare** (main ieșind ucide goroutine-urile; folosește `WaitGroup` pentru a aștepta), și preferința Go pentru **comunicarea prin canale** în loc de memorie partajată este fundamentală pentru scrierea corectă a Go concurent.

Goroutine-urile (și modelele din jurul lor) sunt centrale pentru propunerea de valoare a Go și printre cele mai importante și frecvent testate subiecte din limbaj.