class Fiber

• Fiber
• Reference
• Object

Overview

A Fiber is a light-weight execution unit managed by the Crystal runtime.

It is conceptually similar to an operating system thread but with less overhead and completely internal to the Crystal process. The runtime includes a scheduler which schedules execution of fibers.

A Fiber has a stack size of 8 MiB which is usually also assigned to an operating system thread. But only 4KiB are actually allocated at first so the memory footprint is very small.

Communication between fibers is usually passed through Channel.

Cooperative

Fibers are cooperative. That means execution can only be drawn from a fiber when it offers it. It can't be interrupted in its execution at random. In order to make concurrency work, fibers must make sure to occasionally provide hooks for the scheduler to swap in other fibers. IO operations like reading from a file descriptor are natural implementations for this and the developer does not need to take further action on that. When IO access can't be served immediately by a buffer, the fiber will automatically wait and yield execution. When IO is ready it's going to be resumed through the event loop.

When a computation-intensive task has none or only rare IO operations, a fiber should explicitly offer to yield execution from time to time using Fiber.yield to break up tight loops. The frequency of this call depends on the application and concurrency model.

Event loop

The event loop is responsible for keeping track of sleeping fibers waiting for notifications that IO is ready or a timeout reached. When a fiber can be woken, the event loop enqueues it in the scheduler

Defined in:

Constructors

• .current : Fiber

  Returns the current fiber.

• .new(name : String | Nil = nil, &proc : -> )

  Creates a new Fiber instance.

Class Method Summary

• .cancel_timeout : Nil
• .suspend : Nil

  Suspends execution of the current fiber indefinitely.

• .timeout(timeout : Time::Span, select_action : Channel::TimeoutAction) : Nil

  The current fiber will resume after a period of time.

• .yield : Nil

  Yields to the scheduler and allows it to swap execution to other waiting fibers.

Instance Method Summary

• #dead? : Bool

  The fiber's proc has terminated, and the fiber is now considered dead.

• #enqueue : Nil

  Adds this fiber to the scheduler's runnables queue for the current thread.

• #inspect(io : IO) : Nil

  Appends a String representation of this object which includes its class name, its object address and the values of all instance variables.

• #name : String | Nil

  The name of the fiber, used as internal reference.

• #name=(name : String | Nil)

  The name of the fiber, used as internal reference.

• #resumable? : Bool

  The fiber's proc is currently not running and fully saved its context.

• #resume : Nil

  Immediately resumes execution of this fiber.

• #running? : Bool

  The fiber's proc is currently running or didn't fully save its context.

• #to_s(io : IO) : Nil

  Appends a short String representation of this object which includes its class name and its object address.

Constructor Detail

Class Method Detail

counter = 0
spawn name: "status" do
  loop do
    puts "Status: #{counter}"
    sleep(2.seconds)
  end
end

while counter < Int32::MAX
  counter += 1
  if counter % 1_000_000 == 0
    # Without this, there would never be an opportunity to resume the status fiber
    Fiber.yield
  end
end

Instance Method Detail

class Person
  def initialize(@name : String, @age : Int32)
  end
end

Person.new("John", 32).inspect # => #<Person:0x10fd31f20 @name="John", @age=32>

fiber = Fiber.new do
  puts "in fiber"
end
fiber.resume
puts "never reached"

class Person
  def initialize(@name : String, @age : Int32)
  end
end

Person.new("John", 32).to_s # => #<Person:0x10a199f20>