ruby concurrency parallelism ractors async threads fibers

Concurrent Ruby with Ractors and Async

Sarah Mitchell Feb 2026

2 tabs

# Basic Ractor usage
ractor = Ractor.new do
  # This runs in parallel, isolated from main thread
  result = heavy_computation
  result
end

# Wait for result
result = ractor.take  # Blocks until ractor finishes

# Passing data to ractors
ractor = Ractor.new(10) do |n|
  n ** 2
end

ractor.take  # => 100

# Communication via messages
ractor = Ractor.new do
  loop do
    message = Ractor.receive
    puts "Received: #{message}"

    break if message == :stop
  end
end

ractor.send("Hello")
ractor.send("World")
ractor.send(:stop)

# Parallel processing with multiple ractors
def parallel_map(array)
  ractors = array.map do |item|
    Ractor.new(item) do |value|
      # CPU-intensive operation
      expensive_computation(value)
    end
  end

  ractors.map(&:take)
end

results = parallel_map([1, 2, 3, 4, 5])

# Worker pool pattern
class RactorPool
  def initialize(size)
    @queue = Ractor.new do
      jobs = []
      loop do
        Ractor.yield(jobs.shift) while jobs.any?
        jobs << Ractor.receive
      end
    end

    @workers = size.times.map do
      Ractor.new(@queue) do |queue|
        loop do
          job = queue.take
          result = job.call
          Ractor.yield(result)
        end
      end
    end
  end

  def submit(job)
    @queue.send(job)
  end

  def results
    @workers.map { |w| w.take }
  end
end

pool = RactorPool.new(4)
10.times { |i| pool.submit(-> { i ** 2 }) }
pool.results

# Ractor limitations (by design for safety)
# Cannot share mutable objects
data = "hello"
Ractor.new(data) do |str|
  str.upcase!  # Error! Cannot modify shared object
end

# Must freeze or copy data
data = "hello".freeze
Ractor.new(data) do |str|
  str.upcase  # OK - frozen string
end

# Only shareable objects can be passed:
# - Immutable objects (numbers, symbols, true, false, nil)
# - Frozen objects
# - Ractor objects themselves
# - Classes/modules

# Async gem for structured concurrency
require 'async'

# Basic async task
Async do
  puts "Hello"
  sleep 1
  puts "World"
end

# Concurrent HTTP requests
require 'async/http/internet'

Async do
  internet = Async::HTTP::Internet.new

  # Make requests concurrently
  responses = Async do |task|
    [
      task.async { internet.get("https://api1.example.com/data") },
      task.async { internet.get("https://api2.example.com/data") },
      task.async { internet.get("https://api3.example.com/data") }
    ].map(&:wait)
  end

  responses.each do |response|
    puts response.read
  end
ensure
  internet&.close
end

# Thread basics
threads = 5.times.map do |i|
  Thread.new do
    sleep rand
    puts "Thread #{i} finished"
  end
end

threads.each(&:join)  # Wait for all threads

# Thread-safe counter with Mutex
class Counter
  def initialize
    @count = 0
    @mutex = Mutex.new
  end

  def increment
    @mutex.synchronize do
      @count += 1
    end
  end

  def value
    @mutex.synchronize { @count }
  end
end

counter = Counter.new

threads = 100.times.map do
  Thread.new do
    100.times { counter.increment }
  end
end

threads.each(&:join)
counter.value  # => 10000 (thread-safe!)

# Concurrent-ruby primitives
require 'concurrent'

# Atomic counter
counter = Concurrent::AtomicFixnum.new(0)
threads = 100.times.map do
  Thread.new { 100.times { counter.increment } }
end
threads.each(&:join)
counter.value  # => 10000

# Thread pool
pool = Concurrent::FixedThreadPool.new(5)

10.times do |i|
  pool.post do
    puts "Task #{i} on thread #{Thread.current.object_id}"
    sleep 1
  end
end

pool.shutdown
pool.wait_for_termination

# Future (async computation)
future = Concurrent::Future.execute do
  # Long running computation
  sleep 2
  42
end

puts "Doing other work..."

result = future.value  # Blocks until ready
puts "Future result: #{result}"

# Promise (manual fulfillment)
promise = Concurrent::Promise.new do |value|
  value * 2
end

Thread.new do
  sleep 1
  promise.execute(21)
end

promise.value  # => 42

# Actor pattern
class Counter
  include Concurrent::Async

  def initialize
    @count = 0
    super()
  end

  def increment
    @count += 1
  end

  def value
    @count
  end
end

counter = Counter.new
100.times { counter.async.increment }
sleep 0.1
counter.value  # Thread-safe!

# Concurrent map
results = Concurrent::Promise.zip(
  *[1, 2, 3, 4, 5].map { |i|
    Concurrent::Promise.execute { expensive_operation(i) }
  }
).value

2 files · ruby Explain with highlit

Ruby 3+ introduces Ractors for true parallelism without GIL limitations. Ractors are isolated actors—no shared mutable state. I use Ractors for CPU-intensive parallel processing. Messages pass between Ractors via send and receive. Async gem provides structured concurrency—fibers for non-blocking I/O. Concurrent-ruby gem offers thread-safe primitives—Atomic, ThreadPool, Future, Promise. Understanding Ruby's GIL limits thread parallelism helps choose right concurrency tool. Ractors excel for parallel computations; fibers for I/O concurrency. Thread safety requires careful synchronization. Mutex guards shared state. Testing concurrent code needs deterministic fixtures. Concurrency unlocks Ruby's full CPU potential.