Java中单例有哪些写法？

正确并且可以做到延迟加载的写法其实就是三种： 1.使用volatile修饰变量并且双重校验的写法来实现。 2.使用静态内部类来实现（类A有一个静态内部类B，类B有一个静态变量instance，类A的getInstance()方法会返回类B的静态变量instance，因为只有调用getInstance()方法时才会加载静态内部类B，这种写法缺点是不能传参。） 3.使用枚举来实现 ### 第1种 不加锁（裸奔写法） 多线程执行时，可能会在instance完成初始化之前，其他线性线程判断instance为null，从而也执行第二步的代码，导致初始化覆盖。 ```java public class UnsafeLazyInitialization { private static Instance instance; public static Instance getInstance() { if (instance == null) //1 instance = new Instance(); //2 } return instance; } ``` ### 第2种-对方法加sychronize锁(俗称的懒汉模式) 初始化完成以后，每次调用getInstance()方法都需要获取同步锁，导致不必要的开销。 ```java public class Singleton { private static Singleton instance; public synchronized static Singleton getInstance() { if (instance == null) instance = new Instance(); return instance; } } ``` ### 第3种-使用静态变量(俗称的饿汉模式) ```java public class Singleton { private static Singleton instance = new Singleton(); public static Singleton getInstance() { return instance; } } ``` 这种方法是缺点在于不能做到延时加载，在第一次调用getInstance()方法之前，如果Singleton类被使用到，那么就会对instance变量初始化。 ### 第4种-使用双重检查锁定 代码如下： ```java 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来修饰变量，防止重排序。 ### 第5种 基于 volatile 的双重检查锁定的解决方案 代码如下： ```java 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种 - 使用静态内部类来实现 ```java class Test { public static Signleton getInstance() { return Signleton.instance ; // 只有调用getInstance()方法时，才会引用到静态内部类Signleton，从而会触发Signleton类的instance变量的初始化，以此实现懒加载的目的。 } private static class Signleton { private static Signleton instance = new Signleton(); } } ``` 因为JVM底层通过加锁实现，保证一个类只会被加载一次，多个线程在对类进行初始化时，只有一个线程会获得锁，然后对类进行初始化，其他线程会阻塞等待。所以可以使用上面的代码来保证instance只会被初始化一次，这种写法的问题在于创建单例时不能传参。 ### 7.使用枚举来实现单例 ```java public enum Singleton { //每个元素就是一个单例 INSTANCE; //自定义的一些方法 public void method(){} } ``` 这种写法比较简洁，但是不太便于阅读和理解，所以实际开发中应用得比较少，而且由于枚举类是不能通过反射来创建实例的(反射方法newInstance中判断是枚举类型，会抛出IllegalArgumentException异常)，所以可以防止反射。而且由于枚举类型的反序列化是通过java.lang.Enum的valueOf方法来实现的，不能自定义序列化方法，可以防止通过序列化来创建多个单例。