前情提要:最近在准备面试,发现自己以前学的东西都太窄,太浅了,只知其然而不知所以然,今天内心很复杂,写一下单例模式的总结吧。
~~单例模式是设计模式中最最经典的一种设计模式,也是日常使用、面试中常见的设计模式之一。
文章目录
一、定义
单例模式是指一个类只允许产生一个实例化对象。也是最好理解的一种设计模式。
单例模式有以下特点:
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
单例模式实现方式(8种):
- 饿汉式(静态常量)
- 饿汉式(静态代码块)
- 懒汉式(线程不安全)
- 懒汉式(线程安全,同步方法)
- 懒汉式(线程安全,同步代码块)
- 双重检查🌟❤️❤️
- 静态内部类 🌟
- 枚举🌟❤️
二、类图
所有单例的实现都包含以下两个相同的步骤:
- 将默认构造函数设为私有, 防止其他对象使用单例类的new运算符。
- 新建一个静态构建方法调用构造函数。 该函数会 “偷偷” 调用私有构造函数来创建对象, 并将其保存在一个静态成员变量中。此后所有对于该函数的调用都将返回这一缓存对象。
三、代码实现及解释
1. 饿汉式(静态常量)
饿汉式(当类加载进来的就立即实例化对象,但是这种方式比较的消耗计算机资源):构造方法私有化,外部无法产生新的实例化对象,只能通过static方法取得实例化对象。
具体实现步骤:
1)将采用单例设计模式的类的构造方法私有化(private修饰,防止new)。
2)在其内部产生该类的实例化对象instance,并将其封装成private static类型。
3)定义一个静态方法getInstance()返回该类的实例。
//【线程安全,效率低】
class Singleton {
private static Singleton instance = new Singleton(); // 2.在内部类产生本类的实例化对象
private Singleton() { // 1. 私有化构造方法
}
public static Singleton getInstance() { // 3.通过静态方法返回instance对象
return instance;
}
public void print() {
System.out.println("Hello Singleton...");
}
}
public class SingletonDemo {
public static void main(String[] args) {
Singleton instance1 = Singleton.getInstance();// 取得实例化对象
Singleton instance2 = Singleton.getInstance();
System.out.println(instance1 == instance2);
System.out.println("instance1.hashCode=" + instance1.hashCode());
System.out.println("instance2.hashCode=" + instance2.hashCode());
instance1.print();// 调用方法
}
}
//结果:
true
instance1.hashCode=1705929636
instance2.hashCode=1705929636
Hello Singleton...
评价:
- 优点:这种写法比较简单,就是在类装载的时候就完成实例化。避免了线程同步问题。
- 缺点:在类装载的时候就完成实例化,没有达到懒加载(Lazy Loading) 的效果。如果从始至终从未使用过这个实例,则会造成内存的浪费
- 这种方式基于 classloader 机制避免了多线程的同步问题,不过,instance 在类装载时就实例化,在单例模式中大多数都是调用 getInstance 方法, 但是导致类装载的原因有很多种,因此不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化 instance 就没有达到 lazy loading 的效果
- 结论:这种单例模式可用,可能造成内存浪费.
2. 饿汉式(静态代码块)
class Singleton {
private static Singleton instance;
static {
instance = new Singleton(); // 2.在内部类产生本类的实例化对象
}
private Singleton() { // 1. 私有化构造方法
}
public static Singleton getInstance() { // 3.通过静态方法返回instance对象
return instance;
}
}
public class SingletonDemo {
public static void main(String[] args) {
Singleton instance1 = Singleton.getInstance();// 取得实例化对象
Singleton instance2 = Singleton.getInstance();
System.out.println(instance1 == instance2);
System.out.println("instance1.hashCode=" + instance1.hashCode());
System.out.println("instance2.hashCode=" + instance2.hashCode());
instance1.print();// 调用方法
}
}
//结果:
true
instance.hashCode=1705929636
instance2.hashCode=1705929636
评价:
- 这种方式和上面的方式其实类似,只不过将类实例化的过程放在了静态代码块中,也是在类装载的时候,就执行静态代码块中的代码,初始化类的实例。优缺点和上面是一样的。
- 结论:这种单例模式可用,但是可能造成内存浪费.
3.懒汉式(线程不安全)
评价:
- 起到了 Lazy Loading的效果,但是只能在单线程下使用。
- 如果在多线程下,一个线程进入了 if (singleton == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。所以在多线程环境下不可使用这种方式
- 结论:在实际开发中,不要使用这种方式,多线程情况下会出现线程不安全的问题。
//【非线程安全,效率高】
class Singleton {
private static Singleton instance;
private Singleton() { //1. 私有化构造方法
}
public static Singleton getInstance() { //2.通过静态方法返回instance对象
// 3. 使用Singleton对象时才产生实例化对象操作
if (instance==null) { // code A
instance = new Singleton(); // code B
}
return instance;
}
public void print() {
System.out.println("Hello Singleton...");
}
}
public class SingletonDemo{
public static void main(String[] args) {
Singleton singleton = null;//声明对象
singleton=Singleton.getInstance();//取得实例化对象
singleton.print();//调用方法
}
}
假设这样的场景:两个线程并发调用Singleton.getInstance(),假设线程一先判断instance是否为null,即👆代码中code A进入到code B的位置。刚刚判断完毕后,JVM将CPU资源切换给线程二,由于线程一还没执行code B,所以instance仍然为空,因此线程二执行了new Singleton()操作。片刻之后,线程一被重新唤醒,它执行的仍然是new Singleton()操作,这样问题就来了,new出了两个instance,这还能叫单例吗?===>所以导致线程不安全啊。。。
4. 懒汉式(线程安全,同步方法)
在getInstance()前面加个synchronized锁就可以了。
评价:
- 解决了线程安全问题
- 效率太低了,每个线程在想获得类的实例时候,执行 getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了,后面的想获得该类实例,直接 return 就行了。方法进行同步效率太低
- 结论:在实际开发中,不推荐使用这种方式
//线程安全,效率低
class Singleton {
private static Singleton instance;
private Singleton() { //1. 私有化构造方法
}
public static synchronized Singleton getInstance() { //2.通过静态方法返回instance对象
if (instance==null) { // 3. 使用Singleton对象时才产生实例化对象操作
instance = new Singleton();
}
return instance;
}
public void print() {
System.out.println("Hello Singleton...");
}
}
比起懒汉式(线程不安全)仅仅在方法中多了一个synchronized修饰符,现在可以保证不会出线程问题了。但是这里有个很大(至少耗时比例上很大)的性能问题。除了第一次调用时是执行了Singleton的构造函数之外,以后的每一次调用都是直接返回instance对象。返回对象这个操作耗时是很小的,绝大部分的耗时都用在synchronized修饰符的同步准备上,因此从性能上来说很不划算。
5. 懒汉式(线程安全,同步代码块)
既解决了”懒汉式“的多线程问题,又解决了资源浪费的现象【但是也不推荐使用这种写法】
//【线程安全,效率高】
class Singleton {
private static Singleton instance;
private Singleton() { //1. 私有化构造方法
}
public static Singleton getInstance() { //2.通过静态方法返回instance对象
if (instance==null) { // 3. 使用Singleton对象时才产生实例化对象操作
synchronized (Singleton.class) {
instance = new Singleton();
}
}
return instance;
}
}
6. 双重检查(DCL,Double Check Lock)✨❤️❤️
评价:
- Double-Check 概念是多线程开发中常使用到的,如代码中所示,我们进行了两次 if (instance == null)检查,volatile关键字(禁止指令重排序)修饰变量instance,这样就可以保证线程安全了。
- 这样,实例化代码只用执行一次,后面再次访问时,判断 if (instance == null),直接 return 实例化对象,也避免的反复进行方法同步.
- 线程安全;延迟加载;效率较高
- 结论:在实际开发中,推荐使用这种单例设计模式
class Singleton {
//volatile关键字,禁止指令重排序
private static volatile Singleton instance;
private Singleton() {
}
//提供一个静态的公有方法,加入双重检查代码,解决线程安全问题, 同时解决懒加载问题
//同时保证了效率, 推荐使用
public static Singleton getInstance() {
if (instance == null) {//第一个判空条件(可删)是为了提高效率,减少synchronized带来的性能消耗
synchronized (Singleton.class) { //加synchronized是为了防止多个线程同时调用getInstance()方法,造成线程不安全
if (instance == null) {//第二个判空条件(不可删)是为了防止instance被多次初始化,不符合单例模式
instance = new Singleton();//JVM编译器会导致指令重排
}
}
}
return instance;
}
}
参考:DCL单例模式
假如上述的instance变量没有加volatile关键字可能会出现什么结果呢?
其实上面的instance = new Singleton() 会做三件事:
1)给instance实例分配内存;
2)初始化instance的构造器;
3)将instance对象指向分配的内存空间(这时instance就非null了)
但是由于JVM中为了优化指令,将指令进行重排序,真正执行的时候可能是1),3),2)的顺序,当线程A执行完3)之后,执行2)之前,现在instance被分配了内存空间,但是对象还没有初始化,这时CPU时间片分给了线程B,线程B进入第一个if (instance == null) 时发现instance为非null,那么会直接跳到程序结束return instance,最终结果就是会报错,出现对象未初始化异常。
。。。根据以上分析,知道加volatile关键字的重要性了吧,对,就是为了禁止指令重排序,从而进一步保证线程安全。
面试题:DCL单例模式为什么要两次判空?
回答参考:https://www.jianshu.com/p/17a39b71f8d9
7. 静态内部类✨
评价:
- 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
- 静态内部类方式在 Singleton 类被装载时并不会立即实例化,而是在需要实例化时,调用 getInstance 方法,才会装载 SingletonInstance 类,从而完成 Singleton 的实例化。
- 类的静态属性只会在第一次加载类的时候初始化,所以在这里,JVM 帮助我们保证了线程的安全性,在类进行初始化时,别的线程是无法进入的。
- 优点:避免了线程不安全,利用静态内部类特点实现延迟加载,效率高
- 结论:推荐使用.
//静态内部类完成, 推荐使用
class Singleton {
//构造器私有化
private Singleton() {
}
//写一个静态内部类,该类中有一个静态属性 Singleton
private static class SingletonInstance {
private static final Singleton INSTANCE = new Singleton();
}
//提供一个静态的公有方法,直接返回 SingletonInstance.INSTANCE
public static synchronized Singleton getInstance() {
return SingletonInstance.INSTANCE;
}
}
8. 枚举✨❤️
参考:单例模式
评价:
- 这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象。
- 这种方式是《Effective Java》作者Josh Bloch提倡的方式
- 结论:推荐使用
public class SingletonDemo {
//使用枚举,可以实现单例, 推荐
enum Singleton {
INSTANCE; //属性
}
public static void main(String[] args) {
Singleton instance = Singleton.INSTANCE;
Singleton instance2 = Singleton.INSTANCE;
System.out.println(instance == instance2);
System.out.println(instance.hashCode());
System.out.println(instance2.hashCode());
}
}
四、优点
- 对于使用频繁的对象,可以省略创建对象所花费的时间,这对于那些重量级对象而言,是非常客观的一笔系统开销。
- 由于new操作次数减少,因而对系统内存使用的频率也会降低,这将减轻GC压力,缩短GC停顿时间。
五、缺点
- 单例模式很难实现序列化,这就导致采用单例模式的类很难被持久化,当然也很难通过网络传输;
- 由于单例模式采用静态方法,无法在继承结构中使用。
六、适用场景
- 适用于只需要一个对象的情况
- 适用于不需要继承的情况
- 需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即:重量级对象),但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等)
七、实际应用
在我们的系统中,有些对象只需要一个,比如:线程池、缓存、对话框、注册表、日志对象、充当打印机,显卡等设备驱程序的对象。事实上,这类对象只能有一个实例,如果制造出多个实例就可能会导致一些问题的发生,比如程序的行为异常、资源使用过量、或者不一致的结果。
JDK应用源码分析
~~比如:在我们的java.lang包的Runtime类中,采用了单例模式(饿汉式,静态常量)。
~~原因:Runtime类封装了运行时的环境。每个 Java 应用程序都有一个 Runtime 类实例,并且只有一个实例,使应用程序能够与其运行的环境相连接。(所以说是单例模式)所以想得到当前运行的Runtime对象,需要通过 getRuntime 方法获取。