Services
Technology Web App Development Mobile App Development Windows App Development Database Development UI/UX Development Cloud Development SEO Digital Marketing Guest Posting Content Writing Artificial Intelligence Data Science ERP Development CRM Development CMS Development LMS Development Business Listing Blockchain Technology Startup Promotion
Products
Data Converter Cleaner TUC - Unit Converter Import Export Survey Manager Tweet Controller
Developer
Article Blog Forum Interview Beginner News Startup Quiz
Users
Career
Apply Job Internship
Pricing
Login Sign Up Get a Quote

forum

home / developersection / forums / how do you implement a singleton pattern in java?
Ask Question

How do you implement a singleton pattern in Java?

Anubhav Sharma 403 18 Jul 2024

How do you implement a singleton pattern in Java? Explain the different ways to create a singleton class.

java javajavac
Updated 18 Jul 2024
Anubhav Sharma
Anubhav Sharma

Student

The Anubhav portal was launched in March 2015 at the behest of the Hon'ble Prime Minister for retiring government officials to leave a record of their experiences while in Govt service .

Message

1 Answers

Ravi Vishwakarma
Ravi Vishwakarma 18 Jul 2024
Report Abuse

The Singleton pattern ensures that a class has only one instance and provides a global point of access to it. Here are different ways to create a singleton class in Java:

1. Eager Initialization

In eager initialization, the instance of the Singleton class is created at the time of class loading.

Pros:

  • Simple to implement.
  • The instance is created even if it might not be used.

Cons:

  • May cause resource wastage if the instance is never used.
public class EagerSingleton {
    private static final EagerSingleton instance = new EagerSingleton();

    // Private constructor to prevent instantiation
    private EagerSingleton() {}

    public static EagerSingleton getInstance() {
        return instance;
    }
}

2. Lazy Initialization

In lazy initialization, the instance is created only when it is needed.

Pros:

  • The instance is created only when requested, saving resources.

Cons:

  • Not thread-safe.
public class LazySingleton {
    private static LazySingleton instance;

    // Private constructor to prevent instantiation
    private LazySingleton() {}

    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

3. Thread-Safe Singleton (Synchronized Method)

This approach uses synchronization to make the getInstance method thread-safe.

Pros:

  • Thread-safe.

Cons:

  • Can be slow due to the synchronized method.
public class ThreadSafeSingleton {
    private static ThreadSafeSingleton instance;

    // Private constructor to prevent instantiation
    private ThreadSafeSingleton() {}

    public static synchronized ThreadSafeSingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeSingleton();
        }
        return instance;
    }
}

4. Double-Checked Locking

Double-checked locking reduces the overhead of acquiring a lock by first checking the condition without synchronization.

Pros:

  • Thread-safe.
  • High performance.

Cons:

  • Slightly more complex implementation.
public class DoubleCheckedLockingSingleton {
    private static volatile DoubleCheckedLockingSingleton instance;

    // Private constructor to prevent instantiation
    private DoubleCheckedLockingSingleton() {}

    public static DoubleCheckedLockingSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckedLockingSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckedLockingSingleton();
                }
            }
        }
        return instance;
    }
}

5. Bill Pugh Singleton (Static Inner Class)

This approach leverages the Java class loader mechanism to ensure that the instance is created only when the singleton class is loaded.

Pros:

  • Thread-safe.
  • Lazy initialization.
  • High performance.
public class BillPughSingleton {
    private BillPughSingleton() {}

    private static class SingletonHelper {
        private static final BillPughSingleton INSTANCE = new BillPughSingleton();
    }

    public static BillPughSingleton getInstance() {
        return SingletonHelper.INSTANCE;
    }
}

Summary

  • Eager Initialization: Simple but may waste resources.
  • Lazy Initialization: Efficient but not thread-safe.
  • Thread-Safe Singleton (Synchronized Method): Thread-safe but slow.
  • Double-Checked Locking: Thread-safe and high performance.
  • Bill Pugh Singleton (Static Inner Class): Thread-safe, lazy initialization, high performance.
  • Enum Singleton: Thread-safe, handles serialization, simple.

Read more 

Describe the life cycle of a thread in Java.

Explain the difference between checked and unchecked exceptions. Provide examples.

advertising