Was sind Goroutines?

Question

Accepted Answer

Ein **Goroutine** ist eine leichtgewichtige, gleichzeitig ausgeführte Funktion, die von der Go-Runtime verwaltet wird. Ein Goroutine zu starten ist so einfach wie `go` vor einen Funktionsaufruf zu setzen. Goroutines sind Gos charakteristisches Concurrency-Feature — viel billiger als OS-Threads, sodass du Tausende oder Millionen davon ausführen kannst.

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

Das `go`-Schlüsselwort startet die Funktion auf einem neuen Goroutine und kehrt sofort zurück — der aufrufende Code läuft weiter, ohne zu warten.

## Warum Goroutines besonders sind: Sie sind billig

```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 sind keine OS-Threads — der Go-Scheduler verteilt viele Goroutines auf wenige OS-Threads. Das macht sie außergewöhnlich billig und ermöglicht massive Concurrency (z.B. ein Goroutine pro Verbindung in einem Server, der Millionen von Verbindungen verarbeitet).

## Das Synchronisationsproblem: main kann zu früh beendet werden

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

Wenn `main` zurückkehrt, endet das Programm — und beendet alle noch laufenden Goroutines. Du musst koordinieren.

## Warten mit 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` ist die Standard-Methode, um auf eine Reihe von Goroutines zu warten, bis sie abgeschlossen sind.

## Kommunikation mit Channels

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

Die Go-Philosophie: **"Kommuniziere nicht durch Speicher-Sharing; teile Speicher durch Kommunikation"** — verwende Channels, um Daten zwischen Goroutines zu übergeben, anstatt gemeinsame Variablen + Locks zu verwenden.

## Warum es wichtig ist

Goroutines sind Gos charakteristisches Feature und der Hauptgrund, warum es bei gleichzeitigen, netzwerkgestützten Systemen hervorragend ist.

Ihre extreme Leichtigkeit (Kilobytes statt Megabytes für Threads, geplant M:N auf OS-Threads) macht massive Concurrency praktisch und einfach — ein Server kann ein Goroutine pro Request oder Verbindung starten, ohne sich um Ressourcen zu sorgen, was mit OS-Threads schwierig oder unmöglich ist.
").verstehen, wie man sie startet (`go`), die kritische Notwendigkeit zu **synchronisieren** (main-Ende tötet Goroutines; verwende `WaitGroup` zum Warten) und Gos Vorliebe für **Kommunikation über Channels** statt gemeinsamer Speicher ist fundamental für das Schreiben von korrektivem concurrent Go.

Goroutines (und die Muster um sie herum) sind zentral für Gos Wertangebot und gehören zu den wichtigsten und am häufigsten abgefragten Themen der Sprache.