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

com.MyClass@544a5ab2
com.MyClass@5d888759

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.


2. Deserialization also breaks Singleton
Deserialization means bringing a saved object back to life. When a class is deserialized, a fresh instance of the class is created and its instance variables are then set to the values which were serialized.
What does a fresh instance creation means if the serialized class was Singleton? Simple, More than one object. See below

	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

com.MyClass@2da679b7
com.MyClass@6bbc4459

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

com.MyClass@5d888759
com. MyClass@2e6e1408

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.

51

1
Leave a Reply

Mark Your Impression

  Subscribe  
newest oldest most voted
Notify of
Close Menu

Never Miss an article !

Get the new post delivered straight into your inbox, enter your email and hit the button

You have successfully subscribed to the newsletter

There was an error while trying to send your request. Please try again.

codippa will use the information you provide on this form to be in touch with you and to provide updates and marketing.