Java Singleton Design Pattern: Definition, Implementation, and Best Practices

1. Introduction to the Singleton Pattern

The Singleton Pattern is a creational design pattern that restricts the instantiation of a class to one object, ensuring that only one instance of the class exists in the system at any given time. This pattern is useful in scenarios where there is a need to have only one instance of a class, such as a configuration object or a database connection object.

Table of Contents

  1. Introduction to the Singleton Pattern
  2. Singleton Class Definition and Implementation 2.1. Private Constructor 2.2. Static Instance Variable 2.3. Public Static Method to Retrieve Instance
  3. Singleton Class Usage 3.1. Instantiating the Singleton Object 3.2. Accessing the Singleton Object
  4. Singleton Class Design Considerations 4.1. Thread Safety 4.2. Serialization 4.3. Cloning
  5. Advantages and Disadvantages of Singleton Pattern
  6. Conclusion

2. Singleton Class Definition and Implementation

Singleton Class Definition

To define a Singleton class, we need to ensure that only one instance of the class exists in the system at any given time. This can be achieved by following these steps:

2.1. Private Constructor:

The first step is to create a private constructor that prevents the direct creation of objects of that class. This is because the Singleton class should not be instantiated directly but only through a static method that returns the single instance of the class.

Here's an example of a private constructor for a Singleton class:

csharp
public class Singleton {
    private Singleton() {
        // Private constructor to prevent direct instantiation
    }
}

Note that the constructor is marked as private to prevent direct instantiation of the class.

2.2. Static Instance Variable:

The second step is to create a static instance variable of the class. This variable holds the single instance of the class that will be returned by the static method.

Here's an example of a static instance variable for a Singleton class:

csharp
public class Singleton {
    private static Singleton instance = null;
    private Singleton() {
        // Private constructor to prevent direct instantiation
    }
}

Note that the instance variable is marked as private and static. It is private to prevent direct access from outside the class, and it is static to ensure that there is only one instance of the variable for the entire class.

2.3. Public Static Method to Retrieve Instance:

The final step is to create a public static method that returns a single instance of the class. This method is responsible for creating the instance if it does not exist and returning it if it already exists.

Here's an example of a public static method for a Singleton class:

csharp
public class Singleton {
    private static Singleton instance = null;
    private Singleton() {
        // Private constructor to prevent direct instantiation
    }
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

Note that the getInstance() method is marked as public and static. It is public to allow access from outside the class, and it is static to ensure that it can be accessed without creating an instance of the class.

2.4. Singleton Class Implementation:

To implement a Singleton class, we need to ensure that there is only one instance of the class throughout the system. This can be achieved by following these steps:

  1. Define a private constructor:

As discussed above, we need to define a private constructor to prevent direct instantiation of the class. This ensures that the Singleton class cannot be created more than once.

csharp
private Singleton() {
    // Private constructor to prevent direct instantiation
}

  1. Create a static instance variable:

We need to create a static instance variable of the class. This variable holds the single instance of the class that will be returned by the static method.

java
private static Singleton instance = null;

Note that the instance variable is marked as private and static. It is private to prevent direct access from outside the class, and it is static to ensure that there is only one instance of the variable for the entire class.

  1. Create a public static method to retrieve the instance:

We need to create a public static method that returns the single instance of the class. This method is responsible for creating the instance if it does not exist and returning it if it already exists.

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

Note that the getInstance() method is marked as public and static. It is public to allow access from outside the class, and it is static to ensure that it can be accessed without creating the instance of the class.


3. Singleton Class Usage

Once we have defined and implemented a Singleton class, we can use it in our application. Here are the steps to use a Singleton class:

3.1. Instantiating the Singleton Object:

We cannot directly create an object of the Singleton class since its constructor is private. Instead, we must use the public static method getInstance() to retrieve the Singleton object.

java
Singleton singleton = Singleton.getInstance();

This statement retrieves the Singleton object and assigns it to the variable singleton.

3.2. Accessing the Singleton Object:

We can access the methods and properties of the Singleton object as we would with any other object.

scss
singleton.doSomething();

This statement calls the doSomething() method on the Singleton object.

Here's an example of how we can use a Singleton class:

typescript
public class MyApp {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        singleton.doSomething();
    }
}

In this example, we retrieve the Singleton object and call its doSomething() method.

Note that we only retrieve the Singleton object once, and all subsequent calls to getInstance() return the same instance. This ensures that there is only one instance of the Singleton class throughout the application.

3.3. Singleton Class Usage Best Practices:

Here are some best practices to keep in mind when using a Singleton class:

  1. Keep the Singleton class simple and focused:

    The Singleton class should have a single responsibility, and its methods and properties should be focused on that responsibility. This makes the class easier to understand, maintain, and test.

  2. Use lazy initialization for the Singleton object:

    Lazy initialization means that the Singleton object is created only when it is needed. This can improve performance and reduce memory usage in large applications.

  3. Avoid using Singleton objects across multiple threads:

    Singleton objects are not thread-safe by default, which means that multiple threads may access and modify the same instance concurrently. To avoid this issue, we can use synchronized blocks or double-checked locking to ensure that only one thread can access the Singleton object at a time.

  4. Avoid using the Singleton pattern excessively:

    While the Singleton pattern can be useful in some situations, it should not be used excessively. Overusing the Singleton pattern can lead to code that is difficult to understand and maintain, and can also make testing more difficult.

4. Singleton Class Design Considerations

When designing a Singleton class, there are some important considerations to keep in mind. These considerations include thread safety, serialization, and cloning.

4.1. Thread Safety:

One of the most important considerations when designing a Singleton class is thread safety. Since a Singleton class allows only one instance of the class to be created, multiple threads accessing the class simultaneously can result in race conditions and unpredictable behavior.

To ensure thread safety, we can use various techniques such as:

  • Synchronization: We can use synchronized methods or synchronized blocks to ensure that only one thread can access the Singleton object at a time.
  • Double-checked locking: This technique uses a synchronized block to check if the Singleton object has already been created before creating a new instance. This can improve performance by avoiding unnecessary synchronization.
  • Enum-based Singleton: Enum-based Singleton is thread-safe by default as enums are guaranteed to be instantiated only once in a Java program.

Here's an example code for thread safety in Singleton:

csharp
public class ThreadSafeSingleton {
    private static ThreadSafeSingleton instance;
    
    // private constructor to prevent instantiation from outside the class
    private ThreadSafeSingleton() {
    }
    
    // synchronized method to provide thread-safe access to Singleton instance
    public static synchronized ThreadSafeSingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeSingleton();
        }
        return instance;
    }
}

In the code above, the getInstance() method is marked as synchronized, which means that only one thread can access this method at a time. This ensures that only one instance of the Singleton object is created even in a multi-threaded environment.

However, note that synchronizing the getInstance() method can cause a performance penalty, as only one thread can access the method at a time, even if the Singleton object has already been instantiated. In some cases, it may be more efficient to use double-checked locking or other techniques to ensure thread safety without incurring this performance penalty.

4.2. Serialization:

Serialization is the process of converting an object into a stream of bytes for storage or transmission. When a Singleton class is serialized and deserialized, it can result in multiple instances of the Singleton class.

To ensure that only one instance of the Singleton class is created during serialization and deserialization, we can implement the readResolve() method in the Singleton class. This method returns the existing Singleton object and prevents the creation of a new instance.

Here's an example of the readResolve() method:

csharp
private Object readResolve() throws ObjectStreamException {
    return INSTANCE;
}

In this example, the readResolve() method returns the existing Singleton instance.

Example code for implementing Serialization in Singleton:

java
import java.io.Serializable;

public class SerializableSingleton implements Serializable {
    private static final long serialVersionUID = 1L;
    private static SerializableSingleton instance;
    
    // private constructor to prevent instantiation from outside the class
    private SerializableSingleton() {
    }
    
    // synchronized method to provide thread-safe access to Singleton instance
    public static synchronized SerializableSingleton getInstance() {
        if (instance == null) {
            instance = new SerializableSingleton();
        }
        return instance;
    }
    
    // readResolve method to ensure the same instance is returned after deserialization
    protected Object readResolve() {
        return getInstance();
    }
}

In the code above, the SerializableSingleton class implements the Serializable interface. The readResolve() method is also added to the class to ensure that the same instance of the Singleton object is returned after deserialization.

Note that the readResolve() method is marked as protected, which means that it can only be accessed within the same package or by a subclass of the SerializableSingleton class. This helps to ensure that the Singleton object cannot be instantiated from outside the class or modified during the deserialization process.

To serialize the SerializableSingleton object, you can use the standard Java serialization APIs, as follows:

csharp
SerializableSingleton instance = SerializableSingleton.getInstance();
// serialize the instance
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("filename.ser"));
out.writeObject(instance);
out.close();

// deserialize the instance
ObjectInputStream in = new ObjectInputStream(new FileInputStream("filename.ser"));
SerializableSingleton newInstance = (SerializableSingleton) in.readObject();
in.close();

// ensure that the same instance is returned after deserialization
System.out.println("Is the same instance? " + (instance == newInstance)); // Output: true

In the code above, the SerializableSingleton object is serialized to a file using the ObjectOutputStream class, and then deserialized from the same file using the ObjectInputStream class. The readResolve() method ensures that the same instance of the Singleton object is returned after deserialization.


4.3. Cloning:

Cloning is the process of creating a copy of an object. Since a Singleton class allows only one instance of the class to be created, we must prevent cloning of the Singleton object.

To prevent cloning, we can override the clone() method in the Singleton class and throw a CloneNotSupportedException exception. Here's an example of the clone() method:

java
@Override
protected Object clone() throws CloneNotSupportedException {
    throw new CloneNotSupportedException();
}

In this example, the clone() method throws a CloneNotSupportedException exception, preventing the cloning of the Singleton object.

Singleton Class Design Considerations Best Practices:

Here are some best practices to keep in mind when designing a Singleton class:

  1. Make the Singleton class thread-safe:

    To ensure that a Singleton class is thread-safe, we can use techniques such as synchronization, double-checked locking, or enum-based Singleton.

  2. Implement the readResolve() method for serialization:

    To ensure that only one instance of the Singleton class is created during serialization and deserialization, we can implement the readResolve() method.

  3. Prevent cloning of the Singleton object:

    To prevent cloning of the Singleton object, we can override the clone() method in the Singleton class and throw a CloneNotSupportedException exception.

By keeping these best practices in mind, we can ensure that our Singleton class is well-designed and can be used safely and efficiently in our application.

  1. Advantages of Singleton Pattern:

The Singleton Pattern offers several advantages in software development, including:

  • Single Instance: The Singleton Pattern guarantees that there is only one instance of the class in the entire application, which can be useful for classes that represent resources or services that need to be shared across the application.
  • Global Access: Since the Singleton object is globally accessible, it can be used throughout the application without the need for passing references to the object.
  • Lazy Initialization: The Singleton Pattern allows for lazy initialization of the Singleton object, which can improve performance and reduce memory usage in some cases.
  • Thread Safety: If implemented correctly, the Singleton Pattern can provide thread-safe access to the Singleton object, ensuring that multiple threads cannot access or modify the object simultaneously.
  • Controlled Access: The Singleton Pattern allows for controlled access to the Singleton object, making it easier to manage and maintain the object in the application.

  1. Disadvantages of Singleton Pattern:

While the Singleton Pattern offers several advantages, it also has some drawbacks, including:

  • Dependency Injection: The Singleton Pattern can make dependency injection more difficult since the Singleton object is globally accessible, making it harder to control the object's dependencies and lifecycle.
  • Testing: The Singleton Pattern can make unit testing more difficult since the Singleton object is shared across the application, making it harder to isolate and test individual components.
  • Inflexibility: The Singleton Pattern can be inflexible, making it harder to change the behavior of the Singleton object at runtime.
  • Global State: The Singleton Pattern can create a global state in the application, which can make it harder to manage and maintain the application's state.

  1. Conclusion:

The Singleton Pattern can be a useful pattern for creating a single instance of a class in an application. However, it is important to consider the advantages and disadvantages of the pattern before using it in your application.

If used correctly, the Singleton Pattern can provide several benefits, including single instance, global access, lazy initialization, thread safety, and controlled access. However, the pattern can also have drawbacks, including dependency injection, testing, inflexibility, and global state.

When deciding whether to use the Singleton Pattern in your application, it is important to weigh the benefits and drawbacks carefully and consider the specific needs of your application.


Author
Vaneesh Behl
Passionately writing and working in Tech Space for more than a decade.

Comments

Post a Comment

Popular posts from this blog

Top 7 Web Development Trends in the Market

Image
  Technology continues to advance as humans discover new methods to innovate, doing tasks quicker and more creatively than before. Developers are continuously on the lookout for new technologies that will help them move forward towards a better future.  The contemporary industry is constantly evolving, and new online technologies emerge daily. Entrepreneurs that want to interact with more consumers and stay ahead in this competitive industry may take advantage of these new trends. There aren't many industries that have as much innovation as bespoke web development. Hire WordPress developer to help entrepreneurs interact with more consumers and stay ahead. Websites, without a question, play an important part in today's commercial environment. A WordPress design agency will build you a website that functions as a separate brand, organization, and individual. Doing business on a worldwide scale has become conceivable and attainable as firms and enterprises have transcended all bou
Read more

Top 10 Highly Paid Indian CEOs in the USA

Image
Top Indian CEOs in the USA Indian Americans have been making significant contributions to the US economy for decades. Many Indian-origin executives have reached the pinnacle of success in American corporations and hold some of the highest-paid positions in the country. In this post, we will take a look at the top 10 highly paid Indian-origin CEOs in the USA, their history, academics, salary, and net worth. 1. Sunder Pichai   Salary US$ 199.7 million Sundar Pichai is the CEO of Google and Alphabet Inc. Born in Tamil Nadu, India, Pichai grew up in a middle-class family and earned a Bachelor’s degree in Metallurgical Engineering from the Indian Institute of Technology in Kharagpur. He went on to earn a Master’s degree in Material Sciences and Engineering from Stanford University and an MBA from the Wharton School of the University of Pennsylvania. Pichai joined Google in 2004 and rose through the ranks to become CEO in 2015. His annual salary in 2021 was $2 million, and his net wort
Read more

17 Best Demo Websites for Automation Testing Practice

Image
We need demo websites for various purposes, like learning new tools and for automation testing practice. In this post, we cherry-picked some of the best websites to practice Selenium automation testing. This set of demo websites would help you to enhance your automation skills.  This post can help various people like,  Automation Testing learners, Experienced professionals, and even Automation Testing tutors/teachers. They all can benefit from these demo websites. Table of Contents 1. Techlistic Automation Practice Form 2. Amazon like Demo E-Commerce Website 3. Make My Trip like Travel Portal 4. Demo Automation Practice Web Table 5. Google.com 6. Demo Website for Handling Alerts 7. Way2Automation Demo 8. NewTours DemoAUT 9. The Demo Site 10. DemoQA 11. Para Bank 12. Orange HRM 13. Sauce Labs Demo E-Commerce Site 14. Demo Bank Demo Websites for API Automation Testing Practice 15. Restful Booker 16. Pet Store 17. Demo REST API Best Demo Websites for Automation Practice Let's take
Read more

Automation Practice: Automate Amazon like E-Commerce Website with Selenium

Image
In this post, you will learn to automate different functionalities of an e-commerce website. To automate this practice assignment,  you should have sound knowledge of all the Selenium concepts. We'll create a test plan and then automate an e-commerce website that is quite similar to amazon.com. Automate Amazon-like e-Comm website with Selenium for Automation Practice Table of Content 1. What should you know before starting this Project assignment? 2. Which functionalities will we automate in this Project assignment? 3. Create Test Plan for Amazon like e-commerce website 4. Automate Amazon like e-commerce website: Automate User Registration and Login of e-commerce website Automate Search feature of e-commerce website Automate "Buy Product" feature of e-Commerce website 1. What should you know before automating this automation assignment? You should know the following topics, before starting this project assignment: Software Testing Concept
Read more

Java Date Format Validation with Regular Expressions: A Step-by-Step Guide

Image
1. Introduction Validating date formats is an essential aspect of many software applications. It ensures that the user inputs a date in the correct format, reducing the risk of errors and inconsistencies in data. Regular expressions are a powerful tool for validating date formats. In this tutorial, we will explore how to validate date formats using regular expressions in Java.
Read more

How I learned Selenium WebDriver in just 4 weeks

Image
You can learn Selenium WebDriver yourself in just 1 month, yes you read it right! If you want above statement to work for you, then you would have to come up with a proper study plan and follow it with discipline. Discipline is the key here. Let me help you to make that study plan and also will share very useful blog posts links for the same, later in this post. Table of Content 1. My Story of becoming Selenium Professional 2. My Experiments with Selenium 3. Future of Selenium Automation Testing 4. Which language has a better career prospect with Selenium - Java or Python? 5. The 4 Weeks Plan to Learn Selenium WebDriver 6. What next after being Selenium expert? 1. My Story of becoming a Selenium Automation Professional I started my career way back in 2011 as a Manual Software Tester. I had interest in Java but didn't have much practical knowledge of it. I started learning Java slowly. It took some time to get some good  knowledge on Java. Then in 2012 I switched my first c
Read more

14 Best Selenium Practice Exercises for Automation Practice

Image
  This page contains the list of Selenium Program exercises for automation practice. Your skills will definitely get a boost after solving these Selenium Practice Assignments. In these assignments, you will find the Sample Applications for Automation Testing . These Practice Assignments are designed in such a way that learners can enhance their automation skills. They also include multiple Sample Test Cases for Selenium along with step-by-step description which needs to be automated.  Reference links to  Selenium WebDriver Commands  for solutions are provided in the assignments. 10 Best Selenium Practice Exercises for Automation Practice Automate Amazon-like e-Comm Website with Selenium WebDriver In this self-learning project assignment, we'll automate all the major e-commerce website features with Selenium and Java. We'll automate Sign-up and login, search products, and purchase products for Amazon an e-commerce website. Automate GoDaddy.com Website features with Selenium WebD
Read more

Automate GoDaddy.com Features with Selenium WebDriver

Image
This post contains two assignments that helps you to learn Selenium browser commands. These are the simplest assignments. So, this assignment post is the best suited to start your automation tester journey. 1. Automate Browser Actions on GoDaddy.com If you are a beginner in automation testing and looking forward to writing your first Selenium code, then this post is the best destination for you. This assignment will teach you the basic commands of Selenium Webdriver to perform basic actions like., Launch the browser, maximize the browser window, validate the page title, and close the browser. In this post, you will find very basic step-by-step assignments which will upgrade your understanding of Selenium Webdriver and its commands. 1. Test Case - Open Godaddy.com and maximize the browser window. Steps to Automate:
Read more

Install Appium and Dependencies for Mobile Automation

Image
1. Setting Up the Appium Environment To get started with Appium, you need to have the following software installed on your system: Java Development Kit (JDK) Android Studio (for Android testing) Xcode (for iOS testing) Node.js Appium Desktop or Appium Server You can download and install all these tools from their respective websites. Once you have installed these tools, you can follow the steps below to set up your Appium environment. Step 1: Install Node.js Node.js is a JavaScript runtime that allows you to run JavaScript code outside the browser. Appium is built using Node.js, so you need to install it on your system before you can start using Appium. You can download Node.js from the official website: https://nodejs.org/en/download/ . Once you have downloaded the installer, run it and follow the prompts to complete the installation. Step 2: Install Appium Appium can be installed in two ways: Appium Desktop and Appium Server. Appium Desktop is a graphical user interface (GUI) applica
Read more

Test-aliens are here on Earth, Go slow developers!

Image
 Why should a company have a team for Software Testing and Quality Assurance? What is the need to test a software? Why shouldn't developers test their own work? When I started my career around two years back I encountered above listed queries. At that time I had no reply to these queries. But after dwelling around two years in IT sector I come along with some firm replies. All above listed questions are inter-belonging and the highlighted one was recently posted in a programmer's Q&A post, it inevitably raised my curious eyebrow. This can be a big debate. Diving straight to the point, the simple, unmistakable and well known answer is : “Developers are not very good testers.” But according to my understanding correct answer is, - “They don't want to see bugs in their code and only look for happy paths and and happy endings.” Believe me I was a developer in the past and then I moved to QA to avoid QA on my code, now I'm coding Automated Selenium Scrip
Read more