Was sind grüne Threads (green threads)?

Grüne Threads sind Threads, die auf Benutzerebene verwaltet werden, nicht vom Betriebssystem. Sie werden nicht direkt in den OS-Threads angezeigt. Die Planung und der Kontextwechsel zwischen grünen Threads erfolgen zur Laufzeit der Programmiersprache oder durch eine spezielle Bibliothek.

Hauptmerkmale:

• Verwaltung: Wird vollständig zur Laufzeit durchgeführt.
• Ressourcen: Benötigen weniger Systemressourcen (Speicher und CPU-Zeit) im Vergleich zu nativen OS-Threads für Erstellung und Wechsel.
• Planung: Nicht preemptiv (kooperative Multitasking). Der Thread muss explizit die Kontrolle abgeben, damit ein anderer grüner Thread ausgeführt werden kann.
• Parallelismus: Aufgrund der nicht-preemptiven Planung und Verwaltung im Benutzerspeicher unterstützen grüne Threads explizit keine parallele Ausführung auf Mehrkernprozessoren ohne zusätzliche Mechanismen (z.B. Verwendung mehrerer Prozesse, jeder mit eigenen grünen Threads).

In Ruby, insbesondere in älteren Versionen (vor 1.9) und mit MRI (Matz's Ruby Interpreter), wurden grüne Threads verwendet. Dies führte zu Leistungsproblemen auf Mehrkernsystemen, da nur ein grüner Thread zu einem Zeitpunkt ausgeführt werden konnte, blockiert durch den Global Interpreter Lock (GIL). Neuere Versionen von MRI und alternative Implementierungen (JRuby, Rubinius) verwenden native OS-Threads.

# Beispiel für die Verwendung von Threads in Ruby (abhängig von Version und Implementierung können es grüne oder native Threads sein)
t1 = Thread.new do
  puts "Thread 1 gestartet"
  sleep(1)
  puts "Thread 1 beendet"
end

t2 = Thread.new do
  puts "Thread 2 gestartet"
  sleep(1)
  puts "Thread 2 beendet"
end

t1.join # Wartet auf Abschluss von Thread t1
t2.join # Wartet auf Abschluss von Thread t2

puts "Alle Threads beendet"

Vergleich zwischen grünen und nativen Threads:

Merkmal	Grüne Threads	Native OS-Threads
Verwaltung	Benutzerspeicher	Kernel des Betriebssystems
Erstellung/Wechsel	Günstiger	Teurer
Planung	Kooperativ (nicht preemptiv)	Preemptiv
Parallelismus	Eingeschränkt (ein CPU) ohne Mechanismen	Vollständig (mehrere CPUs)
Blockierende Aufrufe	Blockieren den gesamten Interpreter/Prozess	Blockieren nur den aktuellen nativen Thread

Im modernen Ruby-Kontext (ab 1.9 und höher mit MRI) sind Thread-Threads native OS-Threads. Grüne Threads, als Hauptmodell des Parallelismus, sind in MRI heute selten, können aber in speziellen Bibliotheken oder alternativen Laufzeiten vorkommen.