ruby多线程共享对象之线程安全

标签：http   io   使用   ar   for   文件   sp   数据   2014   

在进行多线程处理中共享对象，多个线程对同一个对象同时进行修改，有可能出现不一致的状态，使用时要注意。

例子：

test.rb

x = 0

10.times.map do |i|
  Thread.new do
    puts "before (#{ i }): #{ x }"
    x += 1
    puts "after (#{ i }): #{ x }"
  end
end.each(&:join)

puts "\ntotal: #{ x }"

输出：

before (1): 0
after (1): 1
before (0): 1
after (0): 2
before (2): 2
after (2): 3
before (4): 3
after (4): 4
before (6): 4before (5): 3before (9): 3
before (8): 3before (7): 3
after (7): 6
before (3): 3

after (3): 7
after (9): 5

after (8): 8

after (6): 9after (5): 10


total: 10

你可能注意到了，在第四次循环，i = 3，输出：

before (3): 3 #x等于3

after (3): 7 #x等于7

Mutex是一个类，它实现了一个简单的一些共享资源的互斥访问的信号锁定。也就是说，只有一个线程可以持有锁在一个给定的时间。其他线程可能会选择等待锁线，变为可用，或者可能干脆选择错误，指示立即得到锁不能使用。
通过将所有访问一个互斥的控制下共享数据，我们可以确保一致性和原子操作，将代码放到Mutex对象的synchorize方法中。

修改test.rb文件内容如下：

x = 0
mutex = Mutex.new

10.times.map do |i|
  Thread.new do
    mutex.synchronize do
      puts "before (#{ i }): #{ x }"
      x += 1
      puts "after (#{ i }): #{ x }"
    end
  end
end.each(&:join)

puts "\ntotal: #{ x }"

执行 ruby test.rb

输出：

before (0): 0
after (0): 1
before (9): 1
after (9): 2
before (2): 2
after (2): 3
before (3): 3
after (3): 4
before (4): 4
after (4): 5
before (5): 5
after (5): 6
before (6): 6
after (6): 7
before (7): 7
after (7): 8
before (8): 8
after (8): 9
before (1): 9
after (1): 10

total: 10

app.rb文件内容如下：

class Counter
  attr_reader :total
  
  def initialize
    puts ‘initialized...‘
    @total = 0
    @mutex = Mutex.new
  end
  
  def increment!
    @mutex.synchronize { @total += 1 }
  end
end

class Application
  def counter
    @counter ||= Counter.new
  end
  
  def increment!
    counter.increment!
  end
  
  def total
    counter.total
  end
end

app = Application.new
10.times.map do |i|
  Thread.new do
    app.increment!
  end
end.each(&:join)
puts app.total

initialized...
initialized...
initialized...
initialized...
initialized...
initialized...
initialized...
initialized...initialized...

1

正确的是将Application修改成这样：

class Application
  def initialize
    @counter = Counter.new
  end
  
  def counter
    @counter
  end
  
  def increment!
    counter.increment!
  end
  
  def total
    counter.total
  end
end

再次执行，结果如下：

initialized...
10

处理死锁：

当我们开始使用互斥对象的线程排斥，我们必须小心地避免死锁。死锁条件时所发生的所有线程正在等待获取另一个线程持有的资源。因为所有的线程被阻塞，他们不能释放持有的锁。因为他们不能释放的锁，没有其他线程可以获取这些锁。
条件变量是一个简单的相关资源和用于特定互斥锁的保护范围内的信号。当你需要的资源是不可用的，你等待一个条件变量。这一操作释放相应的互斥锁。当其他一些线程信号的资源是可用的，原来的线程来等待，同时恢复对临界区锁。

ConditionVariable类实现了支持线程同步的状态变量的功能。ConditionVariable对象就是把线程的等待条件具体化的产物。

mutex = Mutex.new
cv = ConditionVariable.new

Thread.start {
    mutex.synchronize {
      ...
      while (尚未满足条件时)
        cv.wait(m)
      end
      ...
    }
}

Thread.start {
    mutex.synchronize {
      # 进行某些操作使上述条件得到满足
      cv.signal
    }
}

然后调用signal方法通知正在wait的线程上述条件已成立。这是比较典型的用法。

参考：http://lucaguidi.com/2014/03/27/thread-safety-with-ruby.html

ruby多线程共享对象之线程安全

标签：http   io   使用   ar   for   文件   sp   数据   2014   

原文地址：http://my.oschina.net/fxhover/blog/330469