How to break Singleton class in java

Overall notion of Singleton class lies in getting one and only one instance of the class. Much of our functionality relies on the base that there will be only one object of a class we intentionally designed to be Singleton. What if the same class produces more than one object in some scenario? Woaaah!!! Our code blows away.

For all those who are anxious to know how this could be done to break a Singleton class or how to write Singleton class so that it is not broken, there is some interesting stuff below:

1. Break by Cloning

If a Singleton class implements java.lang.Cloneable interface then invoking clone() method on its single instance creates a duplicate object. Consider the below code:

public class MyClass implements Cloneable{

 private static MyClass instance = new MyClass();

 private static MyClass getInstance(){
  return instance;
 }

 public static void main(String[] args) 
                      throws CloneNotSupportedException {
  MyClass obj = MyClass.getInstance();
  System.out.println(obj);
  System.out.println(obj.clone());
 } 
}

This prints

See!!! Two distinct objects. Singleton gone away.

Remedy
Don’t make the class which should be Singleton implement java.lang.Cloneable. If it extends a class which implements Cloneable, then override clone method and throw CloneNotSupportedException from it. This will prevent clone creation.

 MyClass ob= MyClass.getInstance();
 System.out.println(ob);

 // ..code to serialize object goes here
 
        // ..code to deserialize saved object here

 MyClass newObject = (MyClass)inputStream.readObject(); 
 //inputStream is the stream connected to the medium to which the object 
        //was serialized, e.g., a file  
 System.out.println(newObject);
 //re-initialize the same input stream or 
 //use another inputstream to read the object once again
 MyClass anotherObject = (MyClass)inputStreamNew.readObject();
 System.out.println(anotherObject);

The output is

Again, distinct objects.

Remedy
Override readResolve method and return the same Singleton instance every time. readResolve method is called after the object has been read from the stream but before it is returned to the calling code. For implementing this method just put the following code into your Serializable class:

private Object readResolve(){
  return instance;
}

3. Reflection can instantiate a Singleton multiple times
Using java reflection api, we can tweak into a class by getting details like its fields, constructor, invoking its methods etc. Reflection can also be used to create new instance of a class. Obviously, if the class is Singleton, then creating a new instance again breaks its Singleton nature. See below

try {
 //load class
 Class c = Class.forName("com.codippa.MyClass");
 //get all constructors (whether public or private)
 Constructor[] constructors = c.getDeclaredConstructors();
 //suppress access check errors
 constructors[0].setAccessible(true);
 //instance no 1
 System.out.println(constructors[0].newInstance());
 //instance no 2
 System.out.println(constructors[0].newInstance());
} catch (ClassNotFoundException e) {
  e.printStackTrace();
} catch (InstantiationException e) {
  e.printStackTrace();
} catch (IllegalAccessException e) {
  e.printStackTrace();
} catch (IllegalArgumentException e) {
  e.printStackTrace();
} catch (InvocationTargetException e) {
  e.printStackTrace();
}

The above code prints

Clearly the two objects are different.

Remedy
Check the static instance to be not null and throw Error if it is not null which means one instance already exists as.

 
private MyClass () {
 if(inst!=null){
  throw new InstantiationError("Already there");
 }
}

Hope the above post let you understand the ways to break a Singleton. Keep the above points in mind when designing a Singleton.
Hit the clap below to show your appreciation if you liked the article.