> For the complete documentation index, see [llms.txt](https://aaronice.gitbook.io/object-oriented-design/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://aaronice.gitbook.io/object-oriented-design/ood-case-studies/singleton.md).

# 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: <https://stackoverflow.com/questions/12878012/concurrent-calls-of-singleton-class-methods>

### About Thread Safety:

<https://crunchify.com/thread-safe-and-a-fast-singleton-implementation-in-java/>

#### 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)

<https://stackoverflow.com/a/16580366>

## Thread Safe Singleton in Java

<https://www.journaldev.com/171/thread-safety-in-java-singleton-classes-with-example-code>

```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;
    }

}
```