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

[email protected]
[email protected]

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

[email protected]
[email protected]

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
[email protected]
com. [email protected]

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.

Mark Your Impression

Close Menu