Worin unterscheiden sich Goroutines von Threads (Fäden)?

Goroutines unterscheiden sich von Threads (Fäden) in den folgenden Schlüsselaspekten:

• Verwaltung: Goroutines werden von der Laufzeitumgebung von Go verwaltet, während Threads vom Betriebssystem verwaltet werden. Dies macht den Wechsel zwischen Goroutines deutlich leichter und schneller, da kein Kernel-Kontextwechsel erforderlich ist.
• Kosten: Das Erstellen und Verwalten von Goroutines erfordert deutlich weniger Ressourcen (Speicher und Zeit) im Vergleich zu Threads. Eine Goroutine beginnt mit einem sehr kleinen Stack (einige Kilobyte), der bei Bedarf dynamisch wachsen oder schrumpfen kann, während Threads einen festen, oft viel größeren Stack haben.
• Skalierbarkeit: Aufgrund der niedrigen Kosten ist es einfach, Hunderttausende oder sogar Millionen von Goroutines in einer Anwendung zu erstellen, während die Erstellung der gleichen Anzahl von Threads schnell die Systemressourcen erschöpft.
• Planung: Der Scheduler von Go multiplext viele Goroutines auf eine geringere Anzahl von Betriebssystem-Threads. Dies implementiert kooperative Multitasking zwischen Goroutines auf einem einzelnen OS-Thread (mit Elementen der Preemption), während Betriebssystem-Threads vom OS-Scheduler verwaltet werden, der präemptives Multitasking nutzt.

Aspekt	Goroutines	Threads
Verwaltung	Laufzeitumgebung von Go	Betriebssystem
Kosten	Gering (Speicher, Zeit)	Hoch (Speicher, Zeit)
Skalierbarkeit	Sehr hoch	Begrenzte Systemressourcen
Planung	Go-Scheduler (kooperativ)	OS-Scheduler (präemptiv)
Stack	Dynamisch, klein	Fester, oft groß

Beispiel für die Erstellung einer Goroutine:

package main

import (
	"fmt"
	"time"
)

func aufgabe(id int) {
	fmt.Printf("Goroutine %d hat begonnen\n", id)
	time.Sleep(time.Second)
	fmt.Printf("Goroutine %d hat beendet\n", id)
}

func main() {
	go aufgabe(1) // Erstellen einer Goroutine
	go aufgabe(2) // Erstellen einer weiteren Goroutine

	time.Sleep(2 * time.Second) // Warten, bis die Goroutines beendet sind
	fmt.Println("Haupt-Goroutine beendet")
}