Common Ways to Implement Thread-Safe Singleton Patterns in Java

Implementation method of singleton mode

There are several common ways to implement thread-safe singleton pattern in Java, each of which has its own characteristics and applicable scenarios. Here are some commonly used implementation methods:

• Lazy style (double check lock)
• Hungry Man-style (static internal class)
• Enum

1. Lazy style (double check lock)

Code Example

public class Singleton {
    private volatile static Singleton instance; // Use volatile to ensure visibility
    private Singleton() {
        // Prevent reflection attacks        if (instance != null) {
            throw new IllegalStateException("Singleton instance already created!");
        }
    }

    public static Singleton getInstance() {
        if (instance == null) { // First check            synchronized () { // Add lock                if (instance == null) { // The second inspection                    instance = new Singleton(); // Instantiation                }
            }
        }
        return instance;
    }
}

explain

• Double-Checked Locking: First perform an empty check, ifinstanceIf empty, it will enter the synchronization block. This can avoid every callgetInstance()The method must be synchronized to improve performance.
• volatile:usevolatileKeywords to ensure visibility in multi-threaded environments. wheninstanceAfter being initialized, other threads can see this change immediately.
• Constructor privatization: Ensure that the external instance cannot be created directly through the constructor.
• Prevent reflex attacks: Add checks to the constructor to prevent instances created bypassing the constructor's privatization through reflection.

2. Hungry Man-style (static internal class)

Code Example

public class Singleton {
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return ;
    }
}

explain

• Static inner class: Use static inner class to hold singleton instances. Static inner classes are loaded only once, thus ensuring the uniqueness of the instance.
• Delay loading: Although the static inner class is static, it is not initialized immediately when the class is loaded. Only when the first visit()Only when   is static inner class will be loaded and initialized.
• Thread safety: The initialization of static inner class is thread-safe by the JVM, so this method is also thread-safe.

3. Enum (Enum)

Code Example

public enum Singleton {
    INSTANCE;

    public void someMethod() {
        // Method to implement singleton    }
}

explain

• enumerate: Using enumerations to implement singleton pattern is the easiest and safest way. Enumeration types naturally support thread-safe singleton mode.
• Simple and easy to use: Enumeration provides a simple way to define singleton objects directly in enum types and implement singleton methods in enumeration.

Rational use suggestions

1. Choose the right implementation method

   • If delayed initialization is required, you can chooseLazy style (double check lock)orHungry Man-style (static internal class)。
   • If you need the simplest implementation method, you can chooseEnum。

2. Performance considerations

   • If performance is an important factor, it is recommended to useStatic inner classorenumerate, because they only happen once at initialization, and each time you get the instance is very fast afterwards.
   • If delayed initialization is required and performance requirements are not high, you can chooseDouble check lock。

3. Code clarity

   • Choose the simplest and clearest way to make the code easy to understand and maintain. Enumeration method is usually preferred because it is both simple and safe.

Points to note during actual development

• Thread safety
  In a multithreaded environment, it is important to ensure thread safety in singleton mode. usevolatileand double check locking can effectively prevent the problem of multi-threading concurrent creation of multiple instances.

• Reflection Attack
  Even if the constructor is private, objects can still be created through reflection mechanisms. Adding checks in the constructor prevents this.

• Serialization problem
  If the singleton object needs to support serialization, it needs to be rewrited.readResolve()Method to ensure that a singleton instance is returned during deserialization.

public class Singleton implements Serializable {
    private static final long serialVersionUID = 1L;

    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return ;
    }

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

• Prevent JVM reordering
  When using double check lock,volatileKeywords not only ensure visibility, but also prevent the JVM's instructions from reordering, thus ensuring the atomicity of the instantiation process.

Through the above discussion, we can see that there are many ways to implement thread-safe singleton pattern in Java, and each method has its applicable scenarios.

Choosing the most appropriate approach depends on the specific requirements and context.

In actual development, ensuring the thread safety of singleton mode is very important, while also taking into account performance, code clarity and maintenance.

This is the introduction to this article about common ways to implement thread-safe singleton pattern in Java. For more related content on Java thread-safe singleton pattern, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!