When it comes to juggling multiple tasks in Ruby, one of the most underrated yet powerful tools is the Fiber class. Fibers are something like the Swiss Army knife for non-blocking operations, making them perfect for situations where you have to deal with a lot of input/output (I/O) or other asynchronous operations.

Concurrency vs. Parallelism

First things first, let’s clear up the difference between concurrency and parallelism. Concurrency is when a program handles multiple tasks at once but not necessarily at the same instant. Think of it like multitasking on your computer. Parallelism, on the other hand, is when multiple tasks are actually happening at the same time, requiring multiple CPU cores.

Even if you’re on a single-core machine, Ruby allows you to achieve concurrency. But for parallelism, you need multiple cores. This is where fibers come in handy.

Getting to Know Fibers

Fibers are lightweight entities that can be stopped and started at will. Unlike threads, which are a bit more heavyweight and managed by the operating system, fibers are controlled by you, the programmer. This makes them super-efficient and predictable. They’re perfect for multitasking situations where you need fine-grained control.

Making and Using Fibers

Creating a fiber in Ruby is as easy as pie. You just use the Fiber.new method and pass in a block of code to execute. But remember, fibers don’t just kick off on their own; you have to explicitly start them with the Fiber#resume method.

fiber = Fiber.new do
  puts "Inside the fiber"
  Fiber.yield
  puts "Resumed fiber"
end

fiber.resume # Output: Inside the fiber
fiber.resume # Output: Resumed fiber

Here’s the deal with this example: We make a fiber that does nothing until we say so. It prints a message, then hits pause using Fiber.yield. When we resume it, the fiber continues from where it left off.

Pausing and Continuing Fibers

Want to stop a fiber? Simple, just use the Fiber.yield method. This returns control to the main thread, letting other fibers or tasks do their thing. And when you’re ready, just resume the fiber to pick up where it paused.

fiber = Fiber.new do
  5.times do
    puts "Inside the fiber"
    Fiber.yield
  end
end

5.times do
  fiber.resume
end

In this snippet, the fiber runs five times and yields each time. This allows efficient switching between tasks without the need to juggle threads.

Creating Loops and Sequences with Fibers

Fibers can even help you build infinite loops or sequences without causing program lockups. By using Fiber.yield, you can create a nonstop-running fiber that gives control back to the main thread after every round.

fib = Fiber.new do
  x, y = 0, 1
  loop do
    Fiber.yield y
    x, y = y, x + y
  end
end

10.times do
  puts fib.resume
end

This example spins up a fiber generating Fibonacci numbers. Each time you call fib.resume, you get the next number in the sequence, while the main thread remains unblocked and happy.

Fibers for Async I/O

One of the most exciting uses for fibers is handling asynchronous I/O operations efficiently. By isolating I/O tasks from the main thread, fibers keep your program from getting stuck waiting on I/O.

require "open-uri"

fibers = 5.times.map do
  Fiber.new do
    delay = (rand * 20).fdiv(10)
    URI.open("https://httpbin.org/delay/#{delay}")
    puts "Done with delay #{delay}"
  end
end

fibers.each(&:resume)

In this script, multiple fibers handle I/O operations without blocking the main thread. Each fiber makes an HTTP request with a random delay, ensuring that the program keeps running smoothly.

Advanced Fiber Scheduling

Sometimes, you need something more sophisticated, like a scheduler to manage your fibers. A scheduler can ensure that your fibers run concurrently without stepping on each other’s toes.

require "fiber_scheduler"

queue = Queue.new
Fiber.set_scheduler FiberScheduler.new

5.times do |i|
  Fiber.schedule do
    delay = (rand * 20).fdiv(10)
    URI.open("https://httpbin.org/delay/#{delay}")
    puts "Done #{i} with delay #{delay}"
    queue << "."
  end
end

Fiber.schedule do
  5.times do
    queue.pop
  end
  puts "All 5 requests are done"
end

Here, a fiber scheduler handles the execution of multiple fibers. Each fiber performs an I/O task, and the scheduler ensures all fibers run concurrently, boosting performance.

The Takeaway

Ruby’s Fiber class is an absolute gem for managing lightweight concurrency, especially with non-blocking operations. Knowing how to create, manage, and schedule fibers can lead to more efficient and scalable Ruby code. Whether you’re dealing with I/O-heavy tasks or other async operations, fibers offer a flexible and effective way to achieve concurrency without the complications of threads or processes. With the right approach, you can tap into the full potential of fibers to supercharge your Ruby applications, making them faster and more responsive.