正确并且可以做到延迟加载的写法其实就是三种:
使用volatile修饰变量并且双重校验的写法。
使用静态内部类来实现(类A有一个静态内部类B,类B有一个静态变量instance,类A的getInstance()方法会返回类B的静态变量instance,因为只有调用getInstance()方法时才会加载静态内部类B,这种写法缺点是不能传参。)
使用枚举来实现()
第1种 不加锁(裸奔写法)
多线程执行时,可能会在instance完成初始化之前,其他线性线程判断instance为null,从而也执行第二步的代码,导致初始化覆盖。
public class UnsafeLazyInitialization {
private static Instance instance;
public static Instance getInstance() {
if (instance == null) //1
instance = new Instance(); //2
}
return instance;
}
第2种-对方法加sychronize锁(俗称的懒汉模式)
初始化完成以后,每次调用getInstance()方法都需要获取同步锁,导致不必要的开销。
public class Singleton {
private static Singleton instance;
public synchronized static Singleton getInstance() {
if (instance == null)
instance = new Instance();
return instance;
}
}
第3种-使用静态变量(俗称的饿汉模式)
public class Singleton {
private static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance;
}
}
这种方法是缺点在于不能做到延时加载,在第一次调用getInstance()方法之前,如果Singleton类被使用到,那么就会对instance变量初始化。
第4种-使用双重检查锁定
代码如下:
public class Singleton {
private static Singleton instance;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) { //双重检查存在的意义在于可能会有多个线程进入第一个判断,然后竞争同步锁,线程A得到了同步锁,创建了一个Singleton实例,赋值给instance,然后释放同步锁,此时线程B获得同步锁,又会创建一个Singleton实例,造成初始化覆盖。
instance = new Singleton();
}
}
}
return instance;
}
}
instance = new Singleton();
这句代码在执行时会分解为三个步骤:
1.为对象分配内存空间。
2.执行初始化的代码。
3.将分配好的内存地址设置给instance引用。
但是编译器会对指令进行重排序,只能保证单线程执行时结果不会变化,也就是可能第3步会在第2步之前执行,某个线程A刚好执行完第3步,正在执行第2步时,此时如果有其他线程B进入if (instance == null)判断,会发现instance不为null,然后将instance返回,但是实际上instance还没有完成初始化,线程B会访问到一个未初始化完成的instance对象。
第5种 基于 volatile 的双重检查锁定的解决方案
代码如下:
public class Singleton {
private volatile static Singleton instance;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null)//双重检查存在的意义在于可能会有多个线程进入第一个判断,然后竞争同步锁,线程A得到了同步锁,创建了一个Singleton实例,赋值给instance,然后释放同步锁,此时线程B获得同步锁,又会创建一个Singleton实例,造成初始化覆盖。
instance = new Singleton();
}
}
return instance;
}
}
volatile可以保证变量的内存可见性及防止指令重排。
volatile修饰的变量在编译后,会多出一个lock前缀指令,lock前缀指令相当于一个内存屏障(内存栅栏),有三个作用:
确保指令重排序时,内存屏障前的指令不会排到后面去,内存屏障后的指令不会排到前面去。
强制对变量在线程工作内存中的修改操作立即写入到物理内存。
如果是写操作,会导致其他CPU中对这个变量的缓存失效,强制其他CPU中的线程在获取变量时从物理内存中获取更新后的值。
所以使用volatile修饰后不会出现第3种写法中由于指令重排序导致的问题。
第6种 – 使用静态内部类来实现
private static class Signleton {
private static Signleton instance = new Signleton();
}
public static Signleton getInstance() {
return Signleton.instance ; // 这里将导致 Signleton 类被初始化
}
因为JVM底层通过加锁实现,保证一个类只会被加载一次,多个线程在对类进行初始化时,只有一个线程会获得锁,然后对类进行初始化,其他线程会阻塞等待。所以可以使用上面的代码来保证instance只会被初始化一次,这种写法的问题在于创建
7.使用枚举来实现单例
public enum Singleton {
//每个元素就是一个单例
INSTANCE;
//自定义的一些方法
public void method(){}
}
这种写法比较简洁,但是不太便于阅读和理解,所以实际开发中应用得比较少,而且由于枚举类是不能通过反射来创建实例的(反射方法newInstance中判断是枚举类型,会抛出IllegalArgumentException异常),所以可以防止反射。而且由于枚举类型的反序列化是通过java.lang.Enum的valueOf方法来实现的,不能自定义序列化方法,可以防止通过序列化来创建多个单例。
原创文章,作者:9IM,如若转载,请注明出处:https://www.9im.cn/695.html