线程安全：Ruby中的类变量

Question

在Ruby中执行对类变量的写入/读取操作不是线程安全的。对实例变量执行写入/读取似乎是线程安全的。也就是说，对类或元类对象的实例变量执行写/读操作是否线程安全？

在线程安全方面，这三个（人为的）例子之间有什么区别？

实施例1：互斥

class BestUser # (singleton class) 
    @@instance_lock = Mutex.new 

    # Memoize instance 
    def self.instance 
    @@instance_lock.synchronize do 
     @@instance ||= best 
    end 
    end 
end 

实施例2：INSTANCE变量存储

class BestUser # (singleton class) 
    # Memoize instance 
    def self.instance 
    @instance ||= best 
    end 
end 

实施例3：INSTANCE变量存储ON元类

class BestUser # (singleton class) 
    # Memoize instance 
    class << self 
    def instance 
     @instance ||= best 
    end 
    end 
end 

Answer 1

实施例2和3完全相同。模块和类也是对象，在一个对象上定义一个单例方法实际上在它的单例类中定义它。

这样说，既然你已经建立了实例变量访问是线程安全的，例子2和3是线程安全的。示例1也应该是线程安全的，但比其他两个要差，因为它需要手动变量同步。但是，如果您需要利用继承树内共享类变量的事实，则可能必须使用第一种方法。

---

Ruby语言的固有线程安全性取决于实现。

MRI之前，1.9，实施线程at the VM level。这意味着，尽管Ruby能够调度代码执行，但在单个Ruby进程中没有任何并行运行并行。 Ruby 1.9使用与global interpreter lock同步的本地线程。只有持有锁的上下文可以执行代码。

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 

Answer 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上运行。

Answer 3

Instance variables are not thread safe（和类变量甚至更线程安全）

实施例2和3中，与实例变量，是等效的，并且它们NOT线程安全，像@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：实例变量有时称为“类的实例变量”，这取决于在其中使用它们的上下文：

当自被一个类，它们是类的实例变量（类 实例变量）。当自己是一个对象时，它们是对象变量（实例变量）的实例 。 - WindorC's answer to a question about this