{"id":31367,"date":"2023-10-20T11:44:21","date_gmt":"2023-10-20T10:44:21","guid":{"rendered":"https:\/\/www.baeldung.com\/java-patterns-singleton-cons"},"modified":"2023-10-20T11:44:21","modified_gmt":"2023-10-20T10:44:21","slug":"drawbacks-of-the-singleton-design-pattern","status":"publish","type":"post","link":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/2023\/10\/20\/drawbacks-of-the-singleton-design-pattern\/","title":{"rendered":"Drawbacks of the Singleton Design Pattern"},"content":{"rendered":"

\"\"<\/p>\n

1. Overview<\/h2>\n
<\/div>\n

Singleton is one of the creational design patterns<\/a>\u00a0published by the Gang of Four in 1994.<\/p>\n

Because of its simple implementation, we tend to overuse it. Therefore, nowadays, it\u2019s considered to be an anti-pattern. Before introducing it in our code, we should ask ourselves if we really need the functionality it provides.<\/p>\n

In this tutorial, we\u2019ll discuss the general drawbacks of the\u00a0Singleton<\/a> design pattern and see some alternatives we can use instead.<\/p>\n

2. Code Example<\/h2>\n
<\/div>\n

First, let’s create a class we’ll use in our examples:<\/p>\n

public class Logger {\r\n    private static Logger instance;\r\n    private PrintWriter fileWriter;\r\n    public static Logger getInstance() {\r\n        if (instance == null) {\r\n            instance = new Logger();\r\n        }\r\n        return instance;\r\n    }\r\n    private Logger() {\r\n        try {\r\n            fileWriter = new PrintWriter(new FileWriter("app.log", true));\r\n        } catch (IOException e) {\r\n            e.printStackTrace();\r\n        }\r\n    }\r\n    public void log(String message) {\r\n        String log = String.format("[%s]- %s", LocalDateTime.now(), message);\r\n        fileWriter.println(log);\r\n        fileWriter.flush();\r\n    }\r\n}<\/code><\/pre>\n
The class above represents a simplified class for logging into the file. We implemented it as a singleton, using the lazy initialization approach.<\/p>\n
3. Disadvantages of Singleton<\/h2>\n
<\/div>\n
By definition, the Singleton pattern ensures a class has only one instance and, additionally, provides global access to this instance. Therefore, we should use it in cases where we need both of those things.<\/p>\n
Looking at its definition, we can notice it violates the Single Responsibility Principle<\/a>.<\/strong> The principle states one class should have only one responsibility.<\/p>\n
However, the Singleton pattern has at least two responsibilities – it ensures the class has only one instance and contains business logic.<\/p>\n
In the next sections, we\u2019ll discuss some other pitfalls of this design pattern.<\/p>\n
3.1. Global State<\/h3>\n
<\/div>\n
We know global states<\/a> are considered to be a bad practice and, thus, should be avoided.<\/p>\n
Although it may not be obvious, a singleton introduces global variables in our code, but they\u2019re encapsulated within a class.<\/p>\n
Since they’re global, everyone can access and use them. Moreover, if they aren\u2019t immutable, everyone can change them as well.<\/strong><\/p>\n
Suppose we use the Logger<\/em> class in several places in our code. Everyone can access and modify its values.<\/p>\n
Now, if we encounter a problem in one method that uses it and discover the problem is in the singleton itself, we need to check the entire codebase and every method that uses it to find the impact of the problem.<\/p>\n
This can quickly become a bottleneck for our application.<\/p>\n
3.2. Code Flexibility<\/h3>\n
<\/div>\n
Next, in terms of software development, the only certainty lies in the fact our code will likely change in the future.<\/p>\n
When a project is in the early stages of development, we can make the assumption there will be no more than one instance of certain classes and define them using the Singleton design pattern.<\/p>\n
However, if requirements change and our assumption turns out to be incorrect, we\u2019d need to put a big effort into refactoring our code.<\/strong><\/p>\n
Let\u2019s discuss the problem above in our working example.<\/p>\n
We assumed we\u2019d only need one instance of our Logger<\/em> class. What if, in the future, we decide one file isn’t enough?<\/p>\n
For instance, we might need separate files for errors and info messages. Additionally, one instance of a class wouldn’t be enough anymore. Next, in order to make the modification possible, we\u2019d need to refactor our entire codebase and remove the singleton, which would require a lot of effort.<\/p>\n
With singletons, we\u2019re making our code tightly coupled and less flexible.<\/strong><\/p>\n
3.3. Dependency Hiding<\/h3>\n
<\/div>\n
Moving forward, singleton promotes hidden dependencies.<\/p>\n
To put it differently, when we\u2019re using them in other classes, we\u2019re hiding the fact these classes depend on a singleton instance.<\/strong><\/p>\n
Let’s consider the sum()<\/em> method:<\/p>\n
public static int sum(int a, int b){\r\n    Logger logger = Logger.getInstance();\r\n    logger.log("A simple message");\r\n    return a + b;\r\n}<\/code><\/pre>\n
If we don’t look directly at the implementation of the sum()<\/em> method, we have no way of knowing it uses the Logger<\/em> class.<\/p>\n
We didn\u2019t pass the dependencies as usual, as arguments to the constructor or a method.<\/p>\n
3.4. Multithreading<\/h3>\n
<\/div>\n
Next, in a multithreaded environment, singletons can be tricky to implement.<\/p>\n
The main problem is that the global variables are visible to all threads in our code.<\/strong> Moreover, each thread is unaware of the activities other threads make on the same instance.<\/p>\n
Therefore, we can end up facing different problems, such as race conditions<\/a> and other synchronization issues.<\/p>\n
Our earlier implementation of the Logger<\/em> class won\u2019t work well in a multithreaded environment. Nothing in our method prevents multiple threads from accessing the getInstance()<\/em> method at the same time. As a result, we can end up having more than one instance of the Logger<\/em> class.<\/p>\n
Let\u2019s modify the getInstance()<\/em> method with the synchronized<\/em><\/a> keyword:<\/p>\n
public static Logger getInstance() {\r\n    synchronized (Logger.class) {\r\n        if (instance == null) {\r\n            instance = new Logger();\r\n        }\r\n    }\r\n    return instance;\r\n}<\/code><\/pre>\n
We\u2019re now forcing every thread to wait its turn. However, we should be aware having synchronization is expensive. In addition, we are introducing an overhead to our method.<\/p>\n
If necessary, one of the ways we can solve our problem is by applying the double-checking locking<\/a> mechanism:<\/p>\n
private static volatile Logger instance;\r\npublic static Logger getInstance() {\r\n    if (instance == null) {\r\n        synchronized (Logger.class) {\r\n            if (instance == null) {\r\n                instance = new Logger();\r\n            }\r\n        }\r\n    }\r\n    return instance;\r\n}<\/code><\/pre>\n
However, we should keep in mind the JVM<\/a> allows access to partially constructed objects, which may lead to unexpected behaviors of our program<\/strong>. Therefore, it’s required to add the volatile<\/em><\/a> keyword to the instance<\/em> variable.<\/p>\n
Other alternatives we might consider include:<\/p>\n