Do singleton classes create problems in a multi-threaded app?

Question

This might be premature optimization, or premature over-cautionization, but I'm avoiding using singletons on a few classes because I'm concerned that down the road I'll need to run my app as multi-threaded, and that the singletons will create conflicts and messiness. Do singletons have this issue in Ruby, or is there some kind of built in namespace so that when an a class refers to the singleton, only the singleton on the same thread is returned?

Edit: to clarify these are observable classes which when updated cause the other classes that are watching them to update. I'm not sure if this is thread safe or not, but I do know that right now I'm passing these observable classes around a ton and it's kind of annoying. And they do seem like natural singleton classes.

Answer 1

Here is an example of making a singelton threadsafe. You have to treat it like any other object which has state (@things) and is not immutable (readonly). The getters and setters need to access the internal state via a Mutex (mutual exclusion).

require 'singleton'

class MyObject
  include Singleton

  def initialize
    @things = []
    @mutex  = Mutex.new
  end

  def add(thing)
    with_mutex { @things << thing }   
  end

  def things
    with_mutex { @things }
  end

  def clear
    with_mutex { @things.clear }
  end

  def self.add(thing)
    instance.add(thing)
  end

  def self.things
    instance.things
  end

  def self.clear
    instance.clear
  end

  private

  def with_mutex
    @mutex.synchronize { yield }
  end
end

Further reading: http://rubylearning.com/satishtalim/ruby_threads.html

Answer 2

All classes that aren't written to be thread-safe will cause problems in a multi-threaded environment, regardless of whether they're singletons or not.

The fact that your class is a singleton could make the problem worse, because it's shared by default. You can't have an instance per-thread.

If the singleton state is read-only and immutable you won't have a thread safety issue.

If shared state is modified, you have to ensure that it's thread safe.