Wat zijn goroutines?

Question

Accepted Answer

Een **goroutine** is een lichtgewicht, gelijktijdig uitgevoerde functie die door de Go runtime wordt beheerd. Het starten van een goroutine is net zo eenvoudig als het plaatsen van `go` voor een functie-aanroep. Goroutines zijn Go's kenmerkende concurrency-feature — veel goedkoper dan OS-threads, dus je kunt duizenden of miljoenen uitvoeren.

## Een goroutine starten

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

Het `go`-trefwoord start de functie op een nieuwe goroutine en keert onmiddellijk terug — de aangeroepen code gaat door zonder te wachten.

## Waarom goroutines speciaal zijn: ze zijn goedkoop

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

Goroutines zijn geen OS-threads — de Go-scheduler multiplexet veel goroutines op enkele OS-threads. Dit maakt ze buitengewoon goedkoop, waardoor massale concurrency mogelijk is (bijv. één goroutine per verbinding in een server die miljoenen verbindingen afhandelt).

## Het synchronisatieprobleem: main kan te vroeg afsluiten

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

Wanneer `main` retourneert, eindigt het programma — wat nog lopende goroutines doodt. Je moet coördineren.

## Wachten met 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` is de standaardmanier om te wachten tot een set goroutines is voltooid.

## Communicatie via channels

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

De Go-filosofie: **"Communiceer niet door geheugen te delen; deel geheugen door te communiceren"** — gebruik channels om gegevens tussen goroutines door te geven in plaats van gedeelde variabelen + locks.

## Waarom het belangrijk is

Goroutines zijn Go's definiërende feature en de belangrijkste reden waarom het uitblinkt in gelijktijdige, netwerkgebonden systemen.

Hun extreme lichtheid (kilobytes in plaats van megabytes voor threads, gepland M:N op OS-threads) maakt massale concurrency praktisch en gemakkelijk — een server kan per request of verbinding een goroutine spawnen zonder resourceproblemen, wat moeilijk of onmogelijk is met OS-threads.

Het begrijpen hoe je ze start (`go`), de kritieke noodzaak om te **synchroniseren** (main afsluiten doodt goroutines; gebruik `WaitGroup` om te wachten), en Go's voorkeur voor **communicatie via channels** in plaats van gedeeld geheugen is fundamenteel voor het schrijven van correct gelijktijdige Go-code.

Goroutines (en de patronen eromheen) zijn centraal voor Go's waardepropositie en behoren tot de belangrijkste en meest geteste onderwerpen in de taal.