java 中单例_Java中单例有哪些写法

正确并且可以做到延迟加载的写法其实就是三种：

使用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