JAVA如何正确写出一个单例模式？看这里就够了
保证一个类只有一个实例，且在类里面提供一个全局可以访问的入口。如图 Singleton 类，提供了一个 getInstance() 入口获取这个实例。
为什么需要单例？
- 节省内存
- 节省计算
- 保证结果的正确（需要一个全局的计数器）
- 方便管理（很多工具类只需要一个实例）
很多类并不需要创建大量的实例。如：初始化时的类，在第一次构造的时候花了大量的时间进行初始化该对象。
public class ExpensiveResource {
public ExpensiveResource () {
field1 = // 查询数据库
field2 = // 对查询的数据进行计算
field3 = // 加密、压缩等耗时操作
}
}
复制代码
适用场景
常见的单例模式写法
- 饿汉式
- 懒汉式
- 双重检查式(又名double-check)
- 静态内部类式
- 枚举式(目前最好的实现方式)
下面就是从简单到最后的枚举式，逐步递增，去看看这个单例是怎么写的。各个方式有什么弊端，才最后产生了枚举式。
饿汉式
写法1：
public class Singleton {
private static Singleton singlenton = new Singlention();
private Singleton() {}
public Singlenton getInstance() {
return singlenton;
}
}
---------------------------------------------------------
写法2：
public class Singleton() {
private static Singleton singleton;
static {
singleton = new Singleton();
}
private Singleton() {}
public Singlenton getInstance() {
return singlenton;
}
}
复制代码
如上所示：
- static 来修饰实例
- 构造函数用 private 修饰
- 实例直接在加载时候 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 synchronized 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不同见我之前的博文： blog.csdn.net/Charlven/ar…
通过 volatile 和 两次判空结合。就可以实现线程安全了。 优点：
- 线程安全
- 延迟加载
- 效率更高
可能有的小伙伴会不明白，为什么一定要两次 check，那我们来试试去掉其中一个check。
- 去掉第一个 check：很明显的，去掉第一个check，就会全部都进入同步了。效率很慢，原因上面已经说了。
- 去掉第二个 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() 才去实例化。 所以静态内部类的写法跟双重检查式的优点是一致的。
- 线程安全
- 延迟加载，效率高。
看着似乎完美了，无可挑剔。但是静态内部类和双重检查式都存在着一个缺点：
可以被反序列化。通过反射可以创建多个实例。
所以这个时候就来一个终极推荐写法 ↓
枚举式
public enum Singleton {
INSTANCE;
public void whateverMethod() {
}
}
复制代码
优点：
- 简洁
- 线程安全有保障
- 反编译可以看出都是 static代码块
- 在类被加载时完成初始化，加载由JVM保证线程安全
- 防止被反序列化破坏，反序列时只能根据valueOf方法来查看，而不能新建对象。
- 反射时是不能创建对象。
正文到此结束
热门推荐
相关文章
Loading...
![[HBLOG]公众号](https://www.liuhaihua.cn/img/qrcode_gzh.jpg)
