Generic Singleton Class

[Kumar Jaya]

Hello,

Can I create a generic (Parameterized) Singleton class?

public class SingleTon<T> {

private static SingleTon instance; //I am getting warning message here...

}

I tried but in vain, I am not able to declare my private static instance variable??

Can any one help me??

Regards
Jaya

[Campbell Ritchie]

Maybe you can use

private static final Singleton<T> instance;

instead. Using final will reduce the risk of your instantiating it twice by mistake.

[Vaman Kulkarni]

I guess you should supply the type while creating instance.

    
private static SingleTon<Your type goes here> instance = new  SingleTon<Your type goes here>();
e.g.
private static SingleTon<Integer> instance = new  SingleTon<Integer>();

[Embla Tingeling]

What's the message you get?

[Kumar Jaya]

What's the message you get?

Hi Embla,

A Samle SingleTon Class

class singleton {
private static singleton instance;

static {
instance = new singleton();
}

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

Now I want to parameterize this singleton so.., I will have to do something like this..


class singleton<T> {

private static singleton instance;

// I get warning here in above line saying ->singleton is a rawtype. Reference to generic type should be parameterized.... I cannot parameterize a static reference also??? right???

static {
instance = new singleton();
}

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

suppose I want to instantiate this singleton.., I will do something like this..

singleton<Integer> singleInt = singleton<Integer>.getInstance(); // This wont work since I cannot parameterize the line I get the warning..

I think you get it???

[Paul Clapham]

Well, first of all your declaration inside the class will have to be

private static T instance; 

That's because your singleton object is supposed to be of type T, right? And your getInstance method would be

public static T getInstance()

So far so good. But now you have the problem of creating an instance of an unknown type. No, you can't write "instance = new T()" if you were going to try that. The standard way to deal with this in Generics is to pass in the actual class as a parameter. So your getInstance method would change to be

public static T getInstance(Class<T> clas)

and your code to get the singleton object in the caller would look like this

Singleton<Integer> only = Singleton<Integer>.getInstance(Integer.class);

Next you have the problem of creating an object of a type T when you're given the Class object for that type. Here you use reflection: Class<T> has a method newInstance() which creates an object of type T, using its no-arguments constructor. Note that there's an assumption built in that T actually has such a constructor. If it doesn't, you'll have to use a more complicated method of creating a T object and pass it suitable parameters -- I don't want to go into that, you can figure it out if the question arises.

Personally I wouldn't do all of this. I don't use singletons nearly enough to need a generic way of creating them, so I wouldn't bother. But if you want to do it, because you have a singleton-happy designer passing you specs or just for the challenge of doing it, hopefully that gets you started.

(Edit: I didn't compile any of that so it might not be entirely correct.)

[Embla Tingeling]

Kumar Jaya wrote:I think you get it???

It seems like a problem that cannot be solved without an unsafe downcast somewhere.

This is the best solution I can come up with,

class singleton<T> { 
	private static final singleton<?> instance = new singleton<Object>();
	private singleton() {}
	T variable;

	public static singleton<?> getInstance() { 
		return instance; 
	} 
} 
void test() {
	singleton<String> singletonString = (singleton<String>)singleton.getInstance();
	String s = singletonString.variable;
	singleton<Integer> singletonInteger = (singleton<Integer>)singleton.getInstance();
	Integer i = singletonInteger.variable;
}

As you can see the singleton reference (returned by getInstance) must be downcasted so that's not typesafe. On the other hand this downcast must match the type of the reference variable (singletonString and singletonInteger) so you actually get a typecheck at compiletime. This means the downcast is typesafe in practice so the last step would be to suppress the compiler warning with @SuppressWarnings("unchecked").

[Lorand Komaromi]

Embla Tingeling wrote:

Kumar Jaya wrote:
his means the downcast is typesafe in practice

No it is not, you can assign the instance to a singleton<String> reference and set variable then assign it to a singleton<Integer> and try to use it as an Int. At runtime the JVM can't tell whether the singleton instance contains a String or Int, because of this, it can't check the cast and throw a ClassCastException before you try to do something really silly...

[Lorand Komaromi]

Embla Tingeling wrote:

Kumar Jaya wrote:
his means the downcast is typesafe in practice

No it is not, you can assign the instance to a singleton<String> reference and set variable then assign it to a singleton<Integer> and try to use it as an Int. At runtime the JVM can't tell whether the singleton instance contains a String or Int, because of this, it can't check the cast and throw a ClassCastException before you try to do something really silly...

[Lorand Komaromi]

Embla Tingeling wrote:
his means the downcast is typesafe in practice

No it is not, you can assign the instance to a singleton<String> reference and set variable then assign it to a singleton<Integer> and try to use it as an Int. At runtime the JVM can't tell whether the singleton instance contains a String or Int, because of this, it can't check the cast and throw a ClassCastException before you try to do something really silly...

[Lorand Komaromi]

Hmm, I tried to edit my reply and it got posted 3 times.

[Embla Tingeling]

Lorand Komaromi wrote:

Embla Tingeling wrote:
his means the downcast is typesafe in practice

No it is not,

Could you supply an example of what you mean (preferrably based on the code I posted).

[Vivek Singh]

Campbell Ritchie wrote:Maybe you can use

private static final Singleton<T> instance;

instead. Using final will reduce the risk of your instantiating it twice by mistake.

This is the best and smartest way to introduce Singleton.

[Embla Tingeling]

Vivek Singh wrote:

Campbell Ritchie wrote:Maybe you can use

private static final Singleton<T> instance;

instead. Using final will reduce the risk of your instantiating it twice by mistake.

This is the best and smartest way to introduce Singleton.

I don't agree, the enum Singleton is both better and smarter. The problem is that an enum cannot be generic so it doesn't solve the OP's problem.

[Seetharaman Venkatasamy]

Campbell Ritchie wrote:private static final Singleton<T> instance;

or define a private Constructor .

[Kumar Jaya]

Well, first of all your declaration inside the class will have to be
view plaincopy to clipboardprint?

1. private static T instance;

private static T instance;
That's because your singleton object is supposed to be of type T, right?

This is not permited as you cant have a static Type..

I am trying from all the posts from Paul, Embla to find out a way..

Anyway thanks to all..

Regards
Jaya

[Embla Tingeling]

Kumar Jaya wrote:I am trying from all the posts from Paul, Embla to find out a way..

Good luck.

I still claim that the downcast in my solution is typesafe but I'll change my mind if Lorand Komaromi manages to come up with a counterexample showing it is not.

[Lorand Komaromi]

Embla Tingeling wrote:
I still claim that the downcast in my solution is typesafe but I'll change my mind if Lorand Komaromi manages to come up with a counterexample showing it is not.

I was wrong about the ClassCastException, it WILL be thrown because the compiler had inserted casts at compile time. Still, you loose compile-time type safety:

singleton<String> singletonString = (singleton<String>)singleton.getInstance();  
   singletonString.variable = "foo";  
   singleton<Integer> singletonInteger = (singleton<Integer>)singleton.getInstance();  
   Integer i = singletonInteger.variable;  
   i.intValue();

[Kumar Jaya]

Thanks Lorand Komaromi and Embla Tingeling,

The discussion was really good, but I still dont have a complete understanding, and have some doubts lurking in my mind.

1) I far as I understood, generics was introduced to remove unnecessary casts, so even if I use generics I cannot go without the downcast in the example. So I cant justify such a design.

2) Singleton pattern has a prime purpose of having only one instance of its kind. So if I use a non generic instance such as

Singelton sTon = Singleton.getInstance();...

I will get an instance of a singleton if this call is for the first time, and in any other part of my coding classes if I use the same statement like

Singleton sTonn = SingleTon.getInstance(); should return the same instance. (like sTon == sTonn)..

Now if I used generics

Singleton<Integer> sInt = Singleton<Integer>.getInstance();

and

Singleton<String> sString = Singleton<String>.getInstance();

I will be having ideally two instances sInt and sString where (sInt != sString), so if I do the same
Singleton<Integer> sIntt = Singleton<Integer>.getInstance(); some where down the code will I get (sInt == sIntt or sInt != sIntt)??

Also one final thing from a more practical point

Suppose I have a more generic class like

class myclass <T extends Something<ID>, ID> {
....
}

can I create a singleton implementation for myclass??

Once again I really thank for your time.

Regards
Jaya

[Embla Tingeling]

Kumar Jaya wrote:and have some doubts lurking in my mind.

So do I actually.

I've search a little on the internet and there doesn't seem to be a good generic Singleton solution available. It's seems to be beyond Java generics.

My suggested solution doesn't seem to work properly so I suggest you forget about it.

[Steve Luke]

Seems to me like you don't actually want a Singleton, you are probably better off with a mapping of the Type to the Instance, and a method to make sure that there is only one instance in play. To me that suggests using a Factory class with access to a particular Type's Instance protected by synchronization. For example, if we replace your Singleton class with a Generic interface like below:

public interface ThingHolder<T> 
{
	public T getThing();
	public void setThing(T toSet);
}

We could have an Factory (which is a Singleton, but not the 'Generic Singleton' you were talking about) like this:

import java.util.HashMap;
import java.util.Map;

public class InstanceFactory
{

	/*****
	 * The InstanceFactory is a Singleton to make sure there is only one instanceMap
	 *****/
	private static final InstanceFactory factory = new InstanceFactory();
	public static InstanceFactory getFactory() { return factory; }
	private InstanceFactory() {};
	
	/*****
	 * The Map holds Class -> ThingHolder pairings.  Note that the 'ThingHolder' represents the 'Singleton'
	 * you want per type.
	 *****/
	@SuppressWarnings("unchecked")
	private final Map<Class, ThingHolder> instanceMap = new HashMap<Class, ThingHolder>();

	/*****
	 * Return an instance of a ThingHolder which holds an Object of the type described by
	 * the passed in Class.  Each type will have exactly one instance of ThingHolder, such
	 * that two calls to getInstance using the same Class Object will return the same 
	 * instance of ThingHolder.
	 * 
	 * Such that the assertion below should always be true:
	 * <code>
	 *     InstanceFactory factory = InstanceFactory.getFactory();
	 *     ThingHolder<Integer> holder1 = factory.getInstance(Integer.class);
	 *     ThingHolder<Integer> holder2 = factory.getInstance(Integer.class);
	 *     assert(holder1 == holder2);
	 * </code>
	 * 
	 * If different Class Objects are passed into the getInstance method then the method
	 * will return different ThingHolder objects which holds a different type.
	 * 
	 * Such that the assertion below should always be true:
	 * <code>
	 *     InstanceFactory factory = InstanceFactory.getFactory();
	 *     ThingHolder<Integer> holder1 = factory.getInstance(Integer.class);
	 *     ThingHolder<String> holder2 = factory.getInstance(String.class);
	 *     assert(holder1 != holder2);
	 * </code>
	 *****/
	@SuppressWarnings("unchecked")
	public <T> ThingHolder<T> getInstance(Class<T> ofClass) {
		ThingHolder<T> instance = null;
		synchronized(ofClass)
		{
			if (instanceMap.containsKey(ofClass))
			{
				instance = instanceMap.get(ofClass);
			}
			else
			{
				instance = new ThingHolderImpl<T>(ofClass);
				instanceMap.put(ofClass, instance);
			}
		}
		
		return instance;
	}
	
	/* ***
	 * Private implementation of the ThingHolder interface.
	 * ***/
	private class ThingHolderImpl<T> implements ThingHolder<T>
	{
		private T toHold;
		
		ThingHolderImpl(Class<T> typeToHold)
		{}
		
		public T getThing() { return this.toHold; }
		public void setThing(T toSet) { this.toHold = toSet; }
	}
}

I haven't tested so much, but I think this would provide Thread-Safe 'singleton' instances per-type since all accesses to the instance are synchronized on the Class object. You could use it like this:

public class ThingWorker {
	public static void main(String[] args) {
		InstanceFactory factory = InstanceFactory.getFactory();
		ThingHolder<Integer> intThingy = factory.getInstance(Integer.class);
		ThingHolder<String> stringThingy = factory.getInstance(String.class);
		// Oops  Compile Time Error
		//ThingHolder<Double> doubleThingy = factory.getInstance(Number.class);
		
		ThingHolder anotherIntThingy = factory.getInstance(Integer.class);
		
		assert(intThingy == anotherIntThingy) : "Integer ThingHolders are different!";
		assert(stringThingy != anotherIntThingy) : "String and Integer ThingHolders are the same!";
		
		System.out.println("All is as it should be.");
	}
}

[Kumar Jaya]

Thanks Steve,

I will give this a try.

Regards
Jaya