Cosa sono le goroutine?

Question

Accepted Answer

Una **goroutine** è una funzione leggera ed eseguita concorrentemente, gestita dal runtime di Go. Avviarla è semplice quanto mettere `go` prima di una chiamata di funzione. Le goroutine sono la caratteristica distintiva della concorrenza di Go — molto più economiche dei thread del sistema operativo, quindi puoi eseguirne migliaia o milioni.

## Avvio di una 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")
}()
```

La parola chiave `go` avvia la funzione su una nuova goroutine e ritorna immediatamente — il codice chiamante continua senza aspettare.

## Perché le goroutine sono speciali: sono economiche

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

Le goroutine non sono thread del sistema operativo — lo scheduler di Go esegue il multiplexing di molte goroutine su pochi thread del sistema operativo. Questo le rende straordinariamente economiche, abilitando concorrenza massiccia (ad es. una goroutine per connessione in un server che gestisce milioni di connessioni).

## Il problema della sincronizzazione: main può uscire troppo presto

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

Quando `main` ritorna, il programma termina — uccidendo qualsiasi goroutine ancora in esecuzione. È necessario coordinare.

## Attendere con 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` è il modo standard per attendere che un set di goroutine si completi.

## Comunicazione tramite channel

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

La filosofia di Go: **"Non comunicare condividendo la memoria; condividi la memoria comunicando"** — usa i channel per passare dati tra goroutine piuttosto che variabili condivise + lock.

## Perché è importante

Le goroutine sono la caratteristica distintiva di Go e il motivo principale per cui eccelle nei sistemi concorrenti e in rete.

La loro leggerezza estrema (kilobyte rispetto a megabyte per i thread, pianificati M:N su thread del sistema operativo) rende la concorrenza massiccia pratica e facile — un server può avviare una goroutine per richiesta o connessione senza preoccupazioni di risorse, il che è difficile o impossibile con i thread del sistema operativo.

Comprendere come avviarle (`go`), la necessità critica di **sincronizzare** (main che esce uccide le goroutine; usa `WaitGroup` per aspettare), e la preferenza di Go per **comunicare tramite channel** piuttosto che memoria condivisa è fondamentale per scrivere Go concorrente corretto.

Le goroutine (e i pattern attorno ad esse) sono centrali nella proposta di valore di Go e tra gli argomenti più importanti e frequentemente testati nel linguaggio.