Безопасность потока: переменные класса в Ruby

Ответ 1

Примеры 2 и 3 точно совпадают. Модули и классы также являются объектами, и определение метода singleton для объекта фактически определяет его в его одноэлементном классе.

С учетом сказанного, и поскольку вы уже установили доступ к переменной экземпляра, поточно-безопасный, примеры 2 и 3 являются потокобезопасными. Пример 1 также должен быть потокобезопасным, но он уступает другим двум, поскольку он требует ручной синхронизации переменных.

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

Собственная безопасность потоков языка Ruby зависит от реализации.

MRI, до 1.9, реализовал потоки на уровне VM. Это означает, что хотя Ruby способен планировать выполнение кода, ничто не работает параллельно в рамках одного процесса Ruby. Ruby 1.9 использует собственные потоки, синхронизированные с блокировкой глобального интерпретатора. Только контекст, который содержит блокировку, может выполнять код.

n, x = 10, 0

n.times do
  Thread.new do
    n.times do
      x += 1
    end
  end
end

sleep 1
puts x
# 100

Значение x всегда согласовано на MRI. Однако на JRuby картина меняется. Несколько выполнений одного и того же алгоритма дали значения 76, 87, 98, 88, 94. Результатом может быть все, потому что JRuby использует потоки Java, которые являются настоящими потоками и выполняются параллельно.

Как и на языке Java, для безопасной работы потоков в JRuby требуется ручная синхронизация. Следующий код всегда приводит к согласованным значениям для x:

require 'thread'
n, x, mutex = 10, 0, Mutex.new

n.times do
  Thread.new do
    n.times do
      mutex.synchronize do
        x += 1
      end
    end
  end
end

sleep 1
puts x
# 100

Ответ 2

Примеры 2 и 3 точно совпадают. Они не являются безопасными для потока.

См. пример ниже.

class Foo
  def self.bar
    @bar ||= create_no
  end

  def self.create_no
    no = rand(10000)
    sleep 1
    no
  end
end

10.times.map do
  Thread.new do
    puts "bar is #{Foo.bar}"
  end
end.each(&:join)

Результат не такой. Результат аналогичен при использовании мьютекса, как показано ниже.

class Foo
  @mutex = Mutex.new

  def self.bar
    @mutex.synchronize {
      @bar ||= create_no
    }
  end

  def self.create_no
    no = rand(10000)
    sleep 1
    no
  end
end

10.times.map do
  Thread.new do
    puts "bar is #{Foo.bar}"
  end
end.each(&:join)

Он запускается на CRuby 2.3.0.

Ответ 3

Переменные экземпляра не являются потокобезопасными (и переменные класса еще менее безопасны для потоков)

Пример 2 и 3, оба с переменными экземпляра, эквивалентны, и они НЕ потокобезопасны, как указано в @VincentXie. Однако, вот лучший пример, чтобы показать, почему они не являются:

class Foo
  def self.bar(message)
    @bar ||= message
  end
end

t1 = Thread.new do
    puts "bar is #{Foo.bar('thread1')}"
end

t2 = Thread.new do
    puts "bar is #{Foo.bar('thread2')}"
end

sleep 2

t1.join
t2.join

=> bar is thread1
=> bar is thread1

Поскольку переменная экземпляра является общей для всех потоков, например, @VincentXie, указанная в его комментарии.

PS: переменные экземпляра иногда упоминаются как "переменные экземпляра класса", в зависимости от контекста, в котором они используются:

Когда self является классом, они являются переменными экземпляра классов (класс переменные экземпляра). Когда self является объектом, они являются экземпляром переменные объектов (переменные экземпляра). - Ответ на вопрос о WindorC