# Singleton ### Description **Singleton** is a most widely used design pattern. If a class has and only has one instance at every moment, we call this design as singleton. For example, for class Mouse (not a animal mouse), we should design it in singleton. You job is to implement a `getInstance`method for given class, return the same instance of this class every time you call this method. #### Example ``` In Java: A a = A.getInstance(); A b = A.getInstance(); a should equal to b. ``` ### Challenge If we call getInstance concurrently, can you make sure your code could run correctly? ## Solution 创建静态instance成员，每次都返回此静态成员。 #### Traditional Singleton: Lazy Initialization ```java /** * This reference program is provided by @jiuzhang.com * Copyright is reserved. Please indicate the source for forwarding */ class Solution { /** * @return: The same instance of this class every time */ public static Solution instance = null; public static Solution getInstance() { if (instance == null) { instance = new Solution(); } return instance; } }; ``` The `getSingleton()`method is attempting to [lazily initializing](http://en.wikipedia.org/wiki/Lazy_initialization) the SINGLETON instance, but it has the following problems: * Access to the variable is not `synchronized` * The variable is not `volatile` * You are not using [double checked locking](http://en.wikipedia.org/wiki/Double-checked_locking) so a race condition MAY cause two instances to be created. Source: ### About Thread Safety: #### Auto ThreadSafe Singleton Pattern: ```java package com.crunchify.tutorials; public class ThreadSafeSingleton { private static final Object instance = new Object(); protected ThreadSafeSingleton() { } // Runtime initialization // By defualt ThreadSafe public static Object getInstance() { return instance; } } ``` Through this approach we provide the necessary [thread-safety](https://crunchify.com/java-simple-thread-example/), as the Singleton instance is created at class-load time. Any subsequent calls to the `getInstance()` method will return the already created instance. Furthermore, the implementation is optimized as we’ve eliminated the need for checking the value of the Singleton instance, i.e. `instance == null`. #### Simple Singleton Pattern: (Lazy Initialization + ThreadSafe with synchronized block) ```java package com.crunchify.tutorials; public class CrunchifySingleton { private static CrunchifySingleton instance = null; protected CrunchifySingleton() { } // Lazy Initialization (If required then only) public static CrunchifySingleton getInstance() { if (instance == null) { // Thread Safe. Might be costly operation in some case synchronized (CrunchifySingleton.class) { if (instance == null) { instance = new CrunchifySingleton(); } } } return instance; } } ``` It is clear from the example that the traditional approach is not [thread-safe](https://crunchify.com/what-is-threadsafe-blockingqueue-in-java-and-when-you-should-use-it-implementation-attached/) , as it’s possible that before a thread creates the Singleton instance, another thread proceeds to the instantiation part of the code (i.e. instance = new Object();), because the condition [instance == null](https://crunchify.com/have-you-noticed-nullpointerexception-npe-there-are-few-best-practices-to-avoid-npe/) is still true. #### StackOverflow Answer: [What is an efficient way to implement a singleton pattern in Java? \[closed\]](https://stackoverflow.com/questions/70689/what-is-an-efficient-way-to-implement-a-singleton-pattern-in-java) ## Thread Safe Singleton in Java ```java package com.journaldev.designpatterns; public class ASingleton { private static ASingleton instance = null; private ASingleton() { } public static ASingleton getInstance() { if (instance == null) { instance = new ASingleton(); } return instance; } } ``` \- There are three ways through which we can achieve thread safety. 1. **Create the instance variable at the time of class loading.** **Pros**: * Thread safety without synchronization * Easy to implement **Cons**: * Early creation of resource that might not be used in the application. * The client application can’t pass any argument, so we can’t reuse it. For example, having a generic singleton class for database connection where client application supplies database server properties. 2. **Synchronize the getInstance() method** **Pros**: * Thread safety is guaranteed. * Client application can pass parameters * Lazy initialization achieved **Cons**: * Slow performance because of locking overhead. * Unnecessary synchronization that is not required once the instance variable is initialized. 3. **Use synchronized block inside the if loop and volatile variable** **Pros**: * Thread safety is guaranteed * Client application can pass arguments * Lazy initialization achieved * Synchronization overhead is minimal and applicable only for first few threads when the variable is null. **Cons**: * Extra if condition #### Using 3rd approach: ```java package com.journaldev.designpatterns; public class ASingleton { private static volatile ASingleton instance; private static Object mutex = new Object(); private ASingleton() { } public static ASingleton getInstance() { ASingleton result = instance; if (result == null) { synchronized (mutex) { result = instance; if (result == null) instance = result = new ASingleton(); } } return result; } } ``` --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://aaronice.gitbook.io/object-oriented-design/ood-case-studies/singleton.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.