JAVA如何正确写出一个单例模式?看这里就够了

什么是单例模式?

保证一个类只有一个实例,且在类里面提供一个全局可以访问的入口。如图 Singleton 类,提供了一个 getInstance() 入口获取这个实例。
类图

为什么需要单例?

  • 节省内存
  • 节省计算
  • 保证结果的正确(需要一个全局的计数器)
  • 方便管理(很多工具类只需要一个实例)

很多类并不需要创建大量的实例。如:初始化时的类,在第一次构造的时候花了大量的时间进行初始化该对象。

public class ExpensiveResource {
    public ExpensiveResource () {
        field1 = // 查询数据库
        field2 = // 对查询的数据进行计算
        field3 = // 加密、压缩等耗时操作
    }
}

适用场景

适用场景

常见的单例模式写法

  • 饿汉式
  • 懒汉式
  • 双重检查式(又名double-check)
  • 静态内部类式
  • 枚举式(目前最好的实现方式)

下面就是从简单到最后的枚举式,逐步递增,去看看这个单例是怎么写的。各个方式有什么弊端,才最后产生了枚举式。

饿汉式

写法1public class Singleton {
    private static Singleton singlenton = new Singlention();
    
    private Singleton() {}
    
    public Singlenton getInstance() {
        return singlenton;
    }
}

---------------------------------------------------------
写法2public class Singleton() {
    private static Singleton singleton;
    
    static {
        singleton = new Singleton();
    }
    
    private Singleton() {}
    
    public Singlenton getInstance() {
        return singlenton;
    }
}

如上所示:

  1. static 来修饰实例
  2. 构造函数用 private 修饰
  3. 实例直接在加载时候 new.

写法最简单,在类装载的时候就实例化了,避免线程同步的问题。
但是 缺点是类加载就完成了实例化 。没有达到懒加载。

很明显,如果永远都用不上这个类的话,那就资源浪费了。所以产生了下面的懒汉式。

懒汉式

线程不安全的写法:

public class Singleton {
    private static Singleton singlenton;
    
    private Singleton() {}
    
    public Singlenton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

很明显在 getInstance() 中增加了判断,在获取的时候才去实例化。这个就是懒加载了。

但是注意了,这种只适合单线程,如果多线程,就会出现实例化多次的情况。场景重现:

线程1:进入了 if 语句,准备进行实例化。此时线程2进来了,线程1被挂起。

线程2:进入 if 语句,创建完实例后,切换回线程1 继续执行。

线程1:继续实例化 Singleton

这个时候就出现了初始化多次了。很明显多线程下->这是一个错误的写法

线程安全的写法(改写 getInstance()方法):

public class Singleton {
    private static Singleton singlenton;
    
    private Singleton() {}
    
    public static synchronized Singlenton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

增加锁,锁住整个方法。
但是缺点是:执行效率十分低。因为每个线程 getInstance() 都要进行同步,多个线程的时候,必须要等待一个一个的来。

所以我们再升级一下写法,再改改 getInstance():

public static Singlenton getInstance() {
    if (singleton == null) {
        synchronzied (Singleton.class) {
            singleton = new Singleton();    
        }
    }
    return singleton;
}

不过还是有问题的,一样的并发情况下,还是会出现上面线程不安全的问题。

左思右想,还是不行。所以最后为了解决这个问题。就出现了 double-check双重检查式。

双重检查式(double-check)

public class Singleton {
    private static volatile Singleton singlenton;
    
    private Singleton() {}
    
    public Singlenton getInstance() {
        if (singleton == null) {
            synchronzied (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

有几个地方发生了改变:

  • getInstance() 时进行了两次判断。
  • Singleton 增加了 volatile 可见性关键字,volatile和synchronized不同见我之前的博文:https://blog.csdn.net/Charlven/article/details/104463842。

通过 volatile 和 两次判空结合。就可以实现线程安全了。
优点:

  1. 线程安全
  2. 延迟加载
  3. 效率更高

可能有的小伙伴会不明白,为什么一定要两次 check,那我们来试试去掉其中一个check。

  1. 去掉第一个 check:很明显的,去掉第一个check,就会全部都进入同步了。效率很慢,原因上面已经说了。
  2. 去掉第二个 check:会出现并发问题。当singleton=null,同时两个线程都执行到第一个 check 时候,线程1进入sync代码块,线程2在外面等待;线程1执行完,线程2继续创建实例。就会同时创建了两个实例了。

为什么要 votatile 呢?

因为实例化 singleton 并不是一个原子性操作。JVM 可能存在着重排序。我们来看看实例化的流程:
实例化顺序
存在重排序完了之后变成:
重排序后

所以当多线程的时候,且执行顺序被重排序时,程序就会报错。详细我们来看看:

在这里插入图片描述

所以使用volatile的意义主要在于防止重排序的情况。避免拿到未完成初始化的对象。

静态内部类

public class Singleton {
    private Singleton() {}
    
    private static class SingletonInstance() {
        private static final Singleton singleton = new singleton(); 
    }
    
    public Singlenton getInstance() {
        return SingletonInstance.singleton;
    }
}

和饿汉式的方式类似。不过这个是通过 JVM 的方式保证了线程安全。
和饿汉式不一样的是,这个是懒加载模式的。也就是只有在 getInstance() 才去实例化。
所以静态内部类的写法跟双重检查式的优点是一致的。

  1. 线程安全
  2. 延迟加载,效率高。

看着似乎完美了,无可挑剔。但是静态内部类和双重检查式都存在着一个缺点:

可以被反序列化。通过反射可以创建多个实例。

所以这个时候就来一个终极推荐写法 ↓

枚举式

public enum Singleton {
    INSTANCE;
    private final App app;
    public Singleton() {
    	app = new App();
    }

	public App getInstance() {
		return app;
	}
    public void otherMethod() {
        
    }
}
---------------------------------
获取方式:
Singleton.INSTANCE.getInstance();

优点:

  1. 简洁
  2. 线程安全有保障
    1. 反编译可以看出都是 static代码块
    2. 在类被加载时完成初始化,加载由JVM保证线程安全
  3. 防止被反序列化破坏,反序列时只能根据valueOf方法来查看,而不能新建对象。
  4. 反射时是不能创建对象。

总结

单例主要就是

  • 饿汉式
  • 懒汉式
  • 双重检查式(又名double-check)
  • 静态内部类式
  • 枚举式(目前最好的实现方式)

上面几种,单线程时推荐使用懒汉式。而大多数建议后 3 种实现方式。

枚举式目前可能比较少人写,但是也是极为推荐的。最后该文章是参考了极客时间某篇课程输出的。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Charlven

你的鼓励将是我最大的动力哦

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值