在java程序中,有时候可能需要推迟一些高开销的对象初始化操作,并且只有在使用这些对象时才进行初始化。此时程序员可能会采用延迟初始化,这时候就有了创建单例的模式。
非线程安全的延迟初始化
public class SingletonDemo {
private static SingletonDemo singletonDemo;
public static SingletonDemo getInstance(){
if(singletonDemo == null){ //1行
singletonDemo = new SingletonDemo(); //2行
}
return singletonDemo;
}
}
非线程安全的单例加载会导致在高并发下,A线程执行到2行时,还没有创建成功,B线程执行到1时发现singleton == null,就进来创建,导致了对象的重复创建。而且在重排序情况下,可能导致A线程创建对象还没成功,B就引用了一个空对象,这个下面讲解
线程安全的延迟初始化
public class SingletonDemo {
private static SingletonDemo singletonDemo;
public synchronized static SingletonDemo getInstance(){
if(singletonDemo == null){ //1行
singletonDemo = new SingletonDemo(); //2行
}
return singletonDemo;
}
}
线程安全的单例模式解决了对象重复创建的问题,但是在高并发下,频繁调用getInstance()方法都需要加锁,导致了性能的下降。
双重检查锁定
public class SingletonDemo {
private static SingletonDemo singletonDemo;
public static SingletonDemo getInstance(){
if(singletonDemo == null){ //4.第一次检查
synchronized (SingletonDemo.class){ //5.加锁
if(singletonDemo == null){ //6.第二次检查
singletonDemo = new SingletonDemo(); //7.new对象
}
}
}
return singletonDemo;
}
}
双重检查锁定解决了:
- 在多个线程试图在同一时间创建对象时,会通过加锁来保证只有一个线程能创建对象
- 在对象创建好之后,执行getInstance()将不需要获取锁,直接返回已创建好的对象,保证了性能
但是
上面的双重检查锁定还是会存在问题:
在线程执行到第4行代码读取到instance不为null时,instance引用的对象有可能还没有完成初始化。
问题的根源
前面的双重检查锁定示例代码的第7行(singletonDemo = new SingletonDemo();)创建一个对象。这一行代码可以分解为如下的三行伪代码
memory = allocate(); //1:分配对象的内存空间
ctorInstance(memory); //2:初始化对象
instance = memory; //3:设置instance指向刚分配的内存地址
上面三行伪代码中的2和3之间,可能会被重排序,变成
memory = allocate(); //1:分配对象的内存空间
instance = memory; //3:设置instance指向刚分配的内存地址
//注意,此时对象还没有被初始化!
ctorInstance(memory); //2:初始化对象
所以执行的顺序可能是:
时间 | 线程A | 线程B |
---|---|---|
t1 | A1:分配对象的内存空间 | |
t2 | A3:设置instance指向内存空间 | |
t3 | B1:判断instance是否为空 | |
t4 | B2:由于instance不为null,线程B将访问instance引用的对象 | |
t5 | A2:初始化对象 | |
t6 | A4:访问instance引用的对象 |
这里A2和A3虽然重排序了,但java内存模型的intra-thread semantics将确保A2一定会排在A4前面执行。因此线程A的intra-thread semantics没有改变。但A2和A3的重排序,将导致线程B在B1处判断出instance不为空,线程B接下来将访问instance引用的对象。此时,线程B将会访问到一个还未初始化的对象
基于volatile的双重检查锁定的解决方案(把instance声明为volatile型)
public class SingletonDemo {
private static volatile SingletonDemo singletonDemo;
public static SingletonDemo getInstance(){
if(singletonDemo == null){ //4.第一次检查
synchronized (SingletonDemo.class){ //5.加锁
if(singletonDemo == null){ //6.第二次检查
singletonDemo = new SingletonDemo(); //7.new对象
}
}
}
return singletonDemo;
}
}
volatite保证了多线程环境下行伪代码中的2和3之间的重排序被禁止。
(不懂volatite可以看Java多线程干货系列—(四)volatile关键字)
基于类初始化的解决方案
public class InstanceFactory {
private static class InstanceHolder {
public static Instance instance = new Instance();
}
public static Instance getInstance() {
return InstanceHolder.instance ; //这里将导致InstanceHolder类被初始化
}
}
基于CAS的单例模式
private static AtomicReference singletonDemoAtomicReference = new AtomicReference();
public static SingletonDemo getInstanceByCAS(){
for(;;){
SingletonDemo singletonDemo = singletonDemoAtomicReference.get();
if(singletonDemo != null){
return singletonDemo;
}
singletonDemo = new SingletonDemo();
if(singletonDemoAtomicReference.compareAndSet(null,singletonDemo)){
return singletonDemo;
}
}
}
用CAS的好处在于不需要使用传统的锁机制来保证线程安全,CAS是一种基于忙等待的算法,依赖底层硬件的实现,相对于锁它没有线程切换和阻塞的额外消耗,可以支持较大的并行度。CAS的一个重要缺点在于如果忙等待一直执行不成功(一直在死循环中),会对CPU造成较大的执行开销。
参考
https://blog.csdn.net/li295214001/article/details/48135939/