класс Ractor

Ractor — это абстракция модели акторов для Ruby, которая обеспечивает потокобезопасное параллельное выполнение.

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

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

Ractors не разделяют все объекты друг с другом. Это имеет два основных преимущества: во-первых, проблемы потоковой безопасности, такие как гонки данных и условия гонки, в работе между ракторами невозможны. Второе преимущество — параллелизм.

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

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 until somebody passes a message
  puts "I am in Ractor! a=#{a_in_ractor}"
end
r.send(a)  # pass it
r.take
# Here, "I am in Ractor! a=1" is printed

Существует две пары методов для отправки/получения сообщений:

• Ractor#send и Ractor.receive для случаев, когда отправитель знает получателя (push);

• Ractor.yield и Ractor#take для случаев, когда получатель знает отправителя (pull);

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

Небольшой пример классической игры "пинг-понг":

server = Ractor.new(name: "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}"
end

client = Ractor.new(server) do |srv|        # The server is sent to the client, and available as srv
  puts "Client starts: #{self.inspect}"
  received = srv.take                       # The client takes a message 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 to the server
end

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

Это выведет что-то вроде:

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

Ractors получают свои сообщения через входящий порт и отправляют их в исходящий порт. Каждый из них можно отключить с помощью Ractor#close_incoming и Ractor#close_outgoing соответственно. При завершении работы рактора его порты закрываются автоматически.

Делимые и неделящиеся объекты

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

Делимые объекты — это такие, которые могут использоваться несколькими потоками без нарушения потоковой безопасности, например, числа, 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 или Ractor.yield) дополнительная обработка не выполняется. Он просто становится доступным для обоих ракторов. При отправке неделимого объекта, он может быть либо скопирован, либо перемещён. Первое является по умолчанию и полностью копирует объект, выполняя глубокое клонирование (Object#clone) неделимых частей его структуры.

data = ['foo', '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.take
puts "Outside  : #{data.object_id}, #{data[0].object_id}, #{data[1].object_id}"

Это выведет что-то вроде:

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

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

Глубокое клонирование объектов может быть медленным и иногда невозможно. В качестве альтернативы, 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.take
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 объекты делимые, поэтому определения классов/модулей разделяются между ракторами. Объекты Ractor также делимые. Все операции над делимыми объектами потокобезопасны, поэтому свойство потоковой безопасности будет сохранено. Мы не можем определить изменяемые делимые объекты в Ruby, но расширения C могут их ввести.

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

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.take
# I see C
# can not access instance variables of classes/modules from non-main Ractors (RuntimeError)

Ракторы могут получать доступ к константам, если они делимые. Главный рактор — единственный, который может получить доступ к неделящимся константам.

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

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

См. также описание прагмы shareable_constant_value в синтаксисе комментариев.

Ractors против потоков

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

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

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

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

def wait
  sleep(0.1)
end

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

Ссылка

См. документацию по проектированию Ractor для получения более подробной информации.