Additional menu

Crunchify

Largest free Technical and Blogging resource site for Beginner. We help clients transform their great ideas into reality!

Crunchify   Design Development   Singleton Design Pattern in java – Thread-Safe, Fast Singleton I ...

Singleton Design Pattern in java – Thread-Safe, Fast Singleton Implementation

Updated on by App   4

Thread-Safe and a Fast Singleton Implementation - Singleton Design Pattern in java

Simple Singleton Pattern in Java

In software engineering, the singleton pattern is a design pattern that restricts the instantiation of a class to one object. This is useful when exactly one object is needed to coordinate actions across the system. The concept is sometimes generalized to systems that operate more efficiently when only one object exists, or that restrict the instantiation to a certain number of objects.

Singleton Pattern JavaExample:

Window managers, print spoolers, and filesystems are prototypical examples. Typically, those types of objects — known as singletons — are accessed by disparate objects throughout a software system, and therefore require a global point of access.

The Singleton design pattern addresses all of the above concerns.

With the Singleton design pattern you can:

  • Ensure that only one instance of a class is created
  • Provide a global point of access to the object
  • Allow multiple instances in the future without affecting a singleton class’s clients

Another must read:

Here is a singleton design pattern example.

Crunchify Singleton Pattern in Java

Simple Singleton Pattern: (Lazy Initialization + ThreadSafe with synchronized block)

This implementation uses the same double-checked locking mechanism as in the previous implementation. The added logging statements help demonstrate when the instance is being created and returned.

package com.crunchify.tutorials;

public class CrunchifySingleton {
    private static CrunchifySingleton instance;
    
    private CrunchifySingleton() {
        System.out.println("CrunchifySingleton instance created");
    }
    
    // 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();
                }
            }
        }
        System.out.println("Returning CrunchifySingleton instance");
        return instance;
    }
}

It is clear from the example that the traditional approach is not thread-safe, 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 is still true.

Thread-Safe Singleton Pattern in Java:

Here is the updated code that implements a thread-safe Singleton pattern in Java:

In this implementation, the instance variable is declared as volatile to ensure that multiple threads handle the variable correctly when creating the instance. The double-checked locking mechanism is still used to ensure that only one instance of the CrunchifySingleton class is created, even in a multithreaded environment.

public class CrunchifySingleton {
    private static volatile CrunchifySingleton instance;
    
    private CrunchifySingleton() {
        System.out.println("CrunchifySingleton instance created");
    }
    
    public static CrunchifySingleton getInstance() {
        if (instance == null) {
            synchronized (CrunchifySingleton.class) {
                if (instance == null) {
                    instance = new CrunchifySingleton();
                }
            }
        }
        System.out.println("Returning CrunchifySingleton instance");
        return instance;
    }
}

Through this approach we provide the necessary thread-safety, as the Singleton instance is created at class-load time.

Any subsequent calls to the getInstance() method will return the already created instance.

Let me know if you have any question understanding this.

If you liked this article, then please share it on social media. Have a question or suggestion? Please leave a comment to start the discussion.

Suggested Articles...

  1. Java: Factory Design-Method Pattern | Object Oriented Design | Design Patterns
  2. Fundamentals of Java Static Method, Class, Variable and Block
  3. Have you Noticed java.lang.NullPointerException (NPE)? 8 Best Practices to Avoid runtime NPE in Java
  4. Complete End to End Java Tutorial with Singleton Object Employee, Crunchify Java POJO and Detailed TestCase
  5. All in one Java Regex, Matcher Pattern and Regular Expressions Tutorial
  6. Lazy Creation of Singleton ThreadSafe Instance without Using Synchronized Keyword

Reader Interactions

  4 Comments...

  1. Alessio says

    A real thread-safe Singleton can be created using an internal static class that acts as an object Holder.

    Check the example.

    package it.example.singleton;

import java.io.Serializable;

public class SingletonExample implements Serializable{
    
    private final static class StaticHolder{
        public final static SingletonExample INSTANCE = new SingletonExample();
    }
    
    private SingletonExample(){
        //Initialize class if needed
        ;
    }
    
    public static SingletonExample get(){
        return StaticHolder.INSTANCE;
    }
    
    private Object readResolve() {
        return StaticHolder.INSTANCE;
    }

}
    Reply

  2. Björn Kautler says

    Your double-checked locking singleton is NOT thread safe. It can happen that callers get a partially initialized object to be used and crash. Read more about it and how to do it correctly here: https://en.wikipedia. org/wiki/Double-checked_locking#Usage_in_Java

    Reply

Leave a Reply

Comment Policy: We welcome relevant and respectful comments. All comments are manually moderated and those deemed to be spam or solely promotional will be deleted.