CSC/ECE 517 Fall 2007/wiki1b 6 c1

Take a case of the Singleton pattern and implement it as succinctly as possible in Ruby and Java. Compare the two implementations in terms of clarity and succinctness. The example should be a "real-world" example. While it may be grossly oversimplified for the purpose of illustration, it should not be totally contrived.

Singleton Pattern

The Singleton Pattern is a design pattern used to insure the existence of a single instance of a class in the run time. It constructs the object once and returns a reference to this object every time thereafter. In a multithreading environment, special care should be taken.

Global Variables versus Singleton

Singletons are often mistaken as global variables. These two are very similar but the main difference between the two is that the Singleton Pattern deals with how to limit instances, while global variables deal with how programmers declare instances. When programming, one should not think that the use of Singleton Pattern would solve problems that are associated with global variables because this is a common mistake.

Benefits of Singleton Pattern

There are benefits of using the singleton pattern over other patterns and global variables. When using Singleton Pattern it allows instance control by preventing other objects from instantiating their own copies of the Singleton object which would ensure that all objects access the single instance. Using the Singleton Pattern also gives a little flexibility since the class controls the instantiation process and has the flexibility to change the instantiation process. Singleton Pattern allows reduced name space because the Singleton class can be subclassed,which makes it easier to configure an application with an instance of this extended class. The application can be configures with an instance of the class one needs at run-time.

Several uses of Singleton Pattern include logger (which is illustrated below), payment form, application preference, many dialogs in GUI environemt, and etc.

Class Diagram

Implementation

To implement Singleton do following steps
1- Turn your class constructor to private
2- Create a public method -getInstance()- to return a refrence to the instance. If the object is not initialized yet (object == null) it will create one by invoking the constructor.
3- In multithreading environment, synchoranize your getInstance() method so you don't end with Doubleton or Tripleton.
4- Consider overiding the clone method in Java, so no one can copy your Singleton.

In multithreading environment, a synchronized command should be used so not every thread in the program can initialize its own instance of the singleton class.

Example Implementations

To demonstrate further let us consider programs that implement a logger in Java and then in Ruby.

Java

public class LoggerSingleton {
  private static LoggerSingleton instance = null;
  private LoggerSingleton() {
     // Exists only to defeat instantiation.
  }
  public static synchronized LoggerSingleton getInstance() {
     if(instance == null) {
        instance = new LoggerSingleton();
     }
     return instance;
  }
  public Object clone() throws CloneNotSupportedException {
   	throw new CloneNotSupportedException(); 
  }
  // add other attributes
}

or consider simpler implementation in Java,

public class LoggerSingleton {
  private final static LoggerSingleton instance = new Singleton();

  private LoggerSingleton () {
  }

  public static LoggerSingleton getInstance() {
    return instance ;
  }
}

Ruby

or for sure the super simple in Ruby,

require 'singleton' 
class LoggerSingleton
  include Singleton 
end 

Invoking Singletons

The following coding is to invoke a singleton class in Java then in Ruby

Java

LoggerSingleton logger1 = LoggerSingleton.getInstance();	
LoggerSingleton logger2 = LoggerSingleton.getInstance();
LoggerSingleton logger3 = new LoggerSingleton(); // compilation error will occur; The constructor is private.
System.out.println(logger1);
System.out.println(logger2);

Ruby

logger1 = LoggerSingleton.instance 
logger2 = LoggerSingleton.instance 

Test Singletons

The following coding is to test singleton class in Java then in Ruby

Java

import junit.framework.Assert; 
import junit.framework.TestCase; 
public class TestSingleton extends TestCase {
 private LoggerSingleton logger1 = null, logger2 = null;
 public TestSingleton(String name) {
   super(name);
 }
 public void setUp() {
       logger1 = LoggerSingleton.getInstance();
       logger2 = LoggerSingleton.getInstance();
  }
 public void testUnique() {
       System.out.println(logger1);
       System.out.println(logger2);
       Assert.assertEquals(true, logger1 == logger2);
      }
   }

Ruby

def testSingleton
   logger1 = LoggerSingleton.instance 
   logger2 = LoggerSingleton.instance 
   assertEqual logger1, logger2
end

Comparison

When comparing Singleton Pattern in Java and Ruby, it is shown that Ruby obviously is better than Java. It seems that Ruby would win because of the simplicity compared to Java since only one line of code "include Singleton" enables all the functionalities when Java needs more lines to do this. Since Ruby uses singleton mixins, it is easier to implemenet and since Java does not use mixins, it requires more implementation in the coding.

Conclusion

Java doesn’t contain singleton pattern in the language itself, although implementation for the pattern is still possible. While in Ruby the singleton pattern is in the language itself, which became possible since Ruby is a dynamic language through singleton module.

References

Head First Design Patterns by Eric Freeman, Kathy Sierra, Bert Bates, Elisabeth Freeman
Programming Ruby: The Pragmatic Programmers' Guide (Pragmatic Programmers Series) by Dave Thomas, Andy Hunt, Andrew Hunt, Chad Fowler, Chad Fowler

External Links

Singleton Pattern Wiki