关于单例模式的理解(二)
在上一篇中我们简单的说了一些关于单例模式的简单知识,这篇就让我们来深入的探讨一下关于懒汉模式的优化。
之前我们说到,懒汉模式是常用的,但是它又是线程不安全的,所以我们自然而然的会想到使用同步代码的关键字synchronized来修饰getInstance()方法,如下图所示
/**
* 懒汉模式
* 单例实例在第一次使用时进行创建
*/
@ThreadSafe
@NotRecommend
public class SingletonExample3 {
// 私有构造函数
private SingletonExample3() {}
// 单例对象
private static SingletonExample3 instance = null;
// 静态的工厂方法
public static synchronized SingletonExample3 getInstance() {
if (instance == null) {
instance = new SingletonExample3();
}
return instance;
}
}
这样就是线程安全了,但是使用synchronized这样的阻塞同步,即同一时刻只有一个线程来访问的方式是会有比较大的性能开销的,这是我们所不希望看到的,所以不太推荐。
于是,有聪明的小伙伴一定会想到,你之前的那个是synchronized修饰方法的,我只要将其放进方法内只需要同步必要的代码不就好了,如下图所示
/**
* 懒汉模式 -> 双重同步锁单例模式
*/
@NotThreadSafe
public class SingletonExample4 {
// 私有构造函数
private SingletonExample4() {}
// 单例对象
private static SingletonExample4 instance = null;
// 静态的工厂方法
public static SingletonExample4 getInstance() {
if (instance == null) { // 双重检测机制
synchronized (SingletonExample4.class) { // 同步锁
if (instance == null) {
instance = new SingletonExample4();
}
}
}
return instance;
}
}
这时候,很多小伙伴就觉得这样很ok啊,的确啊,看上去比较华丽,但我想提醒的这样的写法是线程不安全的。肯定有小伙伴会觉得懵逼,这怎么就线程不安全了,且听我为你娓娓道来。
首先我们需要了解的是,CPU的指令,当我们在instance = new SingletonExample4();执行的时候,我们将其放大细化,主要是分成三步:
// 1、memory = allocate() 分配对象的内存空间
// 2、ctorInstance() 初始化对象
// 3、instance = memory 设置instance指向刚分配的内存
上述三步骤,在经过jvm的指令优化后,其第二点和第三点会步骤互换
// JVM和cpu优化,发生了指令重排
// 1、memory = allocate() 分配对象的内存空间
// 3、instance = memory 设置instance指向刚分配的内存
// 2、ctorInstance() 初始化对象
所以我们现在假设有A,B两个线程,当A线程走到132中的三,这时候B到if(instance == null)那边就会发现,原来instance已经有值了,就直接返回了,然而啥都还没发生呢,你就完事了。因为还没有实例呢。。。,这时候肯定会出现问题。
@NotThreadSafe
public class SingletonExample4 {
// 私有构造函数
private SingletonExample4() {}
// 1、memory = allocate() 分配对象的内存空间
// 2、ctorInstance() 初始化对象
// 3、instance = memory 设置instance指向刚分配的内存
// JVM和cpu优化,发生了指令重排
// 1、memory = allocate() 分配对象的内存空间
// 3、instance = memory 设置instance指向刚分配的内存
// 2、ctorInstance() 初始化对象
// 单例对象
private static SingletonExample4 instance = null;
// 静态的工厂方法
public static SingletonExample4 getInstance() {
if (instance == null) { // 双重检测机制 // B
synchronized (SingletonExample4.class) { // 同步锁
if (instance == null) {
instance = new SingletonExample4(); // A - 3
}
}
}
return instance;
}
}
虽然这个几率不大,但严格的说这并不是线程安全的。那么什么关键字能防止指令的重排序呢?熟悉的同学,一定会想到一个关键字,没错,就是volatile, 就是那个能有可见性,防指令重排却没有原子性的volatile。如下如代码所示:
@ThreadSafe
public class SingletonExample5 {
// 私有构造函数
private SingletonExample5() {}
// 1、memory = allocate() 分配对象的内存空间
// 2、ctorInstance() 初始化对象
// 3、instance = memory 设置instance指向刚分配的内存
// 单例对象 volatile + 双重检测机制 -> 禁止指令重排
private volatile static SingletonExample5 instance = null;
// 静态的工厂方法
public static SingletonExample5 getInstance() {
if (instance == null) { // 双重检测机制 // B
synchronized (SingletonExample5.class) { // 同步锁
if (instance == null) {
instance = new SingletonExample5(); // A - 3
}
}
}
return instance;
}
}
这样的话,就是一个比较好的实现方式。
这里,我还要加上一种模式,也就是枚举模式,这种也是我从在单位里leader提示的,然后根据多方学习整理的,如下图所示:
/**
* 枚举模式:最安全
*/
@ThreadSafe
@Recommend
public class SingletonExample7 {
// 私有构造函数
private SingletonExample7() {}
public static SingletonExample7 getInstance() {
return Singleton.INSTANCE.getInstance();
}
private enum Singleton {
INSTANCE;
private SingletonExample7 singleton;
// JVM保证这个方法绝对只调用一次
Singleton() {
singleton = new SingletonExample7();
}
public SingletonExample7 getInstance() {
return singleton;
}
}
}
这是一种基于枚举的实现单例的方式。