Singleton design pattern and preventing cloning

Question

Many articles I've read on the Net about Singleton design pattern mention that the class should override 'clone()' method and in it, throw 'CloneNotSupported' exception. Is this really necessary?

The clone() method by default is protected, so no class (except those in the same package) would be able to call it on that Singleton instance. Plus, if this Singleton does not implement Cloneable, then even if this method is called, it will give a runtime exception. Plus, the constructor being private, we won't be able to subclass it and thus allow for its cloning. So should I still implement this advice for my Singleton classes?

EDIT: Just to clarify: I'm not looking for the best possible way to implement Singleton. I'm just asking about the validity of the advice mentioned above, w.r.t the 'normal' Singleton pattern (and not Enum based Singleton).

Answer 1

If you're really going to implement a singleton, use a one-element enum and stop thinking about it.

---

EDIT: Just to clarify: I'm not looking for the best possible way to implement Singleton. I'm just asking about the validity of the advice mentioned above, w.r.t the 'normal' Singleton pattern (and not Enum based Singleton).

Since you have Effective Java, then you should already be aware of the pitfalls and problems with Cloneable. That said, if you're going to implement a singleton one of the "wrong" ways, no, there's absolutely no reason whatsoever to implement Cloneable and override Object#clone() just to throw CloneNotSupportedException. Object#clone() already does this when the Cloneable interface is absent.

Answer 2

@shrini1000, You have a valid question but the suggetsion about clone is very specific to following condition

public Object clone() throws CloneNotSupportedException {
    throw new CloneNotSupportedException(); 
}

The above is only necessary if a superclass of a singleton class implements a public clone() method.

Answer 3

The below code is for preventing the singleton class to be cloned.Override the clone method and throw new CloneNotSupportedException()

public final class SingeltonCloneTest implements Cloneable {

    /**
     * @param args
     * @return
     */
    private static SingeltonCloneTest instance = null;

    private SingeltonCloneTest() {
     System.out.println("Rahul Tripathi");
    }

    public static SingeltonCloneTest getInstance() {

        if (instance == null) {
            instance = new SingeltonCloneTest();
            return instance;
        }
        return instance;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {

        // TODO Auto-generated method stub
        /*
         * Here forcibly throws the exception for preventing to be cloned
         */
        throw new CloneNotSupportedException();
        // return super.clone();
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SingeltonCloneTest test1 = SingeltonCloneTest.getInstance();

        try {
            SingeltonCloneTest test2 = (SingeltonCloneTest) test1.clone();
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

Answer 4

It is necessary if your Singleton class extends a class that has a visible clone() method defined in its hierarchy.

Answer 5

You can avoid cloning by giving already created object by clone method.

public Object clone() {

return singletoneObject;

}

Answer 6

See https://stackoverflow.com/a/71399/385478 for the safest way to enforce the Singleton pattern. Essentially, make your Singleton an enum rather than a class, with a single INSTANCE value.

Answer 7

When writing a class using the Singleton pattern, only one instance of that class can exist at a time. As a result, the class must not be allowed to make a clone.

The singleton pattern says that only one instance of the class exist inside the program, so it is right to raise CloneNotSupportedException in the Clone() method.

Answer 8

The best example i found is this:

class SingletonSuper implements Cloneable {
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
   }
}

class Singleton2 extends SingletonSuper {
    // 1. Make all constructors private
    private Singleton2() {
     }

// 2. Declare a private static variable to hold single instance of class
    private static Singleton2 INSTANCE = new Singleton2();

    public static Singleton2 getInstance() {
        return INSTANCE;
   }
  }

 public class SingletonCloningTest {
    public static void main(String[] args) throws Exception {
        System.out.println("Singleton Test!");
         System.out.println("Singleton Instance:" +                         +  Singleton2.getInstance());
        System.out.println("Singleton clone:"
            + Singleton2.getInstance().clone());
    }
}



 The result will:

 Singleton Test!
 Singleton Instance:com.sample.test.Singleton2@50d89c
 Singleton clone:com.sample.test.Singleton2@1bd0dd4

Answer 9

You need to override the clone() method only if your singleton class implements Cloneable interface or a class which implements Cloneable interface.

Answer 10

As per my understanding you do not need to implement clone() method. Reason: 1. If you don't implement clone method and Cloneable interface it will throw CloneNotSupportedException. 2. clone method is protected and you cannot subclass a singleton class.