An Introduction To Fibers

You know Thread, but have you heard of his red haired step child? Fiber? Fibers are a new and a note worthy addition to Ruby that appeared with 1.9. They are essentially code blocks that can be paused and resumed. They have to be forced to do so, unlike threads which are well mannered and just step aside when someone is in a hurry. Fibers are not a totally new ideas, they have been known for ages as Coroutines. But how does those fibers work? Let’s start by the canonical example:

f = Fiber.new do 3.times do |i| Fiber.yield i end end puts f.resume #=> 0 puts f.resume #=> 1 puts f.resume #=> 2 puts f.resume #=> Error calling dead fiber

The very first time we called resume, the fiber sprang to life and the loop started, then when it hit Fiber.yield it returned to the caller with the value to the right side of the Fiber.yield (i in this case which is equal to zero in the first iteration). When resume is called again, the fiber continues from where it stopped so the loop continues, i picks the value 1 and then yields it back. This continues till the fiber block is exhausted, at this point, calling resume on the fiber will raise an error.

Fibers can do two way communication

When you resume a fiber, you get the right side of the Fiber.yield statement as a return value. That way the fiber sends us messages or data. The good thing is that we too can send data to the fiber in return. Example:

f = Fiber.new do |x| Fiber.yield x end puts f.resume(7) #=> 7

That is, the value you sent in the first resume was passed to the fiber as the block parameter. Now what about changing the earlier example so we can send data many times to the fiber?

f = Fiber.new do |x| 3.times do |i| Fiber.yield x end end puts f.resume(8) #=> 8 puts f.resume(6) #=> 8 # <span class="caps">WHAT</span>? puts f.resume(7) #=> 8 # <span class="caps">WHAT</span>? WHAT? puts f.resume #=> Error calling dead fiber

What is going on? it keeps spitting crazy 8’s at us even if we change the value we send in resume. It turns out that the block parameter will get bound in the very first call and live with you afterwards. Still, the data you pass in the resume is what the term Fiber.yield x evaluates to. So given this tiny update:

f = Fiber.new do |x| 3.times do |i| x = Fiber.yield x end end puts f.resume(8) #=> 8 puts f.resume(6) #=> 6 puts f.resume(7) #=> 7 puts f.resume #=> Error calling dead fiber

Nice, whenever we call resume with a value, the Fiber.yield x statement evaluates into it. This way we can send messages to the fiber as much as we can get messages from it.

In another article we will explain how fibers can be pooled. We will go through the fiber pool implementation that lives in the NeverBlock library.