Discussion on:

Using the Singleton pattern in Java

... that's a lot of work! In VB.Net, you just mark a class or method with "Shared" and you are done. I understand why, Java gives you much more control doing it the way you describe, but you would think that since it is such a common pattern, they would have made it a bit easier.

J.Ja

Well I don't think that making common patterns a part of language is really a good idea. Better is to give more flexibility to developer. That's what all these Java patterns are about.

If you want maximum flexibility then program in Assembly. You can design the classes the way you want them. Adding common patterns to programming languages helps to speed up development. Personally, I think a programming language needs to be adapted to a specific field rather than making every language capable of doing the same thing. The idea that Cobol was written for business apps and Fortran for scientific/engineering apps allows a programmer to choose his design tool.

...that amount of work is necessary in VB.NET too... VB's 'Shared' is analogous to java or c#'s 'static'. Marking a class Shared or static makes it non-instantiable, like a module, not a Singleton. The pattern for Singleton classes is exactly the same in VB.NET as it is in Java as it is in C# as it is in C++, etc... (save for the thread-safe stuff). No language has direct support for this pattern, because it IS so easy to implement with standard language constructs.

Although it has valid uses, i think Singleton is one pattern that has been consistently (ab)used, especially in Java code. It's too easy to make a class a Singleton and end up with code that's very tightly coupled, is difficult to unit-test as it's difficult to mock, and makes a lot of assumptions about the calling code. Have a look at this:

http://www.ibm.com/developerworks/webservices/library/co-single.html

If you need to make the class Serializable, you need to add a readResolve() method to the class:

public Object readResolve() {
return getInstance();
}

Otherwise, deserialization will construct a new instance of the class and use it. The pre-enum style of type-safe enumerations has the same problem.

This article seems woefully incomplete when talking about multi-threaded access to Singletons in Java. See this for a more thorough discussion.

You may also be interested in this discussion of why you should avoid using Singleton in the first place.

Hi ,

There could be another solution if Singleton is written in JAVA by using Enum way as explained in book "Effective Java".

public enum Singleton {
INSTANCE;
}

Thanks
Javin
Why String is immutable in Java