Hvad er goroutines?

Question

Hvad er goroutines?

Accepted Answer

En **goroutine** er en letvægts, samtidigt-eksekverbar funktion administreret af Go-runtime. Det er så simpelt som at sætte `go` foran et funktionskald. Goroutines er Gos signatur concurrency-feature — langt billigere end OS-tråde, så du kan køre tusinder eller millioner.

## Lancering af en 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")
}()
```

`go`-nøgleordet starter funktionen på en ny goroutine og returnerer øjeblikkeligt — den kaldende kode fortsætter uden at vente.

## Hvorfor goroutines er specielle: de er billige

```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 er ikke OS-tråde — Go-scheduleren multiplexerer mange goroutines på få OS-tråde. Dette gør dem ekstraordinært billige, hvilket muliggør massiv concurrency (f.eks. en goroutine pr. forbindelse på en server, der håndterer millioner af forbindelser).

## Synkroniseringsproblemet: main kan slutte for tidligt

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

Når `main` returnerer, afsluttes programmet — hvilket dræber eventuelle stadig kørende goroutines. Du skal koordinere.

## Venting med 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` er standardmåden at vente på, at en mængde goroutines fuldfører.

## Kommunikation 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)
```

Go-filosofien: **"Kommuniker ikke ved at dele hukommelse; del hukommelse ved at kommunikere"** — brug channels til at sende data mellem goroutines i stedet for delte variabler + locks.

## Hvorfor det betyder noget

Goroutines er Gos definerende feature og hovedårsagen til, at det glimrer inden for concurrent, netværk-baserede systemer.

Deres ekstreme lethed (kilobytes kontra megabytes for tråde, planlagt M:N på OS-tråde) gør massiv concurrency praktisk og let — en server kan spawne en goroutine pr. request eller forbindelse uden ressourcebetænkeligheder, hvilket er svært eller umuligt med OS-tråde.

At forstå, hvordan man lancerer dem (`go`), det kritiske behov for at **synkronisere** (main afsluttes dræber goroutines; brug `WaitGroup` for at vente), og Gos præference for **kommunikation via channels** i stedet for delt hukommelse er fundamental for at skrive korrekt concurrent Go.

Goroutines (og mønstrene omkring dem) er centrale for Gos værditilbud og blandt de vigtigste og mest hyppigt testede emner i sproget.