Wie sind Goroutines aufgebaut und wie viel Speicher nehmen sie im Stack ein?

Eine Goroutine ist ein leichter Ausführungsthread, der von der Laufzeitumgebung von Go verwaltet wird. Im Gegensatz zu Betriebssystem-Threads werden Goroutines auf eine kleinere Anzahl von Betriebssystem-Threads multiplexiert. Dies sorgt für eine bessere Skalierbarkeit.

Wichtige Aspekte:

• Scheduler: Die Laufzeitumgebung von Go hat ihren eigenen Scheduler (M:N Scheduler), der die Goroutines (M) auf eine begrenzte Anzahl von Betriebssystem-Threads (N) verwaltet.
• Speicher-Manager: Verwalten die Stacks der Goroutines und deren Wachstum/Schrumpfung.
• Kommunikation: Goroutines kommunizieren über Kanäle, was einen sicheren Datenaustausch ohne Blockierungen/Mutexe in den meisten Fällen gewährleistet.

Stack der Goroutine:

• Anfangs sind die Stacks der Goroutines klein, meist 2 KB (vor Go 1.4 waren es 4 KB).
• Der Stack wächst und schrumpft dynamisch. Bei Überlauf wird er automatisch erweitert, und bei Freigabe von Speicher wird er verkleinert.
• Diese dynamische Stack-Verwaltung reduziert die Kosten im Vergleich zu festen großen Betriebssystem-Threads.

Verbrauchter Speicher im Stack:

• Beim Erstellen einer Goroutine belegt sie in der Regel 2 KB Speicher für ihren Stack.
• Der Speicherverbrauch kann bei Funktionsaufrufen dynamisch steigen und beim Rückkehr sinken.
• Die maximale Stackgröße ist begrenzt, aber groß genug für die meisten Aufgaben (meist mehrere MB).

package main

import (
	"fmt"
	"runtime"
	"time"
)

func sayHello() {
	fmt.Println("Hallo von einer Goroutine!")
}

func main() {
	// Demonstration der Erstellung einer Goroutine
	go sayHello()

	// Um die Arbeit der Goroutine zu beobachten
	time.Sleep(100 * time.Millisecond)

	fmt.Printf("Anzahl der Goroutines: %d\n", runtime.NumGoroutine())
}

In diesem Beispiel wird sayHello als separate Goroutine ausgeführt. runtime.NumGoroutine() zeigt die Anzahl der aktiven Goroutines (einschließlich der Haupt-Goroutine).