Fiber

        # Fiber < Object

(from ruby core)
---
Fibers are primitives for implementing light weight cooperative
concurrency in Ruby. Basically they are a means of creating code blocks
that can be paused and resumed, much like threads. The main difference
is that they are never preempted and that the scheduling must be done by
the programmer and not the VM.

As opposed to other stackless light weight concurrency models, each
fiber comes with a stack.  This enables the fiber to be paused from
deeply nested function calls within the fiber block.  See the ruby(1)
manpage to configure the size of the fiber stack(s).

When a fiber is created it will not run automatically. Rather it must be
explicitly asked to run using the Fiber#resume method. The code running
inside the fiber can give up control by calling Fiber.yield in which
case it yields control back to caller (the caller of the Fiber#resume).

Upon yielding or termination the Fiber returns the value of the last
executed expression

For instance:

    fiber = Fiber.new do
      Fiber.yield 1
      2
    end

    puts fiber.resume
    puts fiber.resume
    puts fiber.resume

*produces*

    1
    2
    FiberError: dead fiber called

The Fiber#resume method accepts an arbitrary number of parameters, if it
is the first call to #resume then they will be passed as block
arguments. Otherwise they will be the return value of the call to
Fiber.yield

Example:

    fiber = Fiber.new do |first|
      second = Fiber.yield first + 2
    end

    puts fiber.resume 10
    puts fiber.resume 1_000_000
    puts fiber.resume "The fiber will be dead before I can cause trouble"

*produces*

    12
    1000000
    FiberError: dead fiber called

## Non-blocking Fibers

The concept of *non-blocking fiber* was introduced in Ruby 3.0. A
non-blocking fiber, when reaching a operation that would normally block
the fiber (like `sleep`, or wait for another process or I/O) will yield
control to other fibers and allow the *scheduler* to handle blocking and
waking up (resuming) this fiber when it can proceed.

For a Fiber to behave as non-blocking, it need to be created in
Fiber.new with `blocking: false` (which is the default), and
Fiber.scheduler should be set with Fiber.set_scheduler. If
Fiber.scheduler is not set in the current thread, blocking and
non-blocking fibers' behavior is identical.

Ruby doesn't provide a scheduler class: it is expected to be implemented
by the user and correspond to Fiber::SchedulerInterface.

There is also Fiber.schedule method, which is expected to immediately
perform the given block in a non-blocking manner. Its actual
implementation is up to the scheduler.
---
# Class methods:

    blocking?
    current
    current_scheduler
    new
    schedule
    scheduler
    set_scheduler
    yield

# Instance methods:

    alive?
    backtrace
    backtrace_locations
    blocking?
    inspect
    raise
    resume
    to_s
    transfer