Die Programmiersprache Ruby (German Edition)

ist eine Sequenz von Ruby-Anweisungen, die parallel zu der Hauptsequenz von Anweisungen läuft (oder zu laufen scheint), die der Interpreter gerade ausführt. Threads werden durch
Thread
-Objekte dargestellt, aber man kann sie sich auch als Kontrollstrukturen für Nebenläufigkeit vorstellen. Die nebenläufige Programmierung in Ruby wird detailliert in „9.9 Threads und Parallelität“ behandelt. Dieser Abschnitt ist nur ein einfacher Überblick, der zeigt, wie man Threads erzeugt.
    Rubys Verwendung von Blöcken macht es sehr einfach, neue Threads zu erzeugen. Rufen Sie einfach
Thread.new
auf und verknüpfen Sie einen Block damit. Ein neuer Ausführungs-Thread wird erzeugt und beginnt damit, den Code in dem Block auszuführen. In der Zwischenzeit kehrt der ursprüngliche Thread von dem
Thread.new
-Aufruf zurück und fährt mit der nachfolgenden Anweisung fort. Der neu erzeugte Thread wird beendet, wenn der Block beendet wird. Der Rückgabewert des Blocks wird durch die Methode
value
des Thread-Objekts zur Verfügung gestellt. (Wenn Sie diese Methode aufrufen, bevor der Thread abgeschlossen ist, blockiert die aufrufende Stelle, bis der Thread einen Wert zurückgibt.)
    Der folgende Code zeigt Ihnen, wie Sie Threads verweden können, um mehrere Dateien parallel zu lesen:
# Diese Methode erwartet ein Array von Dateinamen.
# Sie gibt ein Array von Strings zurück, die den Inhalt der
# genannten Dateien enthalten. Die Methode erzeugt einen
# Thread für jede genannte Datei.
def readfiles(filenames)
# Ein Array mit Threads aus dem Dateinamen-Array erzeugen.
# Jeder Thread beginnt mit dem Lesen einer Datei.
threads = filenames.map do |f|
    Thread.new { File.read(f) }
end
# Nun ein Array mit Dateiinhalten erzeugen, indem die
# Methode value für jeden Thread aufgerufen wird. Diese
# Methode blockiert, wenn nötig, bis der Thread mit einem
# Wert beendet wird.
threads.map {|t| t.value }
end
    Siehe „9.9 Threads und Parallelität“ für mehr Details über Threads und Nebenläufigkeit in Ruby.
    5.8.2 Fiber für Coroutinen
    Ruby 1.9 führt eine neue Kontrollstruktur ein, die Fiber genannt und von einem Objekt der Klasse
Fiber
repräsentiert wird. Der Name »Fiber« (etwa »Faser«) wurde in anderen Fällen für eine Art leichtgewichtiger Threads verwendet, aber Rubys Fiber lassen sich besser als Coroutinen oder noch genauer als Semicoroutinen beschreiben. Der gängigste Verwendungszweck für Coroutinen besteht in der Implementierung von Generatoren: Das sind Objekte, die ein Teilergebnis berechnen, das Ergebnis an die aufrufende Stelle zurückgeben, und den Zustand der Berechnung speichern können, so dass die aufrufende Stelle diese Berechnung wieder aufnehmen kann, um das nächste Ergebnis zu erhalten. In Ruby wird die Klasse
Fiber
verwendet, um die automatische Konvertierung interner Iteratoren wie der Methode
each
in Enumeratoren oder externe Iteratoren zu aktivieren.
    Beachten Sie, dass Fiber eine fortgeschrittene und relativ obskure Kontrollstruktur sind; die Mehrheit der Ruby-Programmierer wird die Klasse
Fiber
niemals direkt verwenden müssen. Wenn Sie nie zuvor mit Coroutinen oder Generatoren programmiert haben, kann es sein, dass Sie sie anfangs schwer verständlich finden. Falls das so ist, studieren Sie die Beispiele sorgfältig und probieren Sie einige von ihnen selbst aus.
    Eine Fiber besitzt einen Rumpf mit Code, genau wie ein Thread. Erzeugen Sie eine Fiber mit
Fiber.new
und verknüpfen Sie einen Block mit ihr, um den Code anzugeben, den sie ausführen soll. Anders als ein Thread beginnt der Rumpf einer Fiber nicht sofort mit der Ausführung. Um eine Fiber auszuführen, rufen Sie die Methode
resume
des Fiber-Objekts auf, das sie repräsentiert. Beim ersten Aufruf von
resume
für eine Fiber wird die Kontrolle an den Beginn des Fiber-Rumpfs übertragen. Die Fiber wird dann ausgeführt, bis sie das Ende des Rumpfs erreicht oder bis sie die Methode
Fiber.yield
ausführt. Die Methode
Fiber.yield
übergibt die Kontrolle zurück an die aufrufende Stelle und lässt den Aufruf von
resume
zurückkehren. Sie speichert außerdem den Zustand der Fiber, so dass der nächste Aufruf von
resume
die Fiber dort weitermachen lässt, wo sie aufgehört hat. Hier sehen Sie ein einfaches Beispiel:
f = Fiber.new { # Zeile 1: Eine neue Fiber erzeugen
puts "Fiber sagt Hallo" # Zeile 2:
Fiber.yield # Zeile 3: Sprung zu Zeile 9
puts "Fiber sagt Tschüss" # Zeile 4:
} # Zeile 5: Sprung zu Zeile 11
     # Zeile 6:
puts "Aufrufende