класс Ractor

Ractor.new создаёт новый Ractor, который может выполняться параллельно с другими ракторами.

# The simplest ractor
r = Ractor.new {puts "I am in Ractor!"}
r.join # wait for it to finish
# Here, "I am in Ractor!" is printed

Ракторы не разделяют между собой все объекты. Это даёт два основных преимущества: между ракторaми невозможны связанные с безопасностью потоков проблемы, такие как гонки данных и состояния гонки. Другое преимущество — параллелизм.

Для этого обмен объектами между ракторами ограничен. В отличие от потоков, ракторам недоступны все объекты, доступные в других ракторaх. Например, запрещено использовать в разных ракторaх объекты, обычно доступные через переменные во внешней области видимости.

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

Объект необходимо явно сделать общим:

a = 1
r = Ractor.new(a) { |a1| puts "I am in Ractor! a=#{a1}"}

В CRuby (реализации по умолчанию) глобальная блокировка виртуальной машины (GVL) удерживается для каждого рактора, поэтому рактора могут выполняться параллельно. Это отличается от ситуации с потоками в CRuby.

Вместо доступа к общему состоянию объекты следует передавать между ракторами, отправляя и получая их в виде сообщений.

a = 1
r = Ractor.new do
  a_in_ractor = receive # receive blocks the Thread until our default port gets sent a message
  puts "I am in Ractor! a=#{a_in_ractor}"
end
r.send(a)  # pass it
r.join
# Here, "I am in Ractor! a=1" is printed

Кроме того, любые аргументы, переданные в Ractor.new, передаются блоку и доступны в нём так, как если бы они были получены с помощью Ractor.receive, а последнее значение блока можно получить с помощью Ractor#value.

Общие и необщие объекты

При отправке объекта рактору важно понимать, является ли он общим или необщим. Большинство объектов Ruby являются необщими. Даже замороженные объекты могут быть необщими, если они содержат (через переменные экземпляра) незамороженные объекты.

Общие объекты можно одновременно использовать в нескольких ракторaх без ущерба для безопасности потоков, например числа, true и false. Метод Ractor.shareable? позволяет это проверить, а Ractor.make_shareable пытается сделать объект общим, если он ещё не является таковым, и выдаёт ошибку, если это невозможно.

Ractor.shareable?(1)            #=> true -- numbers and other immutable basic values are shareable
Ractor.shareable?('foo')        #=> false, unless the string is frozen due to # frozen_string_literal: true
Ractor.shareable?('foo'.freeze) #=> true
Ractor.shareable?([Object.new].freeze) #=> false, inner object is unfrozen

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

При отправке общего объекта с помощью send дополнительная обработка не выполняется, и объект становится доступен обоим ракторaм. При отправке необщего объекта его можно либо скопировать, либо переместить. По умолчанию объект копируется полностью путём глубокого клонирования (Object#clone) необщих частей его структуры.

data = ['foo'.dup, 'bar'.freeze]
r = Ractor.new do
  data2 = Ractor.receive
  puts "In ractor: #{data2.object_id}, #{data2[0].object_id}, #{data2[1].object_id}"
end
r.send(data)
r.join
puts "Outside  : #{data.object_id}, #{data[0].object_id}, #{data[1].object_id}"

Будет выведено примерно следующее:

In ractor: 8, 16, 24
Outside  : 32, 40, 24

Обратите внимание, что идентификаторы объектов массива и незамороженной строки внутри массива в ракторе изменились, поскольку это другие объекты. Второй элемент массива — общая замороженная строка — остался тем же объектом.

Глубокое клонирование объектов может быть медленным, а иногда и невозможным. Вместо этого при отправке можно использовать move: true. Это переместит необщий объект в принимающий рактор, сделав его недоступным отправляющему рактору.

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

Будет выведено:

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

Обратите внимание, что даже inspect и более простые методы, такие как __id__, недоступны для перемещённого объекта.

Объекты Class и Module являются общими, а определения их классов и модулей разделяются между ракторaми. Объекты Ractor также являются общими. Все операции с общими объектами безопасны для потоков во всех ракторaх. В Ruby невозможно определять изменяемые общие объекты, но их могут создавать расширения на C.

Запрещено обращаться (получать) к переменным экземпляра общих объектов из других ракторов, если значения этих переменных не являются общими. Это может произойти, поскольку модули и классы являются общими, но у них могут быть переменные экземпляра со значениями, которые не являются общими. В неродительских ракторaх также запрещено устанавливать переменные экземпляра классов и модулей (даже если значение является общим).

class C
  class << self
    attr_accessor :tricky
  end
end

C.tricky = "unshareable".dup

r = Ractor.new(C) do |cls|
  puts "I see #{cls}"
  puts "I can't see #{cls.tricky}"
  cls.tricky = true # doesn't get here, but this would also raise an error
end
r.join
# I see C
# can not access instance variables of classes/modules from non-main Ractors (RuntimeError)

Ракторы могут обращаться к константам, если они являются общими. Только главный Ractor может обращаться к необщим константам.

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

r = Ractor.new do
  puts "GOOD=#{GOOD}"
  puts "BAD=#{BAD}"
end
r.join
# 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 = Ractor.new do
  puts "I see #{C}"
  puts "I can't see #{C.tricky}"
end
r.join
# I see C
# can not access instance variables of classes/modules from non-main Ractors (RuntimeError)

См. также описание директивы # shareable_constant_value в разделе Синтаксис комментариев.

Ракторы и потоки

У каждого рактора есть собственный главный Thread. Потоки можно создавать внутри рактора (и в CRuby они используют GVL совместно с другими потоками этого рактора).

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

Примечание к примерам кода

В приведённых ниже примерах иногда используется следующий метод, чтобы дождаться выполнения ракторов или завершения их работы.

def wait
  sleep(0.1)
end

Это предназначено **только для демонстрационных целей** и не должно использоваться в реальном коде. В большинстве случаев для ожидания завершения работы ракторов используется join, а для ожидания сообщений — Ractor.receive.

Справка

Подробнее см. документ о проектировании Ractor.