In Files

  • ractor.c
  • ractor.rb

Class/Module Index [+]



Ractor is a Actor-model abstraction for Ruby that provides thread-safe parallel execution.

::new can make new Ractor and it will run in parallel.

# The simplest ractor
r = {puts "I am in Ractor!"}
r.take # wait it to finish
# here "I am in Ractor!" would be printed

Ractors do not share usual objects, so the some kind of thread-safety concerns such as data-race, race-conditions are not available on multi-ractor programming.

To achieve this, ractors severely limit object sharing between different ractors. For example, unlike threads, ractors can’t access each other’s objects, nor any objects through variables of the outer scope.

a = 1
r = {puts "I am in Ractor! a=#{a}"}
# fails immediately with
# ArgumentError (can not isolate a Proc because it accesses outer variables (a).)

On CRuby (the default implementation), Global Virtual Machine Lock (GVL) is held per ractor, so ractors are performed in parallel without locking each other.

Instead of accessing the shared state, the objects should be passed to and from ractors via sending and receiving objects as messages.

a = 1
r = do
  a_in_ractor = receive # receive blocks till somebody will pass message
  puts "I am in Ractor! a=#{a_in_ractor}"
r.send(a)  # pass it
# here "I am in Ractor! a=1" would be printed

There are two pairs of methods for sending/receiving messages:

  • Object#send and ::receive for when the sender knows the receiver (push);

  • Ractor.yield and Ractor#take for when the receiver knows the sender (pull);

In addition to that, an argument to ::new would be passed to block and available there as if received by ::receive, and the last block value would be sent outside of the ractor as if sent by Ractor.yield.

A little demonstration on a classic ping-pong:

server = do
  puts "Server starts: #{self.inspect}"
  puts "Server sends: ping"
  Ractor.yield 'ping'                       # The server doesn't know the receiver and sends to whoever interested
  received = Ractor.receive                 # The server doesn't know the sender and receives from whoever sent
  puts "Server received: #{received}"

client = do |srv|        # The server is sent inside client, and available as srv
  puts "Client starts: #{self.inspect}"
  received = srv.take                       # The Client takes a message specifically from the server
  puts "Client received from "         "#{srv.inspect}: #{received}"
  puts "Client sends to "         "#{srv.inspect}: pong"
  srv.send 'pong'                           # The client sends a message specifically to the server

[client, server].each(&:take)               # Wait till they both finish

This will output:

Server starts: #<Ractor:#2 test.rb:1 running>
Server sends: ping
Client starts: #<Ractor:#3 test.rb:8 running>
Client received from #<Ractor:#2 rac.rb:1 blocking>: ping
Client sends to #<Ractor:#2 rac.rb:1 blocking>: pong
Server received: pong

It is said that Ractor receives messages via the incoming port, and sends them to the outgoing port. Either one can be disabled with Ractor#close_incoming and Ractor#close_outgoing respectively. If a ractor terminated, its ports will be closed automatically.

Shareable and unshareable objects

When the object is sent to and from the ractor, it is important to understand whether the object is shareable or unshareable. Most of objects are unshareable objects.

Shareable objects are basically those which can be used by several threads without compromising thread-safety; e.g. immutable ones. Ractor.shareable? allows to check this, and Ractor.make_shareable tries to make object shareable if it is not.

Ractor.shareable?(1)            #=> true -- numbers and other immutable basic values are
Ractor.shareable?('foo')        #=> false, unless the string is frozen due to # freeze_string_literals: true
Ractor.shareable?('foo'.freeze) #=> true

ary = ['hello', 'world']
ary.frozen?                 #=> false
ary[0].frozen?              #=> false
ary.frozen?                 #=> true
ary[0].frozen?              #=> true
ary[1].frozen?              #=> true

When a shareable object is sent (via send or Ractor.yield), no additional processing happens, and it just becomes usable by both ractors. When an unshareable object is sent, it can be either copied or moved. The first is the default, and it makes the object’s full copy by deep cloning of non-shareable parts of its structure.

data = ['foo', 'bar'.freeze]
r = do
  data2 = Ractor.receive
  puts "In ractor: #{data2.object_id}, #{data2[0].object_id}, #{data2[1].object_id}"
puts "Outside  : #{data.object_id}, #{data[0].object_id}, #{data[1].object_id}"

This will output:

In ractor: 340, 360, 320
Outside  : 380, 400, 320

(Note that object id of both array and non-frozen string inside array have changed inside the ractor, showing it is different objects. But the second array’s element, which is a shareable frozen string, has the same object_id.)

Deep cloning of the objects may be slow, and sometimes impossible. Alternatively, move: true may be used on sending. This will move the object to the receiving ractor, making it inaccessible for a sending ractor.

data = ['foo', 'bar']
r = do
  data_in_ractor = Ractor.receive
  puts "In ractor: #{data_in_ractor.object_id}, #{data_in_ractor[0].object_id}"
r.send(data, move: true)
puts "Outside: moved? #{Ractor::MovedObject === data}"
puts "Outside: #{data.inspect}"

This will output:

In ractor: 100, 120
Outside: moved? true
test.rb:9:in `method_missing': can not send any methods to a moved object (Ractor::MovedError)

Notice that even inspect (and more basic methods like __id__) is inaccessible on a moved object.

Besides frozen objects, there are shareable objects. Class and Module objects are shareable so the Class/Module definitons are shared between ractors. Ractor objects are also shareable objects. All operations for the shareable mutable objects are thread-safe, so the thread-safety property will be kept. We can not define mutable shareable objects in Ruby, but C extensions can introduce them.

It is prohibited to access instance variables of mutable shareable objects (especially Modules and classes) from ractors other than main:

class C
  class << self
    attr_accessor :tricky

C.tricky = 'test'

r = do |cls|
  puts "I see #{cls}"
  puts "I can't see #{cls.tricky}"
# I see C
# can not access instance variables of classes/modules from non-main Ractors (RuntimeError)

Ractors can access constants if they are shareable. The main Ractor is the only one that can access non-shareable constants.

GOOD = 'good'.freeze
BAD = 'bad'

r = do
  puts "GOOD=#{GOOD}"
  puts "BAD=#{BAD}"
# GOOD=good
# can not access non-shareable objects in constant Object::BAD by non-main Ractor. (NameError)

# Consider the same C class from above

r = do
  puts "I see #{C}"
  puts "I can't see #{C.tricky}"
# I see C
# can not access instance variables of classes/modules from non-main Ractors (RuntimeError)

See also the description of # shareable_constant_value pragma in Comments syntax explanation.

Ractors vs threads

Each ractor creates its own thread. New threads can be created from inside ractor (and, on CRuby, sharing GVL with other threads of this ractor).

r = do
  a = 1 {puts "Thread in ractor: a=#{a}"}.join
# Here "Thread in ractor: a=1" will be printed

Note on code examples

In examples below, sometimes we use the following method to wait till ractors that are not currently blocked will finish (or process till next blocking) method.

def wait

It is **only for demonstration purposes** and shouldn’t be used in a real code. Most of the times, just take is used to wait till ractor will finish.


See Ractor desgin doc for more details.

Public Class Methods

count() click to toggle source

Returns total count of Ractors currently running.

Ractor.count                   #=> 1
r = 'example') { Ractor.yield(1) }
Ractor.count                   #=> 2 (main + example ractor)
r.take                         # wait for Ractor.yield(1)
r.take                         # wait till r will finish
Ractor.count                   #=> 1
               # File ractor.rb, line 287
def self.count
  __builtin_cexpr! %q{
current() click to toggle source

Returns the currently executing Ractor.

Ractor.current #=> #<Ractor:#1 running>
               # File ractor.rb, line 273
def self.current
  __builtin_cexpr! %q{
new(*args, name: nil) {|*args| block } → ractor click to toggle source

Create a new Ractor with args and a block.

A block (Proc) will be isolated (can’t access to outer variables). self inside the block will refer to the current Ractor.

r = { puts "Hi, I am #{self.inspect}" }
# Prints "Hi, I am #<Ractor:#2 test.rb:1 running>"

args passed to the method would be propagated to block args by the same rules as objects passed through send/Ractor.receive: if args are not shareable, they will be copied (via deep cloning, which might be inefficient).

arg = [1, 2, 3]
puts "Passing: #{arg} (##{arg.object_id})"
r = {|received_arg|
  puts "Received: #{received_arg} (##{received_arg.object_id})"
# Prints:
#   Passing: [1, 2, 3] (#280)
#   Received: [1, 2, 3] (#300)

Ractor’s name can be set for debugging purposes:

r = 'my ractor') {}
p r
#=> #<Ractor:#3 my ractor test.rb:1 terminated>
               # File ractor.rb, line 262
def*args, name: nil, &block)
  b = block # TODO: builtin bug
  raise ArgumentError, "must be called with a block" unless block
  loc = caller_locations(1, 1).first
  loc = "#{loc.path}:#{loc.lineno}"
  __builtin_ractor_create(loc, name, args, b)
receive → msg click to toggle source

Receive an incoming message from the current Ractor’s incoming port’s queue, which was sent there by send.

r = do
  v1 = Ractor.receive
  puts "Received: #{v1}"
# Here will be printed: "Received: message1"

Alternatively, private instance method receive may be used:

r = do
  v1 = receive
  puts "Received: #{v1}"
# Here will be printed: "Received: message1"

The method blocks if the queue is empty.

r = do
  puts "Before first receive"
  v1 = Ractor.receive
  puts "Received: #{v1}"
  v2 = Ractor.receive
  puts "Received: #{v2}"
puts "Still not received"
puts "Still received only one"


Before first receive
Still not received
Received: message1
Still received only one
Received: message2

If close_incoming was called on the ractor, the method raises Ractor::ClosedError if there are no more messages in incoming queue: do
# in `receive': The incoming port is already closed => #<Ractor:#2 test.rb:1 running> (Ractor::ClosedError)
               # File ractor.rb, line 415
def self.receive
  __builtin_cexpr! %q{
    ractor_receive(ec, rb_ec_ractor_ptr(ec))
Also aliased as: recv
recv() click to toggle source
Alias for: receive
select(*ractors, [yield_value:, move: false]) → [ractor or symbol, obj] click to toggle source

Waits for the first ractor to have something in its outgoing port, reads from this ractor, and returns that ractor and the object received.

r1 = {Ractor.yield 'from 1'}
r2 = {Ractor.yield 'from 2'}

r, obj =, r2)

puts "received #{obj.inspect} from #{r.inspect}"
# Prints: received "from 1" from #<Ractor:#2 test.rb:1 running>

If one of the given ractors is the current ractor, and it would be selected, r will contain :receive symbol instead of the ractor object.

r1 = do |main|
  main.send 'to main'
  Ractor.yield 'from 1'
r2 = do
  Ractor.yield 'from 2'

r, obj =, r2, Ractor.current)
puts "received #{obj.inspect} from #{r.inspect}"
# Prints: received "to main" from :receive

If yield_value is provided, that value may be yielded if another Ractor is calling take. In this case, the pair [:yield, nil] would be returned:

r1 = do |main|
  puts "Received from main: #{main.take}"

puts "Trying to select"
r, obj =, Ractor.current, yield_value: 123)
puts "Received #{obj.inspect} from #{r.inspect}"

This will print:

Trying to select
Received from main: 123
Received nil from :yield

move boolean flag defines whether yielded value should be copied (default) or moved.

               # File ractor.rb, line 342
def*ractors, yield_value: yield_unspecified = true, move: false)
  raise ArgumentError, 'specify at least one ractor or `yield_value`' if yield_unspecified && ractors.empty?

  __builtin_cstmt! %q{
    const VALUE *rs = RARRAY_CONST_PTR_TRANSIENT(ractors);
    VALUE rv;
    VALUE v = ractor_select(ec, rs, RARRAY_LENINT(ractors),
                            yield_unspecified == Qtrue ? Qundef : yield_value,
                            (bool)RTEST(move) ? true : false, &rv);
    return rb_ary_new_from_args(2, rv, v);