The Singleton Pattern
The singleton pattern is one of the simplest design patterns in Java. This design pattern is considered a creational pattern, as this pattern provides one of the best ways to create an object.
Sometimes it’s important for some classes to have exactly one instance. There are many times when we only need one instance of an object and if we instantiate more than one we’ll run into all sorts of problems, like incorrect program behavior, overuse of resources, or inconsistent results. You may require only one object of a class, for example, when you are creating:
- the context of an application.
- a thread manageable pool.
- registry settings.
- a driver to connect to the input or output console.
- and much more.
More than one object of that type clearly will cause inconsistency to our code.
The singleton pattern ensures that a class has only one instance and provides a global point of access to it. Although a singleton is the simplest in terms of its class diagram, because there is only one single class, its implementation is a bit trickier.
Motivation
Sometimes it's important to have only one instance for a class. For example, in a system there should be only one window manager or only one print spooler. Usually, singletons are used for centralized management of internal or external resources and they provide a global point of access to themselves.
The singleton pattern involves only one class which is required to instantiate itself and to make sure it creates no more than one instance.
At the same time, it provides a global point of access to that instance. In this case, the same instance can be accessed from anywhere, making it impossible to directly invoke the constructor each time.
How to Create a Class Using the Singleton Pattern
While there are many ways to create such a class, we will take a look the methods that have worked for me in the past.
Let’s start with a simple way. What if we provide a global variable that makes an object accessible? For example:
As we know, there is only one copy of the static variables of a class; we can apply this. As far as the client code using this sc
static variable... it's fine. But, if the client uses a new operator there would be a new instance of this class. To stop the class from getting instantiated outside the class, let’s make the constructor of the class private.
Is this going to work? I believe so. By keeping the constructor private, no other class can instantiate this class. The only way to get the object of this class is by using the sc
static variable, which ensures only one object is there. But, as we know, providing direct access to a class member is not a good idea. We will provide a method through which the sc
variable will get access, but not directly.
So, this is our singleton class, which makes sure that only one object of the class gets created and, even if there are several requests, only the same instantiated object will be returned. The one problem with this approach is that the object will get created as soon as the class gets loaded into the JVM. If the object is never requested, there will be a useless object inside the memory. It’s always a good approach that an object should get created when it is required. So, we will create an object on the first call and then return the same object on successive calls.
In the getInstance()
method, we check if the static variable sc
is null, then instantiate the object and return it. So, on the first call when sc
would be null, the object gets created and on successive calls it will return the same object. This surely looks good, doesn’t it? But this code will fail in a multi-threaded environment. Imagine two threads concurrently accessing the class, thread t1 gives the first call to the getInstance()
method, it checks if the static variable sc
is null, and then gets interrupted. Another thread (t2) calls the getInstance()
method, successfully passes the if
check, and instantiates the object. Then, thread t1 gets awoken and it also creates the object.
At this time, we have two objects of this class. To avoid this, we will use the synchronized keyword with the getInstance()
method. In this way, we force every thread to wait its turn before it can enter the method. So, no two threads will enter the method at the same time. The synchronized comes with a price, it will decrease the performance, but if the call to the getInstance()
method isn’t causing a substantial overhead for your application, forget about it. The other workaround is to move to an eager instantiation approach as shown in the previous example.
But if you want to use synchronization, there is another technique known as "double-checked locking" to reduce the use of synchronization. With the double-checked locking, we first check to see if an instance is created and, if not, then we synchronize it. This way, we only synchronize the first time.
Apart from this, there are some other ways to break the singleton pattern.
- If the class is serializable.
- If it’s clonable.
- If can be broken by reflection.
- If the class is loaded by multiple class loaders.
The following example shows how you can protect your class from getting instantiated more than once.
- Implement the
readResolve()
andwriteReplace()
methods in your singleton class and return the same object through them. - You should also implement the
clone()
method and throw an exception so that the singleton cannot be cloned. - An "if condition" inside the constructor can prevent the singleton from getting instantiated more than once using reflection.
- To prevent the singleton from getting instantiated from different class loaders, you can implement the
getClass()
method. The abovegetClass()
method associates the classloader with the current thread; if that classloader is null, the method uses the same classloader that loaded the singleton class.
Although we can use all these techniques, there is an easier way of creating a singleton class. As of JDK 1.5, you can create a singleton class using enums. The enum constants are implicitly static and final and you cannot change their values once created.
You will get a compile-time error when you attempt to explicitly instantiate an enum object. As enum gets loaded statically, it is thread-safe. The clone method in enum is final, which ensures that enum constants never get cloned. Enum is inherently serializable, the serialization mechanism ensures that duplicate instances are never created as a result of deserialization. Instantiation using reflection is also prohibited. These things ensure that no instance of an enum exists beyond the one defined by the enum constants.
When to Use Singletons
- There must be exactly one instance of a class, and it must be accessible to clients from a well-known access point.
- The sole instance is extensible by subclassing and clients can use an extended instance without modifying their code.
Pros and Cons of Using Singletons
Pros
- You can be sure that a class has only a single instance.
- You gain a global access point to that instance.
- The singleton object is initialized only when it’s requested for the first time.
Cons
- Violates the Single Responsibility Principle. The pattern solves two problems at a time.
- The Singleton pattern can mask bad design, for instance, when the components of the program know too much about each other.
- The pattern requires special treatment in a multithreaded environment so that multiple threads won’t create a singleton object several times.
- It may be difficult to unit test the client code of the singleton because many test frameworks rely on inheritance when producing mock objects. Since the constructor of the singleton class is private and overriding static methods is impossible in most languages, you will need to think of a creative way to mock the singleton. Otherwise, just don’t write the tests or use the Singleton pattern.
Conclusion
In the above article, we have gone into detail about the singleton pattern and how to implement the singleton pattern along with a practical demonstration. Though the singleton pattern looks like a simple implementation, we should resist using it until and unless there is a strong requirement for it. You can blame the unpredictable nature of the results on the multi-threading environment. Though we can use enum in Java 5+, sometimes it's difficult to implement your logic in an enum or there might be legacy code before Java 5 you have to contend with.
相关推荐
单例模式单例模式单例模式单例模式单例模式单例模式单例模式单例模式
C#单例模式C#单例模式详解C#单例模式详解C#单例模式详解
单例模式详解~~单例模式详解~~单例模式详解~~
2020-02-10 王争设计模式之美进入课程讲述:冯永吉时长 10:21大小 8.31M上两节课中,我们针对单例模式,讲解了单例的应用场景、几种常见的代码实现
首先向关注过我这个系列...这立刻让我想到了最常用也是最简单最容易理解的一个设计模式 单例模式 何为 单例模式 ? 故名思议 即 让 类 永远都只能有一个实例。 由于 示例代码 比较简单 我也加了注释,这里就不在赘述
单例模式是最简单的设计模式之一,但是对于Java的开发者来说,它却有很多缺陷。在本月的专栏中,David Geary探讨了单例模式以及在面对多线程(multithreading)、类装载器(classloaders)和序列化(serialization)时...
单例模式的七种实现方法以及分析,可以作文大作业提交 1.前言 4 1.1 课题的研究背景 4 1.2 课题主要研究目标 4 2.相关技术简介 4 2.1Java简介 4 2.2IDEA简介 4 3. 单例模式的7种实现方式 5 3.1饿汉式(使用静态常量...
一个简单的java工程,包含注释,一目了然,其中包含了单例模式的所有实现方式,懒汉式,饿汉式,双重校验,枚举,静态内部类等方式实现单例。
单例模式--只能弹出一个窗体 只能弹出一个窗体
设计模式之七种单例模式代码及ppt,包含多线程环境测试和反序列化测试
单例模式和工厂模式结合应用,实现了产品的生产,适合用做课程设计,包含详细文档和代码。Java语言。喜欢的可以下载来看看那
几种单例模式的书写方式
使用单例模式创建学生管理系统(饿汉式、懒汉式)
php单例模式php单例模式php单例模式php单例模式
模式就像是OOP开发人员的配方,每种模式都提供了所需的成分。模式对OOP开发人员尤其有用,因为它有助于创建稳定的API,...本章将介绍两种常用的模式:单例模式和工厂模式。前者被称为类的职责,后者被称为类的多态性。
这个讲的是单例模式的多种不同实现方式,希望对单例感兴趣的同学看看
是http://blog.csdn.net/lxq_xsyu/article/category/1544127博客中java设计模式的源代码。下载前请先看《设计模式——单例模式》一文。
Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式...
设计模式C++学习之单例模式(Singleton)
此示例展示了Qml 的单例模式(类似全局对象,只生成一次实例,可全局使用) surfsky.cnblogs.com