class Fiber

Gibt den Wert der Fiber-Speichervariablen zurück, die durch Schlüssel identifiziert wird.

Der Schlüssel muss ein Symbol sein, und der Wert wird von Fiber#[]= oder Fiber#speicher gesetzt.

Siehe auch Fiber::[]=.

Weist Wert der Fiber-Speichervariablen zu, die durch Schlüssel identifiziert wird. Die Variable wird erstellt, wenn sie nicht existiert.

Schlüssel muss ein Symbol sein, andernfalls wird ein TypeError ausgelöst.

Siehe auch Fiber::[].

Zwingt die Fiber, während der Dauer des Blocks blockierend zu sein. Gibt das Ergebnis des Blocks zurück.

Siehe den Abschnitt "Nicht-blockierende Fibers" in der Klassendokumentation für Details.

Gibt falsch zurück, wenn die aktuelle Fiber nicht blockiert. Eine Fiber ist nicht blockierend, wenn sie durch Übergabe von blocking: false an Fiber.new oder durch Fiber.schedule erstellt wurde.

Wenn die aktuelle Fiber blockiert, gibt die Methode 1 zurück. Zukünftige Entwicklungen könnten Situationen zulassen, in denen größere ganze Zahlen zurückgegeben werden könnten.

Beachten Sie, dass, selbst wenn die Methode falsch zurückgibt, das Verhalten der Fiber nur dann anders ist, wenn Fiber.scheduler im aktuellen Thread gesetzt ist.

Siehe den Abschnitt "Nicht-blockierende Fibers" in der Klassendokumentation für Details.

Gibt die aktuelle Fiber zurück. Wenn Sie sich nicht im Kontext einer Fiber befinden, gibt diese Methode die Root-Fiber zurück.

Gibt den Fiber Scheduler zurück, der zuletzt für den aktuellen Thread mit Fiber.set_scheduler gesetzt wurde, und zwar nur dann, wenn die aktuelle Fiber nicht blockiert.

Erstellt eine neue Fiber. Anfangs läuft die Fiber nicht und kann mit resume fortgesetzt werden. Argumente für den ersten resume Aufruf werden an den Block übergeben.

f = Fiber.new do |initial|
   current = initial
   loop do
     puts "current: #{current.inspect}"
     current = Fiber.yield
   end
end
f.resume(100)     # prints: current: 100
f.resume(1, 2, 3) # prints: current: [1, 2, 3]
f.resume          # prints: current: nil
# ... and so on ...

Wenn blocking: false an Fiber.new übergeben wird und der aktuelle Thread einen definierten Fiber.scheduler hat, wird die Fiber nicht-blockierend (siehe Abschnitt "Nicht-blockierende Fibers" in der Klassendokumentation).

Wenn storage nicht angegeben ist, wird standardmäßig eine Kopie des Speichers von der aktuellen Fiber übernommen. Dies ist dasselbe wie storage: true.

Fiber[:x] = 1
Fiber.new do
  Fiber[:x] # => 1
  Fiber[:x] = 2
end.resume
Fiber[:x] # => 1

Wenn der angegebene storage nil ist, initialisiert diese Funktion den internen Speicher verzögert, der als leeres Hash beginnt.

Fiber[:x] = "Hello World"
Fiber.new(storage: nil) do
  Fiber[:x] # nil
end

Andernfalls wird der angegebene storage als Speicher der neuen Fiber verwendet, und er muss eine Instanz von Hash sein.

Die explizite Verwendung von storage: true ist derzeit experimentell und kann sich in Zukunft ändern.

Die Methode soll den bereitgestellten Codeblock sofort in einer separaten, nicht-blockierenden Fiber ausführen.

puts "Go to sleep!"

Fiber.set_scheduler(MyScheduler.new)

Fiber.schedule do
  puts "Going to sleep"
  sleep(1)
  puts "I slept well"
end

puts "Wakey-wakey, sleepyhead"

Unter der Annahme, dass MyScheduler ordnungsgemäß implementiert ist, wird dieses Programm Folgendes erzeugen:

Go to sleep!
Going to sleep
Wakey-wakey, sleepyhead
...1 sec pause here...
I slept well

... z. B. bei der ersten blockierenden Operation innerhalb der Fiber (sleep(1)) wird die Kontrolle an den externen Code (Haupt-Fiber) übergeben, und *am Ende dieser Ausführung* kümmert sich der Scheduler ordnungsgemäß um das Fortsetzen aller blockierten Fibers.

Beachten Sie, dass das beschriebene Verhalten das ist, was die Methode *erwartet* zu tun; das tatsächliche Verhalten hängt von der Implementierung der Methode Fiber::Scheduler#fiber durch den aktuellen Scheduler ab. Ruby erzwingt nicht, dass diese Methode sich in irgendeiner bestimmten Weise verhält.

Wenn der Scheduler nicht gesetzt ist, löst die Methode RuntimeError (Kein Scheduler verfügbar!) aus.

Gibt den Fiber Scheduler zurück, der zuletzt für den aktuellen Thread mit Fiber.set_scheduler gesetzt wurde. Gibt nil zurück, wenn kein Scheduler gesetzt ist (was der Standard ist), und das Verhalten nicht-blockierender Fibers ist dasselbe wie bei blockierenden. (Siehe Abschnitt "Nicht-blockierende Fibers" in der Klassendokumentation für Details zum Scheduler-Konzept).

Setzt den Fiber Scheduler für den aktuellen Thread. Wenn der Scheduler gesetzt ist, rufen nicht-blockierende Fibers (erstellt von Fiber.new mit blocking: false oder von Fiber.schedule) die Hook-Methoden des Schedulers bei potenziell blockierenden Operationen auf, und der aktuelle Thread ruft die close-Methode des Schedulers bei der Finalisierung auf (was es dem Scheduler ermöglicht, alle nicht abgeschlossenen Fibers ordnungsgemäß zu verwalten).

scheduler kann ein Objekt einer beliebigen Klasse sein, die Fiber::Scheduler entspricht. Seine Implementierung liegt beim Benutzer.

Siehe auch den Abschnitt "Nicht-blockierende Fibers" in der Klassendokumentation.

Gibt die Kontrolle an den Kontext zurück, der die Fiber fortgesetzt hat, und übergibt alle Argumente, die an sie übergeben wurden. Die Fiber wird an diesem Punkt die Verarbeitung fortsetzen, wenn resume das nächste Mal aufgerufen wird. Alle Argumente, die an das nächste resume übergeben werden, sind der Wert, zu dem dieser Fiber.yield Ausdruck ausgewertet wird.

Gibt true zurück, wenn die Fiber noch fortgesetzt (oder übertragen) werden kann. Nach Abschluss der Ausführung des Fiber-Blocks gibt diese Methode immer falsch zurück.

Gibt den aktuellen Ausführungsstack der Fiber zurück. start, count und end erlauben die Auswahl nur von Teilen des Backtrace.

def level3
  Fiber.yield
end

def level2
  level3
end

def level1
  level2
end

f = Fiber.new { level1 }

# It is empty before the fiber started
f.backtrace
#=> []

f.resume

f.backtrace
#=> ["test.rb:2:in `yield'", "test.rb:2:in `level3'", "test.rb:6:in `level2'", "test.rb:10:in `level1'", "test.rb:13:in `block in <main>'"]
p f.backtrace(1) # start from the item 1
#=> ["test.rb:2:in `level3'", "test.rb:6:in `level2'", "test.rb:10:in `level1'", "test.rb:13:in `block in <main>'"]
p f.backtrace(2, 2) # start from item 2, take 2
#=> ["test.rb:6:in `level2'", "test.rb:10:in `level1'"]
p f.backtrace(1..3) # take items from 1 to 3
#=> ["test.rb:2:in `level3'", "test.rb:6:in `level2'", "test.rb:10:in `level1'"]

f.resume

# It is nil after the fiber is finished
f.backtrace
#=> nil

Wie backtrace, gibt aber jede Zeile des Ausführungsstacks als Thread::Backtrace::Location zurück. Akzeptiert die gleichen Argumente wie backtrace.

f = Fiber.new { Fiber.yield }
f.resume
loc = f.backtrace_locations.first
loc.label  #=> "yield"
loc.path   #=> "test.rb"
loc.lineno #=> 1

Gibt true zurück, wenn fiber blockiert, und falsch andernfalls. Eine Fiber ist nicht blockierend, wenn sie durch Übergabe von blocking: false an Fiber.new oder durch Fiber.schedule erstellt wurde.

Beachten Sie, dass, selbst wenn die Methode falsch zurückgibt, das Verhalten der Fiber nur dann anders ist, wenn Fiber.scheduler im aktuellen Thread gesetzt ist.

Siehe den Abschnitt "Nicht-blockierende Fibers" in der Klassendokumentation für Details.

Beendet die Fiber, indem eine nicht abfangbare Ausnahme ausgelöst wird. Sie beendet nur die gegebene Fiber und keine andere Fiber, und gibt nil an eine andere Fiber zurück, wenn diese Fiber resume oder transfer aufgerufen hat.

Fiber#kill unterbricht eine andere Fiber nur, wenn sie sich in Fiber.yield befindet. Wenn sie auf die aktuelle Fiber angewendet wird, löst sie diese Ausnahme an der Aufrufstelle von Fiber#kill aus.

Wenn die Fiber noch nicht gestartet wurde, geht sie direkt in den beendeten Zustand über.

Wenn die Fiber bereits beendet ist, tut sie nichts.

Löst FiberError aus, wenn sie auf eine Fiber eines anderen Threads angewendet wird.

Löst eine Ausnahme in der Fiber an der Stelle aus, an der der letzte Fiber.yield aufgerufen wurde.

f = Fiber.new {
  puts "Before the yield"
  Fiber.yield 1 # -- exception will be raised here
  puts "After the yield"
}

p f.resume
f.raise "Gotcha"

Ausgabe

Before the first yield
1
t.rb:8:in 'Fiber.yield': Gotcha (RuntimeError)
  from t.rb:8:in 'block in <main>'

Wenn die Fiber nicht gestartet wurde oder bereits abgeschlossen ist, wird FiberError ausgelöst. Wenn die Fiber yieldet, wird sie fortgesetzt. Wenn sie transferiert, wird sie hinein transferiert. Wenn sie aber resume wird, wird FiberError ausgelöst.

Löst FiberError aus, wenn sie auf eine Fiber eines anderen Thread angewendet wird.

Siehe Kernel#raise für weitere Informationen zu Argumenten.

Setzt die Fiber ab dem Punkt fort, an dem der letzte Fiber.yield aufgerufen wurde, oder startet sie, wenn dies der erste Aufruf von resume ist. An resume übergebene Argumente sind der Wert des Fiber.yield-Ausdrucks oder werden als Blockparameter an den Block der Fiber übergeben, wenn dies das erste resume ist.

Alternativ wird resume, wenn es aufgerufen wird, zu den Argumenten ausgewertet, die an die nächste Fiber.yield-Anweisung innerhalb des Fiber-Blocks übergeben werden, oder zum Blockwert, wenn er ohne Fiber.yield abgeschlossen wird.

Gibt eine Kopie des Speichers-Hash für die Fiber zurück. Die Methode kann nur auf die Fiber.current angewendet werden.

Setzt den Speicher-Hash für die Fiber. Dieses Feature ist experimentell und kann sich in Zukunft ändern. Die Methode kann nur auf die Fiber.current angewendet werden.

Sie sollten vorsichtig mit der Verwendung dieser Methode sein, da Sie möglicherweise versehentlich wichtige Fiber-Speicherzustände löschen. Sie sollten vorzugsweise bestimmte Schlüssel im Speicher mit Fiber::[]= zuweisen.

Sie können auch Fiber.new(storage: nil) verwenden, um eine Fiber mit einem leeren Speicher zu erstellen.

Beispiel

while request = request_queue.pop
  # Reset the per-request state:
  Fiber.current.storage = nil
  handle_request(request)
end

Überträgt die Kontrolle an eine andere Fiber, setzt sie dort fort, wo sie zuletzt angehalten hat, oder startet sie, wenn sie noch nicht fortgesetzt wurde. Die aufrufende Fiber wird wie bei einem Aufruf von Fiber.yield suspendiert.

Die Fiber, die den Transferaufruf empfängt, behandelt ihn ähnlich wie einen Resume-Aufruf. An transfer übergebene Argumente werden wie an resume übergebene Argumente behandelt.

Die beiden Arten der Steuerung zwischen Fiber (eine ist resume und Fiber::yield, die andere ist transfer zu und von Fiber) können nicht frei gemischt werden.

• Wenn der Lebenszyklus der Fiber mit transfer begonnen hat, kann sie niemals yielden oder die Kontrolle zurückerhalten, sondern nur beenden oder zurücktransferieren. (Sie kann immer noch andere Fibers fortsetzen, die fortgesetzt werden dürfen.)

• Wenn der Lebenszyklus der Fiber mit resume begonnen hat, kann sie an eine andere Fiber transferieren oder yielden, kann aber die Kontrolle nur auf die Weise zurückerhalten, die mit der Art und Weise kompatibel ist, wie sie weggegeben wurde: Wenn sie transferiert hat, kann sie nur zurücktransferiert werden, und wenn sie yieldet hat, kann sie nur zurück resumed werden. Danach kann sie wieder transferieren oder yielden.

Wenn diese Regeln gebrochen werden, wird FiberError ausgelöst.

Für das Design einer einzelnen Fiber ist yield/resume einfacher zu verwenden (die Fiber gibt einfach die Kontrolle ab, sie muss nicht darüber nachdenken, an wen die Kontrolle gegeben wird), während transfer flexibler für komplexe Fälle ist und den Aufbau beliebiger Graphen voneinander abhängiger Fibers ermöglicht.

Beispiel

manager = nil # For local var to be visible inside worker block

# This fiber would be started with transfer
# It can't yield, and can't be resumed
worker = Fiber.new { |work|
  puts "Worker: starts"
  puts "Worker: Performed #{work.inspect}, transferring back"
  # Fiber.yield     # this would raise FiberError: attempt to yield on a not resumed fiber
  # manager.resume  # this would raise FiberError: attempt to resume a resumed fiber (double resume)
  manager.transfer(work.capitalize)
}

# This fiber would be started with resume
# It can yield or transfer, and can be transferred
# back or resumed
manager = Fiber.new {
  puts "Manager: starts"
  puts "Manager: transferring 'something' to worker"
  result = worker.transfer('something')
  puts "Manager: worker returned #{result.inspect}"
  # worker.resume    # this would raise FiberError: attempt to resume a transferring fiber
  Fiber.yield        # this is OK, the fiber transferred from and to, now it can yield
  puts "Manager: finished"
}

puts "Starting the manager"
manager.resume
puts "Resuming the manager"
# manager.transfer  # this would raise FiberError: attempt to transfer to a yielding fiber
manager.resume

ergibt

Starting the manager
Manager: starts
Manager: transferring 'something' to worker
Worker: starts
Worker: Performed "something", transferring back
Manager: worker returned "Something"
Resuming the manager
Manager: finished