A singleton pattern is probably the simplest well-known design pattern, but still people often implement it incorrectly in Java.<\/p>\n\n\n\n\n\n\n\n
The main goal of the pattern is to ensure there is a single instance of a class accessible globally before it is first needed.<\/p>\n\n\n\n
But wait, that could be accomplished just by a constant, right? Almost. But in reality, we often want to load the singleton lazily at the point we first need it, and we also want to ensure that it is not created multiple times in multi-threaded environments.<\/p>\n\n\n\n
I’ve seen crazy complex solutions like this one<\/a> to do it correctly. I mean, they are correct, but just too complex to implement by hand without a mistake. They are applicable in any language but they don’t take into account how JVM works to simplify the solution.<\/p>\n\n\n\n My point is that JVM classloaders already provide both lazy loading and thread-synchronization. Contrary to popular beliefs like that all classes are loaded at start-up or when imported by another class, they are loaded when their bytecode is executed<\/a>.<\/p>\n\n\n\n Therefore it is only necessary to define a Singleton class that includes the constant – the static field will be only initialized once the class is loaded, and that would be when It is even simpler to use Java enum to implement the constant. Enums also bring additional advantage because enum values remain single even after deserialization<\/a>, whereas class instances are deserialized as new instances.<\/p>\n\n\n You may access the singleton as easy as:<\/p>\n\n\n In practice, it is better to provide a getter method for the field, so that the access can be intercepted if needed later. But it is not really necessary.<\/p>\n\n\n\nSingleton.INSTANCE<\/code> is first accessed.<\/p>\n\n\npublic<\/span> class<\/span> ClassSingleton<\/span> <\/span>{\n\n private<\/span> ClassSingleton<\/span>()<\/span> <\/span>{\n \/* constructor here *\/<\/span>\n }\n\n \/* instance of the singleton *\/<\/span>\n public<\/span> static<\/span> final<\/span> ClassSingleton INSTANCE = new<\/span> ClassSingleton();\n\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\npublic<\/span> enum<\/span> EnumSingleton{\n INSTANCE;\n\n private<\/span> EnumSingleton<\/span>()<\/span> <\/span>{\n \/* constructor here *\/<\/span>\n }\n\n}\n<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nSystem.out.println(\"Singleton is not loaded yet...\"<\/span>); \n\n\/\/ the singleton's constructor is called at this time lazily<\/span>\nEnumSingleton singleton = EnumSingleton.INSTANCE; \n\nSystem.out.println(\"Singleton is loaded now.\"<\/span>);<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n