Vad är goroutines?

Question

Vad är goroutines?

Accepted Answer

En **goroutine** är en lätt, samtidigt exekverande funktion som hanteras av Go-körtiden. Att starta en är enkelt — sätt bara `go` före ett funktionsanrop. Goroutines är Gos signaturfunktion för samtidighet — långt billigare än OS-trådar, så du kan köra tusentals eller miljontals.

## Starta 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`-nyckelordet startar funktionen på en ny goroutine och returnerar omedelbar — den anropande koden fortsätter utan att vänta.

## Varför goroutines är speciella: de är billiga

```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 är inte OS-trådar — Go-schemaläggaren multiplexar många goroutines på några få OS-trådar. Detta gör dem extraordinärt billiga, vilket möjliggör massiv samtidighet (t.ex. en goroutine per anslutning i en server som hanterar miljontals anslutningar).

## Synkroniseringproblemet: main kan avsluta för tidigt

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

När `main` returnerar avslutas programmet — vilket dödar eventuella körande goroutines. Du måste samordna.

## Vänta 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` är standardsättet att vänta på att en uppsättning goroutines ska slutföras.

## Kommunicera 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-filosofin: **"Kommunicera inte genom att dela minne; dela minne genom att kommunicera"** — använd channels för att skicka data mellan goroutines istället för delade variabler + lås.

## Varför det är viktigt

Goroutines är Gos avgörande funktion och huvudanledningen till att det är bra på samtidiga, nätverksbaserade system.

Deras extrema lätthet (kilobyte mot megabyte för trådar, schemalagda M:N på OS-trådar) gör massiv samtidighet praktisk och enkel — en server kan starta en goroutine per begäran eller anslutning utan resursbegränsningar, vilket är svårt eller omöjligt med OS-trådar.

Att förstå hur man startar dem (`go`), det kritiska behovet av **synkronisering** (main avslutas dödar goroutines; använd `WaitGroup` för att vänta), och Gos preferens för **kommunicering via channels** över delat minne är grundläggande för att skriva korrekt samtidig Go.

Goroutines (och mönstren omkring dem) är centrala för Gos värdeerbjudande och bland de viktigaste och oftast testade ämnena i språket.